st34an test wiki - User contributions [en]

Template:Tracking/inflection of/tag/second-person

2026-04-10T07:29:56Z

Jsrs701: 1 revision imported

<noinclude>==Subpages==
{{Special:PrefixIndex/{{FULLPAGENAME}}/|stripprefix=1}}[[Category:Tracking templates]]</noinclude>

Template:Tracking/inflection of/tag/intransitive

2026-04-10T07:29:56Z

Jsrs701: 1 revision imported

<noinclude>==Subpages==
{{Special:PrefixIndex/{{FULLPAGENAME}}/|stripprefix=1}}[[Category:Tracking templates]]</noinclude>

Template:Kezh-noun-decl

2026-04-10T07:29:56Z

Jsrs701: 1 revision imported

{| class="wikitable"
! style="width:100px; background-color: #00E8FF;"|
! style="text-align: center; background-color: #DDF8FF;"| Singular
! style="text-align: center; background-color: #DDF8FF;"| Plural
|-
| style="text-align: center; background-color: #DDF8FF;"| '''Definite'''
| style="text-align: center;" | [[{{{inic}}}{{{root}}}{{{finc}}}]]
| rowspan="2" style="text-align: center;" | [[an]] [[{{#if: {{{inic|}}} | {{#switch: {{{inic}}} | p = b | P = B | t = d | T = D | k = g | K = G | f = v | F = V | th = dh | Th = Dh | s = z | S = Z | sh = zh | Sh = Zh | {{{inic}}}}} | }}{{{root}}}{{{finc}}}]]
|-
| style="text-align: center; background-color: #DDF8FF;"| '''Indefinite'''
| style="text-align: center;" | [[{{#if: {{{inic|}}} | {{#switch: {{{inic}}} | p = i-b | P = i-B | t = i-d | T = i-D | k = i-g | K = i-G | f = i-v | F = i-V | th = i-dh | Th = i-Dh | s = i-z | S = i-Z | sh = i-zh | Sh = i-Zh | i-{{{inic}}}}} | {{#if: {{{i|}}} | zh- | y- }}}}{{{root}}}{{{finc}}}]]
|-
| style="text-align: center; background-color: #DDF8FF;"| '''Proximal'''
| style="text-align: center;" | [[{{{inic}}}{{{dem}}}{{#if: {{{finc|}}} | {{#switch: {{{finc}}} | p = bagí | t = dagí | k = gagí | f = vagí | th = dhagí | s = zagí | sh = zhagí | {{{finc}}}agí}} | gí}}]]
| style="text-align: center;" | [[an]] [[{{#if: {{{inic|}}} | {{#switch: {{{inic}}} | p = b | P = B | t = d | T = D | k = g | K = G | f = v | F = V | th = dh | Th = Dh | s = z | S = Z | sh = zh | Sh = Zh | {{{inic}}}}} | }}{{{dem}}}{{#if: {{{finc|}}} | {{#switch: {{{finc}}} | p = bagí | t = dagí | k = gagí | f = vagí | th = dhagí | s = zagí | sh = zhagí | {{{finc}}}agí}} | gí}}]]
|-
| style="text-align: center; background-color: #DDF8FF;"| '''Distal'''
| style="text-align: center;" | [[{{{inic}}}{{{dem}}}{{#if: {{{finc|}}} | {{#switch: {{{finc}}} | p = bayá | t = dayá | k = gayá | f = vayá | th = dhayá | s = zayá | sh = zhayá | {{{finc}}}ayá}} | yá}}]]
| style="text-align: center;" | [[an]] [[{{#if: {{{inic|}}} | {{#switch: {{{inic}}} | p = b | P = B | t = d | T = D | k = g | K = G | f = v | F = V | th = dh | Th = Dh | s = z | S = Z | sh = zh | Sh = Zh | {{{inic}}}}} | }}{{{dem}}}{{#if: {{{finc|}}} | {{#switch: {{{finc}}} | p = bayá | t = dayá | k = gayá | f = vayá | th = dhayá | s = zayá | sh = zhayá | {{{finc}}}ayá}} | yá}}]]
|}<noinclude>[[Category:Kezhwa templates]]</noinclude>

Template:Tracking/headword/pagename spelling mismatch/kezh

2026-04-10T07:29:56Z

Jsrs701: 1 revision imported

<noinclude>==Subpages==
{{Special:PrefixIndex/{{FULLPAGENAME}}/|stripprefix=1}}[[Category:Tracking templates]]</noinclude>

Template:Also wt

2026-04-10T07:29:56Z

Jsrs701: 1 revision imported

''See also:'' '''[[Wiktionary:{{{1|{{#ifeq: {{NAMESPACENUMBER}}|0|{{lcfirst:{{PAGENAME}}}}|{{FULLPAGENAME}}}}}}}{{#ifeq: {{NAMESPACENUMBER}}|0|#{{{lang1|English}}}}}|{{{1|{{#ifeq: {{NAMESPACENUMBER}}|0|{{lcfirst:{{PAGENAME}}}}|{{FULLPAGENAME}}}}}}}]]''' {{#if: {{{2|}}} |''and'' '''[[Wiktionary:{{{2|{{#ifeq: {{NAMESPACENUMBER}}|0|{{lcfirst:{{PAGENAME}}}}|{{FULLPAGENAME}}}}}}}{{#ifeq: {{NAMESPACENUMBER}}|0|#{{{lang2|English}}}}}|{{{2|{{#ifeq: {{NAMESPACENUMBER}}|0|{{lcfirst:{{PAGENAME}}}}|{{FULLPAGENAME}}}}}}}]]'''}} ''on [[Wiktionary:Wiktionary:Main Page|Wiktionary]]''<noinclude>[[Category:Templates]]</noinclude>

Template:Tracking/headword/pagename spelling mismatch/sond

2026-04-10T07:29:56Z

Jsrs701: 1 revision imported

<noinclude>==Subpages==
{{Special:PrefixIndex/{{FULLPAGENAME}}/|stripprefix=1}}[[Category:Tracking templates]]</noinclude>

Template:Sond-orth

2026-04-10T07:29:55Z

Jsrs701: 1 revision imported

<span style="font-family: Sondiv; font-weight:normal !important;">{{huge|valign=normal|{{{form}}}}}</span><noinclude>[[Category:Sondiv templates]][[Category:Orthography templates]]</noinclude>

Template:Borrowed

2026-04-10T07:29:55Z

Jsrs701: 1 revision imported

{{#invoke:etymology/templates|borrowed}}<includeonly>{{#if:{{{withtext|}}}|[[Category:bor with withtext]]}}</includeonly><noinclude>{{documentation}}</noinclude>

Template:Bor

2026-04-10T07:29:55Z

Jsrs701: 1 revision imported

#REDIRECT [[Template:borrowed]]

Template:Prefix

2026-04-10T07:29:55Z

Jsrs701: 1 revision imported

{{#invoke:affix/templates|prefix}}<noinclude>{{documentation}}</noinclude>

Module:Affix/templates

2026-04-10T07:29:55Z

Jsrs701: 1 revision imported

local export = {}

local m_affix = require("Module:affix")
local m_languages = require("Module:languages")
local pseudo_loan_module = "Module:affix/pseudo-loan"
local put -- initialized once, when needed, to require("Module:parse utilities")

local rsplit = mw.text.split

-- Per-param modifiers, which can be specified either as separate parameters (e.g. t2=, pos3=) or as inline modifiers
-- <t:...>, <pos:...>, etc. The key is the name fo the parameter (e.g. "t", "pos") and the value is a table with
-- elements as follows:
-- * `extra_specs`: An optional table of extra key-value pairs to add to the spec used for parsing the parameter
-- when specified as a separate parameter (e.g. {type = "boolean"} for a Boolean parameter, or
-- {alias_of = "t"} for the "gloss" parameter, which is aliased to "t"), on top of the default, which
-- is {list = true, allow_holes = true, require_index = true}.
-- * `convert`: An optional function to convert the raw argument into the form passed to [[Module:affix]].
-- This function takes four parameters: (1) `arg` (the raw argument); (2) `inline` (true if we're
-- processing an inline modifier, false otherwise); (3) `term_index` (the actual index of the first term);
-- (4) `i` (the logical index of the term being processed, starting from 1).
-- * `item_dest`: The name of the key used when storing the parameter's value into the processed `parts` list.
-- Normally the same as the parameter's name. Different in the case of "t", where we store the gloss in
-- "gloss", and "g", where we store the genders in "genders".
-- * `param_key`: The name of the key used in the `params` spec passed to [[Module:parameters]]. Normally the same as
-- the parameter's name. Different in the case of "lit", "sc", etc. where e.g. we distinguish per-term
-- parameters "lit1", "lit2", etc. from the overall parameter "lit".
local param_mods = {
t = {
-- We need to store the t1=/t2= param and the <t:...> inline modifier into the "gloss" key of the parsed part,
-- because that is what [[Module:affix]] expects.
item_dest = "gloss",
},
gloss = {
-- The `extra_specs` handles the fact that "gloss" is an alias of "t".
extra_specs = {alias_of = "t"},
},
tr = {},
ts = {},
g = {
-- We need to store the g1=/g2= param and the <g:...> inline modifier into the "genders" key of the parsed part,
-- because that is what [[Module:affix]] expects.
item_dest = "genders",
convert = function(arg, inline, term_index, i)
return rsplit(arg, ",")
end,
},
id = {},
alt = {},
q = {},
qq = {},
lit = {
-- lit1=, lit2=, ... are different from lit=; the former describe the literal meaning of an individual argument
-- while the latter applies to the expression as a whole and appears after them at the end. To handle this in
-- separate parameters, we need to set the key in the `params` object passed to [[Module:parameters]] to
-- something else (in this case "partlit") and set `list = "lit"` in the value of the `params` object. This
-- causes [[Module:parameters]] to fetch parameters named lit1=, lit2= etc. but store them into "partlit", while
-- lit= is stored into "lit".
param_key = "partlit",
extra_specs = {list = "lit"},
},
pos = {
-- pos1=, pos2=, ... are different from pos=; the former indicate the part of speech of an individual argument
-- and appear in parens after the term (similar to the pos= argument to {{l}}), while the latter applies to the
-- expression as a whole and controls the names of various categories. We handle the distinction identically to
-- lit1= etc. vs. lit=; see above.
param_key = "partpos",
extra_specs = {list = "pos"},
},
lang = {
-- lang1=, lang2=, ... are different from 1=; the former set the language of individual arguments that are
-- different from the overall language specified in 1=. Note that the preferred way of specifying a different
-- language for a given individual argument is using a language-code prefix, e.g. 'la:minūtia' or
-- 'grc:[[σκῶρ|σκατός]]', instead of using langN=. Since for compatibility purposes we may support lang= as
-- a synonym of 1=, we can't store langN= in "lang". Instead we do the same as for lit1= etc. vs. lit= above.
-- In addition, we need a conversion function to convert from language codes to language objects, which needs
-- to conditionalize the `param` parameter of `getByCode` of [[Module:languages]] on whether the param is
-- inline. (This only affects the error message.)
param_key = "partlang",
extra_specs = {list = "lang"},
convert = function(arg, inline, term_index, i)
-- term_index + i - 1 because we want to reference the actual term param name, which offsets from
-- `term_index` (the index of the first term); subtract 1 since i is one-based.
return m_languages.getByCode(arg, inline and "" .. (term_index + i - 1) .. ":lang" or "lang" .. i, "allow etym")
end,
},
sc = {
-- sc1=, sc2=, ... are different from sc=; the former apply to individual arguments when lang1=, lang2=, ...
-- is specified, while the latter applies to all arguments where langN=... isn't specified. We handle the
-- distinction identically to lit1= etc. vs. lit=; see above. In addition, we need a conversion function to
-- convert from script codes to script objects, which needs to conditionalize the `param` parameter of
-- `getByCode` of [[Module:scripts]] on whether the param is inline. (This only affects the error message.)
param_key = "partsc",
extra_specs = {list = "sc"},
convert = function(arg, inline, term_index, i)
-- term_index + i - 1 same as above for "lang".
return require("Module:scripts").getByCode(arg, inline and "" .. (term_index + i - 1) .. ":sc" or "sc" .. i)
end,
},
}

local function get_valid_prefixes()
local valid_prefixes = {}
for param_mod, _ in pairs(param_mods) do
table.insert(valid_prefixes, param_mod)
end
table.sort(valid_prefixes)
return valid_prefixes
end

local function fetch_script(sc, param)
return sc and require("Module:scripts").getByCode(sc, param) or nil
end

-- Parse raw arguments in `args`. If `extra_params` is specified, it should be a one-argument function that is called
-- on the `params` structure before parsing; its purpose is to specify additional allowed parameters or possibly disable
-- parameters. If `has_source` is given, there is a source-language parameter following 1= (which becomes the
-- "destination" language parameter) and preceding the terms. This is currently used for {{pseudo-loan}}. The
-- source-language parameter is allowed to be an etymology-only language while the language in 1= is currently not so
-- allowed (FIXME: should we change this?). Returns five values ARGS, TERM_INDEX, LANG_OBJ, SCRIPT_OBJ, SOURCE_LANG_OBJ
-- where ARGS is a table of the parsed arguments; TERM_INDEX is the argument containing all the terms; LANG_OBJ is the
-- language object corresponding to the language code specified in 1=; SCRIPT_OBJ is the script object corresponding to
-- sc= (if given, otherwise nil); and SOURCE_LANG_OBJ is the language object corresponding to the source-language code
-- specified in 2= if `has_source` is specified (otherwise nil).
local function parse_args(args, extra_params, has_source, ilangcode)
if args.lang then
error("The |lang= parameter is not used by this template. Place the language code in parameter 1 instead.")
end

local term_index = (ilangcode and 1 or 2) + (has_source and 1 or 0)
local params = {
[term_index] = {list = true, allow_holes = true},

["lit"] = {},
["sc"] = {},
["pos"] = {},
["sort"] = {},
}

if not ilangcode then
params[1] = {required = true, default = "und"}
end

local source_index
if has_source then
source_index = term_index - 1
params[source_index] = {required = true, default = "und"}
end

local default_param_spec = {list = true, allow_holes = true, require_index = true}
for param_mod, param_mod_spec in pairs(param_mods) do
local param_key = param_mod_spec.param_key or param_mod
if not param_mod_spec.extra_specs then
params[param_key] = default_param_spec
else
local param_spec = mw.clone(default_param_spec)
for k, v in pairs(param_mod_spec.extra_specs) do
param_spec[k] = v
end
params[param_key] = param_spec
end
end

if extra_params then
extra_params(params)
end

args = require("Module:parameters").process(args, params)
local lang
if ilangcode then
lang = m_languages.getByCode(ilangcode, true)
else
lang = m_languages.getByCode(args[1], 1)
end
local source
if has_source then
source = m_languages.getByCode(args[source_index], source_index, "allow etym")
end
return args, term_index, lang, fetch_script(args["sc"], "sc"), source
end

-- Return an object containing all the properties of the `i`th term. `template` is the name of the calling template
-- (used only in the debug-tracking mechanism). `args` is the arguments as returned by parse_args(). `term_index` is
-- the argument containing all the terms. This handles all the complexities of fetching all the properties associated
-- with a term either out of separate parameters (e.g. pos3=, g2=) or from inline modifiers (e.g.
-- 'term<pos:noun><g:m-p>'). It also handles parsing off a separate language code attached to the beginning of a term or
-- specified using langN= or <lang:CODE>.
local function get_parsed_part(template, args, term_index, i)
local part = {}
local term = args[term_index][i]

if not (term or args["alt"][i] or args["tr"][i] or args["ts"][i]) then
require("Module:debug/track")(template .. "/no term or alt or tr")
return nil
end

-- Parse all the term-specific parameters and store in `part`.
for param_mod, param_mod_spec in pairs(param_mods) do
local dest = param_mod_spec.item_dest or param_mod
local param_key = param_mod_spec.param_key or param_mod
local arg = args[param_key][i]
if arg then
if param_mod_spec.convert then
arg = param_mod_spec.convert(arg, false, term_index, i)
end
part[dest] = arg
end
end

-- Remove and remember an initial exclamation point from the term, and parse off an initial language code (e.g.
-- 'la:minūtia' or 'grc:[[σκῶρ|σκατός]]').
if term then
local termlang, actual_term = term:match("^([A-Za-z0-9._-]+):(.*)$")
if termlang and termlang ~= "w" then -- special handling for w:... links to Wikipedia
-- -1 since i is one-based
termlang = m_languages.getByCode(termlang, term_index + i - 1, "allow etym")
term = actual_term
else
termlang = nil
end
if part.lang and termlang then
error(("Both lang%s= and a language in %s= given; specify one or the other"):format(i, i + 1))
end
part.lang = part.lang or termlang
part.term = term
end

-- Check for inline modifier, e.g. מרים<tr:Miryem>. But exclude HTML entry with <span ...>, <i ...>, <br/> or
-- similar in it, caused by wrapping an argument in {{l|...}}, {{af|...}} or similar. Basically, all tags of
-- the sort we parse here should consist of a less-than sign, plus letters, plus a colon, e.g. <tr:...>, so if
-- we see a tag on the outer level that isn't in this format, we don't try to parse it. The restriction to the
-- outer level is to allow generated HTML inside of e.g. qualifier tags, such as foo<q:similar to {{m|fr|bar}}>.
if term and term:find("<") and not term:find("^[^<]*<[a-z]*[^a-z:]") then
if not put then
put = require("Module:parse utilities")
end
local run = put.parse_balanced_segment_run(term, "<", ">")
local function parse_err(msg)
error(msg .. ": " .. (i + 1) .. "=" .. table.concat(run))
end
part.term = run[1]

for j = 2, #run - 1, 2 do
if run[j + 1] ~= "" then
parse_err("Extraneous text '" .. run[j + 1] .. "' after modifier")
end
local modtext = run[j]:match("^<(.*)>$")
if not modtext then
parse_err("Internal error: Modifier '" .. modtext .. "' isn't surrounded by angle brackets")
end
local prefix, arg = modtext:match("^([a-z]+):(.*)$")
if not prefix then
parse_err(("Modifier %s lacks a prefix, should begin with one of %s followed by a colon"):format(
run[j], table.concat(get_valid_prefixes(), ",")))
end
if not param_mods[prefix] then
parse_err(("Unrecognized prefix '%s' in modifier %s, should be one of %s"):format(
prefix, run[j], table.concat(get_valid_prefixes(), ",")))
end
local dest = param_mods[prefix].item_dest or prefix
if part[dest] then
parse_err("Modifier '" .. prefix .. "' occurs twice, second occurrence " .. run[j])
end
if param_mods[prefix].convert then
arg = param_mods[prefix].convert(arg, true, term_index, i)
end
part[dest] = arg
end
end

return part
end

-- Return an array of objects describing all the terms specified by the user. The meat of the work is done by
-- get_parsed_part(). `template`, `args` and `term_index` are as in get_parsed_part() and are required. Optional
-- `max_terms_allowed` restricts the number of terms that can be specified, and optional `start_index` specifies the
-- first index in the user-specified terms under the `term_index` argument to pull terms out of, defaulting to 1.
-- Currently only suffix() specifies a value for `start_index`, because the first term is handled differently by
-- suffix() compared with all the remaining terms.
local function get_parsed_parts(template, args, term_index, max_terms_allowed, start_index)
local parts = {}
start_index = start_index or 1

-- Find the maximum index among any of the list parameters.
local maxmaxindex = 0
for k, v in pairs(args) do
if type(v) == "table" and v.maxindex and v.maxindex > maxmaxindex then
if max_terms_allowed and v.maxindex > max_terms_allowed then
-- Try to determine the original parameter name associated with v.maxindex.
if type(k) == "number" then
-- Subtract one because e.g. if terms start at 2, the 4th term is in 5=.
arg = k + v.maxindex - 1
else
arg = k .. v.maxindex
end
error(("In [[Template:%s|%s]], at most %s terms can be specified but argument %s specified, corresponding to term #%s")
:format(template, template, max_terms_allowed, arg, v.maxindex))
end
maxmaxindex = v.maxindex
end
end

for index = start_index, maxmaxindex do
local part = get_parsed_part(template, args, term_index, index)
parts[index - start_index + 1] = part
end

return parts
end

function export.affix(frame)
local function extra_params(params)
params["type"] = {}
params["nocap"] = {type = "boolean"}
params["notext"] = {type = "boolean"}
params["nocat"] = {type = "boolean"}
params["force_cat"] = {type = "boolean"}
end

local args, term_index, lang, sc = parse_args(frame:getParent().args, extra_params)

if args["type"] and not m_affix.compound_types[args["type"]] then
error("Unrecognized compound type: '" .. args["type"] .. "'")
end

local parts = get_parsed_parts("affix", args, term_index)

-- There must be at least one part to display. If there are gaps, a term
-- request will be shown.
if not next(parts) and not args["type"] then
if mw.title.getCurrentTitle().nsText == "Template" then
parts = { {term = "prefix-"}, {term = "base"}, {term = "-suffix"} }
else
error("You must provide at least one part.")
end
end

return m_affix.show_affix {
lang = lang, sc = sc, parts = parts, pos = args["pos"], sort_key = args["sort"], type = args["type"],
nocap = args["nocap"], notext = args["notext"], nocat = args["nocat"], lit = args["lit"],
force_cat = args["force_cat"]
}
end

function export.compound(frame)
local function extra_params(params)
params["type"] = {}
params["nocap"] = {type = "boolean"}
params["notext"] = {type = "boolean"}
params["nocat"] = {type = "boolean"}
params["force_cat"] = {type = "boolean"}
end

local args, term_index, lang, sc = parse_args(frame:getParent().args, extra_params)

if args["type"] and not m_affix.compound_types[args["type"]] then
error("Unrecognized compound type: '" .. args["type"] .. "'")
end

local parts = get_parsed_parts("compound", args, term_index)

-- There must be at least one part to display. If there are gaps, a term
-- request will be shown.
if not next(parts) and not args["type"] then
if mw.title.getCurrentTitle().nsText == "Template" then
parts = { {term = "first"}, {term = "second"} }
else
error("You must provide at least one part of a compound.")
end
end

return m_affix.show_compound {
lang = lang, sc = sc, parts = parts, pos = args["pos"], sort_key = args["sort"], type = args["type"],
nocap = args["nocap"], notext = args["notext"], nocat = args["nocat"], lit = args["lit"],
force_cat = args["force_cat"]
}
end

function export.compound_like(frame)
local iparams = {
["lang"] = {},
["template"] = {},
["text"] = {},
["oftext"] = {},
["cat"] = {},
}

local iargs = require("Module:parameters").process(frame.args, iparams, nil, "affix/templates", "compound_like")
local parent_args = frame:getParent().args

local function extra_params(params)
params["pos"] = nil
params["nocap"] = {type = "boolean"}
params["notext"] = {type = "boolean"}
params["nocat"] = {type = "boolean"}
params["force_cat"] = {type = "boolean"}
end

local args, term_index, lang, sc = parse_args(parent_args, extra_params, nil, iargs.lang)

local template = iargs["template"]
local nocat = args["nocat"]
local notext = args["notext"]
local text = not notext and iargs["text"]
local oftext = not notext and (iargs["oftext"] or text and "of")
local cat = not nocat and iargs["cat"]

local parts = get_parsed_parts(template, args, term_index)

if not next(parts) then
if mw.title.getCurrentTitle().nsText == "Template" then
parts = { {term = "first"}, {term = "second"} }
end
end

return m_affix.show_compound_like {
lang = lang, sc = sc, parts = parts, sort_key = args["sort"], text = text, oftext = oftext, cat = cat,
nocat = args["nocat"], lit = args["lit"], force_cat = args["force_cat"]
}
end

function export.surface_analysis(frame)
local function ine(arg)
-- Since we're operating before calling [[Module:parameters]], we need to imitate how that module processes arguments,
-- including trimming since numbered arguments don't have automatic whitespace trimming.
if not arg then
return arg
end
arg = mw.text.trim(arg)
if arg == "" then
arg = nil
end
return arg
end

local parent_args = frame:getParent().args
local etymtext
local arg1 = ine(parent_args[1])
if not arg1 then
-- Allow omitted first argument to just display "By surface analysis".
etymtext = ""
elseif arg1:find("^%+") then
-- If the first argument (normally a language code) is prefixed with a +, it's a template name.
local template_name = arg1:sub(2)
local new_args = {}
for i, v in pairs(parent_args) do
if type(i) == "number" then
if i > 1 then
new_args[i - 1] = v
end
else
new_args[i] = v
end
end
new_args.nocap = true
etymtext = ", " .. frame:expandTemplate { title = template_name, args = new_args }
end

if etymtext then
return (ine(parent_args.nocap) and "b" or "B") .. "y [[Appendix:Glossary#surface analysis|surface analysis]]" .. etymtext
end

local function extra_params(params)
params["type"] = {}
params["nocap"] = {type = "boolean"}
params["notext"] = {type = "boolean"}
params["nocat"] = {type = "boolean"}
params["force_cat"] = {type = "boolean"}
end

local args, term_index, lang, sc = parse_args(parent_args, extra_params)

if args["type"] and not m_affix.compound_types[args["type"]] then
error("Unrecognized compound type: '" .. args["type"] .. "'")
end

local parts = get_parsed_parts("surface analysis", args, term_index)

-- There must be at least one part to display. If there are gaps, a term
-- request will be shown.
if not next(parts) then
if mw.title.getCurrentTitle().nsText == "Template" then
parts = { {term = "first"}, {term = "second"} }
else
error("You must provide at least one part.")
end
end

return m_affix.show_surface_analysis {
lang = lang, sc = sc, parts = parts, pos = args["pos"], sort_key = args["sort"], type = args["type"],
nocap = args["nocap"], notext = args["notext"], nocat = args["nocat"], lit = args["lit"],
force_cat = args["force_cat"]
}
end

function export.circumfix(frame)
local function extra_params(params)
params["nocat"] = {type = "boolean"}
params["force_cat"] = {type = "boolean"}
end

local args, term_index, lang, sc = parse_args(frame:getParent().args, extra_params)

local parts = get_parsed_parts("circumfix", args, term_index, 3)
local prefix = parts[1]
local base = parts[2]
local suffix = parts[3]

-- Just to make sure someone didn't use the template in a silly way
if not (prefix and base and suffix) then
if mw.title.getCurrentTitle().nsText == "Template" then
prefix = {term = "circumfix", alt = "prefix"}
base = {term = "base"}
suffix = {term = "circumfix", alt = "suffix"}
else
error("You must specify a prefix part, a base term and a suffix part.")
end
end

return m_affix.show_circumfix {
lang = lang, sc = sc, prefix = prefix, base = base, suffix = suffix, pos = args["pos"], sort_key = args["sort"],
nocat = args["nocat"], lit = args["lit"], force_cat = args["force_cat"]
}
end

function export.confix(frame)
local function extra_params(params)
params["nocat"] = {type = "boolean"}
params["force_cat"] = {type = "boolean"}
end

local args, term_index, lang, sc = parse_args(frame:getParent().args, extra_params)

local parts = get_parsed_parts("confix", args, term_index, 3)
local prefix = parts[1]
local base = #parts >= 3 and parts[2] or nil
local suffix = #parts >= 3 and parts[3] or parts[2]

-- Just to make sure someone didn't use the template in a silly way
if not (prefix and suffix) then
if mw.title.getCurrentTitle().nsText == "Template" then
prefix = {term = "prefix"}
suffix = {term = "suffix"}
else
error("You must specify a prefix part, an optional base term and a suffix part.")
end
end

return m_affix.show_confix {
lang = lang, sc = sc, prefix = prefix, base = base, suffix = suffix, pos = args["pos"], sort_key = args["sort"],
nocat = args["nocat"], lit = args["lit"], force_cat = args["force_cat"]
}
end

function export.pseudo_loan(frame)
local function extra_params(params)
params["pos"] = nil
params["nocap"] = {type = "boolean"}
params["notext"] = {type = "boolean"}
params["nocat"] = {type = "boolean"}
params["force_cat"] = {type = "boolean"}
end

local args, term_index, lang, sc, source = parse_args(frame:getParent().args, extra_params, "has source")

local parts = get_parsed_parts("pseudo-loan", args, term_index)

return require(pseudo_loan_module).show_pseudo_loan {
lang = lang, source = source, sc = sc, parts = parts, sort_key = args["sort"], nocap = args["nocap"],
notext = args["notext"], nocat = args["nocat"], lit = args["lit"], force_cat = args["force_cat"]
}
end

function export.infix(frame)
local function extra_params(params)
params["nocat"] = {type = "boolean"}
params["force_cat"] = {type = "boolean"}
end

local args, term_index, lang, sc = parse_args(frame:getParent().args, extra_params)

local parts = get_parsed_parts("infix", args, term_index, 2)
local base = parts[1]
local infix = parts[2]

-- Just to make sure someone didn't use the template in a silly way
if not (base and infix) then
if mw.title.getCurrentTitle().nsText == "Template" then
base = {term = "base"}
infix = {term = "infix"}
else
error("You must provide a base term and an infix.")
end
end

return m_affix.show_infix {
lang = lang, sc = sc, base = base, infix = infix, pos = args["pos"], sort_key = args["sort"],
nocat = args["nocat"], lit = args["lit"], force_cat = args["force_cat"]
}
end

function export.prefix(frame)
local function extra_params(params)
params["nocat"] = {type = "boolean"}
params["force_cat"] = {type = "boolean"}
end

local args, term_index, lang, sc = parse_args(frame:getParent().args, extra_params)

local prefixes = get_parsed_parts("prefix", args, term_index)
local base = nil

if #prefixes >= 2 then
base = prefixes[#prefixes]
prefixes[#prefixes] = nil
end

-- Just to make sure someone didn't use the template in a silly way
if #prefixes == 0 then
if mw.title.getCurrentTitle().nsText == "Template" then
base = {term = "base"}
prefixes = { {term = "prefix"} }
else
error("You must provide at least one prefix.")
end
end

return m_affix.show_prefix {
lang = lang, sc = sc, prefixes = prefixes, base = base, pos = args["pos"], sort_key = args["sort"],
nocat = args["nocat"], lit = args["lit"], force_cat = args["force_cat"]
}
end

function export.suffix(frame)
local function extra_params(params)
params["nocat"] = {type = "boolean"}
params["force_cat"] = {type = "boolean"}
end

local args, term_index, lang, sc = parse_args(frame:getParent().args, extra_params)

local base = get_parsed_part("suffix", args, term_index, 1)
local suffixes = get_parsed_parts("suffix", args, term_index, nil, 2)

-- Just to make sure someone didn't use the template in a silly way
if #suffixes == 0 then
if mw.title.getCurrentTitle().nsText == "Template" then
base = {term = "base"}
suffixes = { {term = "suffix"} }
else
error("You must provide at least one suffix.")
end
end

return m_affix.show_suffix {
lang = lang, sc = sc, base = base, suffixes = suffixes, pos = args["pos"], sort_key = args["sort"],
nocat = args["nocat"], lit = args["lit"], force_cat = args["force_cat"]
}
end

function export.derivsee(frame)
local iargs = frame.args
local iparams = {
["derivtype"] = {},
["mode"] = {},
}
local iargs = require("Module:parameters").process(frame.args, iparams)

local params = {
["head"] = {},
["id"] = {},
["sc"] = {},
["pos"] = {},
}
local derivtype = iargs.derivtype
if derivtype == "PIE root" then
params[1] = {}
else
params[1] = {required = "true", default = "und"}
params[2] = {}
end

local args = require("Module:parameters").process(frame:getParent().args, params)

local lang
local term

if derivtype == "PIE root" then
lang = m_languages.getByCode("ine-pro")
term = args[1] or args["head"]

if term then
term = "*" .. term .. "-"
end
else
lang = m_languages.getByCode(args[1], 1)
term = args[2] or args["head"]
end

local id = args.id
local sc = fetch_script(args.sc, "sc")
local pos = require("Module:string utilities").pluralize(args.pos or "term")

if not term then
local SUBPAGE = mw.ustring.lower(mw.title.getCurrentTitle().subpageText)
if lang:hasType("reconstructed") or mw.title.getCurrentTitle().nsText == "Reconstruction" then
term = "*" .. SUBPAGE
elseif lang:hasType("appendix-constructed") then
term = SUBPAGE
else
term = SUBPAGE
end
end

if derivtype == "PIE root" then
return frame:callParserFunction{
name = "#categorytree",
args = {
"Terms derived from the Proto-Indo-European root " .. term .. (id and " (" .. id .. ")" or ""),
depth = 0,
class = "\"derivedterms\"",
mode = iargs.mode,
}
}
end

local category = nil
local langname = lang:getCanonicalName()
if (derivtype == "compound" and pos == nil) then
category = langname .. " compounds with " .. term
elseif derivtype == "compound" then
category = langname .. " compound " .. pos .. " with " .. term
else
category = langname .. " " .. pos .. " " .. derivtype .. "ed with " .. term .. (id and " (" .. id .. ")" or "")
end

return frame:callParserFunction{
name = "#categorytree",
args = {
category,
depth = 0,
class = "\"derivedterms" .. (sc and " " .. sc:getCode() or "") .. "\"",
namespaces = "-" .. (mw.title.getCurrentTitle().nsText == "Reconstruction" and " Reconstruction" or ""),
}
}
end

return export

Module:Affix

2026-04-10T07:29:55Z

Jsrs701: 1 revision imported

local export = {}

local debug_force_cat = false -- if set to true, always display categories even on userspace pages

local m_links = require("Module:links")
local m_utilities = require("Module:utilities")
local m_table = require("Module:table")
-- Export this so the category code in [[Module:category tree/poscatboiler/data/terms by etymology]] can access it.
export.affix_lang_data_module_prefix = "Module:affix/lang-data/"

local u = mw.ustring.char
local rsub = mw.ustring.gsub
local usub = mw.ustring.sub
local ulen = mw.ustring.len
local rfind = mw.ustring.find
local rmatch = mw.ustring.match

-- Export this so the category code in [[Module:category tree/poscatboiler/data/terms by etymology]] can access it.
export.langs_with_lang_specific_data = {
["az"] = true,
["fi"] = true,
["izh"] = true,
["la"] = true,
["tr"] = true,
}

local default_pos = "term"

--[=[
About different types of hyphens ("template", "display" and "lookup"):
----------------------------------------------------------------------

* The "template hyphen" is the per-script hyphen character that is used in template calls to indicate that a term is an
affix. This is always a single Unicode char, but there may be multiple possible hyphens for a given script. Normally
this is just the regular hyphen character "-", but for some non-Latin-script languages (currently only right-to-left
languages), it is different.

* The "display hyphen" is the string (which might be an empty string) that is added onto a term as displayed and linked,
to indicate that a term is an affix. Currently this is always either the same as the template hyphen or an empty
string, but the code below is written generally enough to handle arbitrary display hyphens. Specifically:

(1) For East Asian languages, the display hyphen is always blank.
(2) For Arabic-script languages, either tatweel (ـ) or ZWNJ (zero-width non-joiner) are allowed as template hyphens,
where ZWNJ is supported primarily for Farsi, because some suffixes have non-joining behavior. The display hyphen
corresponding to tatweel is also tatweel, but the display hyphen corresponding to ZWNJ is blank (tatweel is also
the default display hyphen, for calls to {{prefix}}/{{suffix}}/etc. that don't include an explicit hyphen).

* The "lookup hyphen" is the hyphen that is used when looking up language-specific affix mappings. (These mappings are
discussed in more detail below when discussing link affixes.) It depends only on the script of the affix in question.
Most scripts (including East Asian scripts) use a regular hyphen "-" as the lookup hyphen, but Hebrew and Arabic
have their own lookup hyphens (respectively maqqef and tatweel). Note that for Arabic in particular, there are
three possible template hyphens that are recognized (tatweel, ZWNJ and regular hyphen), but mappings must use tatweel.

About different types of affixes ("template", "display", "link", "lookup" and "category"):
------------------------------------------------------------------------------------------

* A "template affix" is an affix in its source form as it appears in a template call. Generally, a template affix has
an attached template hyphen (see above) to indicate that it is an affix and indicate what type of affix it is
(prefix, suffix, interfix/infix or circumfix), but some of the older-style templates such as {{tl|suffix}},
{{tl|prefix}}, {{tl|confix}}, etc. have "positional" affixes where the presence of the affix in a certain position
(e.g. the second or third parameter) indicates that it is a certain type of affix, whether or not it has an attached
template hyphen.
* A "display affix" is the corresponding affix as it is actually displayed to the user. The display affix may differ
from the template affix for various reasons:
(1) The display affix may be specified explicitly using the |altN= parameter, the <alt:...> inline modifier or a
piped link of the form e.g. [[-kas|-käs]] (here indicating that the affix should display as '-käs' but be linked
as '-kas'). Here, the template affix is arguably the entire piped link, while the display affix is '-käs'.
(2) Even in the absence of |altN= parameters, <alt:...> inline modifiers and piped links, certain languages have
differences between the "template hyphen" specified in the template (which always needs to be specified somehow
or other in templates like {{affix}}, to indicate that the term is an affix and what type of affix it is) and the
display hyphen (see above), with corresponding differences between template and display affixes.
* A (regular) "link affix" is the affix that is linked to when the affix is shown to the user. The link affix is usually
the same as the display affix, but will differ in one of three circumstances:
(1) The display and link affixes are explicitly made different using |altN= parameters, <alt:...> inline modifiers or
piped links, as described above under "display affix".
(2) For certain languages, certain affixes are mapped to canonical form using language-specific mappings. For example,
in Finnish, the adjective-forming suffix [[Wiktionary:-kas|-kas]] appears as [[Wiktionary:-käs|-käs]] after front vowels, but logically both
forms are the same suffix and should be linked and categorized the same. Similarly, in Latin, the negative and
intensive prefixes spelled [[Wiktionary:in-|in-]] (etymologically two distinct prefixes) appear variously as [[Wiktionary:il-|il-]], [[Wiktionary:im-|im-]] or
[[Wiktionary:ir-|ir-]] before certain consonants. Mappings are supplied in [[Module:affix/lang-data/LANGCODE]] to convert
Finnish [[Wiktionary:-käs|-käs]] to [[Wiktionary:-kas|-kas]] for linking and categorization purposes. Note that the affixes in the mappings use
"lookup hyphens" to indicate the different types of affixes, which is usually the same as the template hyphen but
differs for Arabic scripts, because there are multiple possible template hyphens recognized but only one lookup
hyphen (tatweel). The form of the affix as used to look up in the mapping tables is called the "lookup affix";
see below.
* A "stripped link affix" is a link affix that has been passed through the language's makeEntryName() function, which
may strip certain diacritics: e.g. macrons in Latin and Old English (indicating length); acute and grave accents in
Russian and various other Slavic languages (indicating stress); vowel diacritics in most Arabic-script languages; and
also tatweel in some Arabic-script languages (currently, for example, Persian, Arabic and Urdu strip tatweel, but
Ottoman Turkish does not). Stripped link affixes are currently what are used in category names.
* A "lookup affix" is the form of the affix as it is looked up in the language-specific lookup mappings described above
under link affixes. There are actually two lookup stages:
(1) First, the affix is looked up in a modified display form (specifically, the same as the display affix but using
lookup hyphens). Note that this lookup does not occur if an explicit display form is given using |altN= or an
<alt:...> inline modifier, or if the template affix contains a piped or embedded link.
(2) If no entry is found, the affix is then looked up in a modified link form (specifically, the modified display
form passed through the language's makeEntryName() function, which strips out certain diacritics, but with the
lookup hyphen re-added if it was stripped out, as in the case of tatweel in many Arabic-script languages).
The reason for this double lookup procedure is to allow for mappings that are sensitive to the extra diacritics, but
also allow for mappings that are not sensitive in this fashion (e.g. Russian [[Wiktionary:-ливый|-ливый]] occurs both stressed and
unstressed, but is the same prefix either way).
* A "category affix" is the affix as it appears in categories such as [[:Category:Finnish terms suffixed with -kas]].
The category affix is currently always the same as the stripped link affix. This means that for Arabic-script
languages, it may or may not have a tatweel, even if the correponding display affix and regular link affix have a
tatweel. As mentioned above, makeEntryName() strips tatweel for Arabic, Persian and Urdu, but not for Ottoman Turkish.
Hence affix categories for Arabic, Persian and Urdu will be missing the tatweel, but affix categories for
Ottoman Turkish will have it. An additional complication is that if the template affix contains a ZWNJ, the display
(and hence the link and category affixes) will have no hyphen attached in any case.
]=]

-----------------------------------------------------------------------------------------
-- Template and display hyphens --
-----------------------------------------------------------------------------------------

--[=[
Per-script template hyphens. The template hyphen is what appears in the {{affix}}/{{prefix}}/{{suffix}}/etc. template
(in the wikicode). See above.

They key below is a script code, after removing a hyphen and anything preceding. Hence, script codes like 'fa-Arab'
and 'ur-Arab' will match 'Arab'.

The value below is a string consisting of one or more hyphen characters. If there is more than one character, the
default hyphen must come last and a non-default function must be specified for the script in display_hyphens[] so
the correct display hyphen will be specified when no template hyphen is given (in {{suffix}}/{{prefix}}/etc.).

Script detection is normally done when linking, but we need to do it earlier. However, under most circumstances we
don't need to do script detection. Specifically, we only need to do script detection for a given language if

(a) the language has multiple scripts; and
(b) at least one of those scripts is listed below or in display_hyphens.
]=]

local ZWNJ = u(0x200C) -- zero-width non-joiner
local template_hyphens = {
["Arab"] = "ـ" .. ZWNJ .. "-", -- tatweel + zero-width non-joiner + regular hyphen
["Hebr"] = "־", -- Hebrew-specific hyphen termed "maqqef"
-- This covers all Arabic scripts. See above.
["Mong"] = "᠊",
["mnc-Mong"] = "᠊",
["sjo-Mong"] = "᠊",
["xwo-Mong"] = "᠊",
-- FIXME! What about the following right-to-left scripts?
-- Adlm (Adlam)
-- Armi (Imperial Aramaic)
-- Avst (Avestan)
-- Cprt (Cypriot)
-- Khar (Kharoshthi)
-- Mand (Mandaic/Mandaean)
-- Mani (Manichaean)
-- Mend (Mende/Mende Kikakui)
-- Narb (Old North Arabian)
-- Nbat (Nabataean/Nabatean)
-- Nkoo (N'Ko)
-- Orkh (Orkhon runes)
-- Phli (Inscriptional Pahlavi)
-- Phlp (Psalter Pahlavi)
-- Phlv (Book Pahlavi)
-- Phnx (Phoenician)
-- Prti (Inscriptional Parthian)
-- Rohg (Hanifi Rohingya)
-- Samr (Samaritan)
-- Sarb (Old South Arabian)
-- Sogd (Sogdian)
-- Sogo (Old Sogdian)
-- Syrc (Syriac)
-- Thaa (Thaana)
}

-- Hyphens used when looking up an affix in a lang-specific affix mapping. Defaults to regular hyphen (-). The keys
-- are script codes, after removing a hyphen and anything preceding. Hence, script codes like 'fa-Arab' and 'ur-Arab'
-- will match 'Arab'. The value should be a single character.
local lookup_hyphens = {
["Hebr"] = "־",
-- This covers all Arabic scripts. See above.
["Arab"] = "ـ",
}

-- Default display-hyphen function.
local function default_display_hyphen(script, hyph)
if not hyph then
return template_hyphens[script] or "-"
end
return hyph
end

local function arab_get_display_hyphen(script, hyph)
if not hyph then
return "ـ" -- tatweel
elseif hyph == ZWNJ then
return ""
else
return hyph
end
end

local function no_display_hyphen(script, hyph)
return ""
end

-- Per-script function to return the correct display hyphen given the script and template hyphen. The function should
-- also handle the case where the passed-in template hyphen is nil, corresponding to the situation in
-- {{prefix}}/{{suffix}}/etc. where no template hyphen is specified. The key is the script code after removing a hyphen
-- and anything preceding, so 'fa-Arab', 'ur-Arab' etc. will match 'Arab'.
local display_hyphens = {
-- This covers all Arabic scripts. See above.
["Arab"] = arab_get_display_hyphen,
["Bopo"] = no_display_hyphen,
["Hani"] = no_display_hyphen,
["Hans"] = no_display_hyphen,
["Hant"] = no_display_hyphen,
-- The following is a mixture of several scripts. Hopefully the specs here are correct!
["Jpan"] = no_display_hyphen,
["Jurc"] = no_display_hyphen,
["Kitl"] = no_display_hyphen,
["Kits"] = no_display_hyphen,
["Laoo"] = no_display_hyphen,
["Nshu"] = no_display_hyphen,
["Shui"] = no_display_hyphen,
["Tang"] = no_display_hyphen,
["Thaa"] = no_display_hyphen,
["Thai"] = no_display_hyphen,
}

-----------------------------------------------------------------------------------------
-- Basic Utility functions --
-----------------------------------------------------------------------------------------

local function glossary_link(entry, text)
text = text or entry
return "[[Appendix:Glossary#" .. entry .. "|" .. text .. "]]"
end

local function track(page)
if type(page) == "table" then
for i, pg in ipairs(page) do
page[i] = "affix/" .. pg
end
else
page = "affix/" .. page
end
require("Module:debug/track")(page)
end

-----------------------------------------------------------------------------------------
-- Compound types --
-----------------------------------------------------------------------------------------

local function make_compound_type(typ, alttext)
return {
text = glossary_link(typ, alttext) .. " compound",
cat = typ .. " compounds",
}
end

-- Make a compound type entry with a simple rather than glossary link.
-- These should be replaced with a glossary link when the entry in the glossary
-- is created.
local function make_non_glossary_compound_type(typ, alttext)
local link = alttext and "[[" .. typ .. "|" .. alttext .. "]]" or "[[" .. typ .. "]]"
return {
text = link .. " compound",
cat = typ .. " compounds",
}
end

local function make_raw_compound_type(typ, alttext)
return {
text = glossary_link(typ, alttext),
cat = require("Module:string utilities").pluralize(typ),
}
end

export.compound_types = {
["alliterative"] = make_non_glossary_compound_type("alliterative"),
["allit"] = "alliterative",
["antonymous"] = make_non_glossary_compound_type("antonymous"),
["ant"] = "antonymous",
["bahuvrihi"] = make_compound_type("bahuvrihi", "bahuvrīhi"),
["bahu"] = "bahuvrihi",
["bv"] = "bahuvrihi",
["coordinative"] = make_compound_type("coordinative"),
["coord"] = "coordinative",
["descriptive"] = make_compound_type("descriptive"),
["desc"] = "descriptive",
["determinative"] = make_compound_type("determinative"),
["det"] = "determinative",
["dvandva"] = make_compound_type("dvandva"),
["dva"] = "dvandva",
["endocentric"] = make_compound_type("endocentric"),
["endo"] = "endocentric",
["exocentric"] = make_compound_type("exocentric"),
["exo"] = "exocentric",
["izafet I"] = make_compound_type("izafet I"),
["iz1"] = "izafet I",
["izafet II"] = make_compound_type("izafet II"),
["iz2"] = "izafet II",
["izafet III"] = make_compound_type("izafet III"),
["iz3"] = "izafet III",
["karmadharaya"] = make_compound_type("karmadharaya", "karmadhāraya"),
["karma"] = "karmadharaya",
["kd"] = "karmadharaya",
["kenning"] = make_raw_compound_type("kenning"),
["ken"] = "kenning",
["rhyming"] = make_non_glossary_compound_type("rhyming"),
["rhy"] = "rhyming",
["synonymous"] = make_non_glossary_compound_type("synonymous"),
["syn"] = "synonymous",
["tatpurusa"] = make_compound_type("tatpurusa", "tatpuruṣa"),
["tat"] = "tatpurusa",
["tp"] = "tatpurusa",
}

local function process_compound_type(typ, nocap, notext, has_parts)
local text_sections = {}
local categories = {}

if typ then
local typdata = export.compound_types[typ]
if type(typdata) == "string" then
typdata = export.compound_types[typdata]
end
if not typdata then
error("Internal error: Unrecognized type '" .. typ .. "'")
end
local text = typdata.text
if not nocap then
text = require("Module:string utilities").ucfirst(text)
end
local cat = typdata.cat
local oftext = typdata.oftext or " of"

if not notext then
table.insert(text_sections, text)
if has_parts then
table.insert(text_sections, oftext)
table.insert(text_sections, " ")
end
end
table.insert(categories, cat)
end

return text_sections, categories
end

-----------------------------------------------------------------------------------------
-- Utility functions --
-----------------------------------------------------------------------------------------

-- Iterate an array up to the greatest integer index found.
local function ipairs_with_gaps(t)
local indices = require("Module:table").numKeys(t)
local max_index = #indices > 0 and math.max(unpack(indices)) or 0
local i = 0
return function()
while i < max_index do
i = i + 1
return i, t[i]
end
end
end

export.ipairs_with_gaps = ipairs_with_gaps

--[=[
Concatenate formatted parts (in `parts_formatted`) together with any overall lit= spec (in `lit`) plus categories,
which are formatted by prepending the language name as found in `lang`. The value of an entry in `categories` can be
either a string (which is formatted using `sort_key`) or a table of the form `{cat=CATEGORY, sort_key=SORT_KEY,
sort_base=SORT_BASE}`, specifying the sort key and sort base to use when formatting the category. If `nocat` is given,
no categories are added; otherwise, `force_cat` causes categories to be added even on userspace pages.
]=]
function export.concat_parts(lang, parts_formatted, categories, nocat, sort_key, lit, force_cat)
local cattext
if nocat then
cattext = ""
else
for i, cat in ipairs(categories) do
if type(cat) == "table" then
categories[i] = m_utilities.format_categories({lang:getNonEtymologicalName() .. " " .. cat.cat}, lang,
cat.sort_key, cat.sort_base, force_cat or debug_force_cat)
else
categories[i] = m_utilities.format_categories({lang:getNonEtymologicalName() .. " " .. cat}, lang,
sort_key, nil, force_cat or debug_force_cat)
end
end
cattext = table.concat(categories)
end
return table.concat(parts_formatted, " +&lrm; ") .. (lit and ", literally " .. m_links.mark(lit, "gloss") or "") ..
cattext
end

local function pluralize(pos)
if pos ~= "nouns" and usub(pos, -5) ~= "verbs" and usub(pos, -4) ~= "ives" then
if pos:find("[sx]$") then
pos = pos .. "es"
else
pos = pos .. "s"
end
end
return pos
end

-- Remove links and call lang:makeEntryName(term).
local function make_entry_name_no_links(lang, term)
-- Double parens because makeEntryName() returns multiple values. Yuck.
return (lang:makeEntryName(m_links.remove_links(term)))
end

--[=[
Convert a raw part as passed into an entry point into a part ready for linking. `lang` and `sc` are the overall
language and script objects. This uses the overall language and script objects as defaults for the part and parses off
any fragment from the term. We need to do the latter so that fragments don't end up in categories and so that we
correctly do affix mapping even in the presence of fragments.
]=]
local function canonicalize_part(part, lang, sc)
if not part then
return
end
-- Save the original (user-specified, part-specific) value of `lang`. If such a value is specified, we don't insert
-- a '*fixed with' category, and we format the part using format_derived() in [[Module:etymology]] rather than
-- full_link() in [[Module:links]].
part.part_lang = part.lang
part.lang = part.lang or lang
part.sc = part.sc or sc
if part.term then
local fragment
part.term, fragment = m_links.get_fragment(part.term)
part.fragment = part.fragment or fragment
end
end

--[=[
Construct a single linked part based on the information in `part`, for use by `show_affix()` and other entry points.
This should be called after canonicalize_part() is called on the part. This is a thin wrapper around `full_link()` in
[[Module:links]] unless `part.part_lang` is specified (indicating that a part-specific language was given), in which
case `format_derived()` in [[Module:etymology]] is called to display a term in a language other than the language of
the overall term (specified in `data.lang`). `data` contains the entire object passed into the entry point and is used
to access information for constructing the categories added by `format_derived()`.
]=]
function export.link_term(part, data)
local result

if part.part_lang then
result = require("Module:etymology").format_derived(data.lang, part, data.sort_key, data.nocat,
data.force_cat or debug_force_cat)
else
-- language (e.g. in a pseudo-loan).
result = m_links.full_link(part, "term")
end

if part.q then
result = require("Module:qualifier").format_qualifier(part.q) .. " " .. result
end

if part.qq then
result = result .. " " .. require("Module:qualifier").format_qualifier(part.qq)
end

return result
end

local function canonicalize_script_code(scode)
-- Convert fa-Arab, ur-Arab etc. to Arab.
return (scode:gsub("^.*%-", ""))
end

-----------------------------------------------------------------------------------------
-- Affix-handling functions --
-----------------------------------------------------------------------------------------

-- Figure out the appropriate script for the given affix and language (unless the script is explicitly passed in), and
-- return the values of template_hyphens[], display_hyphens[] and lookup_hyphens[] for that script, substituting
-- default values as appropriate. Four values are returned:
-- DETECTED_SCRIPT, TEMPLATE_HYPHEN, DISPLAY_HYPHEN, LOOKUP_HYPHEN
local function detect_script_and_hyphens(text, lang, sc)
local scode
-- 1. If the script is explicitly passed in, use it.
if sc then
scode = sc:getCode()
else
local possible_script_codes = lang:getScriptCodes()
-- YUCK! `possible_script_codes` comes from loadData() so #possible_scripts doesn't work (always returns 0).
local num_possible_script_codes = m_table.length(possible_script_codes)
if num_possible_script_codes == 0 then
-- This shouldn't happen; if the language has no script codes,
-- the list {"None"} should be returned.
error("Something is majorly wrong! Language " .. lang:getCanonicalName() .. " has no script codes.")
end
if num_possible_script_codes == 1 then
-- 2. If the language has only one possible script, use it.
scode = possible_script_codes[1]
else
-- 3. Check if any of the possible scripts for the language have non-default values for template_hyphens[]
-- or display_hyphens[]. If so, we need to do script detection on the text. If not, just use "Latn",
-- which may not be technically correct but produces the right results because Latn has all default
-- values for template_hyphens[] and display_hyphens[].
local may_have_nondefault_hyphen = false
for _, script_code in ipairs(possible_script_codes) do
script_code = canonicalize_script_code(script_code)
if template_hyphens[script_code] or display_hyphens[script_code] then
may_have_nondefault_hyphen = true
break
end
end
if not may_have_nondefault_hyphen then
scode = "Latn"
else
scode = lang:findBestScript(text):getCode()
end
end
end
scode = canonicalize_script_code(scode)
local template_hyphen = template_hyphens[scode] or "-"
local lookup_hyphen = lookup_hyphens[scode] or "-"
local display_hyphen = display_hyphens[scode] or default_display_hyphen
return scode, template_hyphen, display_hyphen, lookup_hyphen
end

--[=[
Given a template affix `term` and an affix type `affix_type`, change the relevant template hyphen(s) in the affix to
the display or lookup hyphen specified in `new_hyphen`, or add them if they are missing. `new_hyphen` can be a string,
specifying a fixed hyphen, or a function of two arguments (the script code `scode` and the discovered template hyphen,
or nil of no relevant template hyphen is present). `thyph_re` is a Lua pattern (which must be enclosed in parens) that
matches the possible template hyphens. Note that not all template hyphens present in the affix are changed, but only
the "relevant" ones (e.g. for a prefix, a relevant template hyphen is one coming at the end of the affix).
]=]
local function reconstruct_term_per_hyphens(term, affix_type, scode, thyph_re, new_hyphen)
local function get_hyphen(hyph)
if type(new_hyphen) == "string" then
return new_hyphen
end
return new_hyphen(scode, hyph)
end

if not affix_type then
return term
elseif affix_type == "circumfix" then
local before, before_hyphen, after_hyphen, after = rmatch(term, "^(.*)" .. thyph_re .. " " .. thyph_re
.. "(.*)$")
if not before or ulen(term) <= 3 then
-- Unlike with other types of affixes, don't try to add hyphens in the middle of the term to convert it to
-- a circumfix. Also, if the term is just hyphen + space + hyphen, return it.
return term
end
return before .. get_hyphen(before_hyphen) .. " " .. get_hyphen(after_hyphen) .. after
elseif affix_type == "infix" or affix_type == "interfix" then
local before_hyphen, middle, after_hyphen = rmatch(term, "^" .. thyph_re .. "(.*)" .. thyph_re .. "$")
if before_hyphen and ulen(term) <= 1 then
-- If the term is just a hyphen, return it.
return term
end
return get_hyphen(before_hyphen) .. (middle or term) .. get_hyphen(after_hyphen)
elseif affix_type == "prefix" then
local middle, after_hyphen = rmatch(term, "^(.*)" .. thyph_re .. "$")
if middle and ulen(term) <= 1 then
-- If the term is just a hyphen, return it.
return term
end
return (middle or term) .. get_hyphen(after_hyphen)
elseif affix_type == "suffix" then
local before_hyphen, middle = rmatch(term, "^" .. thyph_re .. "(.*)$")
if before_hyphen and ulen(term) <= 1 then
-- If the term is just a hyphen, return it.
return term
end
return get_hyphen(before_hyphen) .. (middle or term)
else
error(("Internal error: Unrecognized affix type '%s'"):format(affix_type))
end
end

--[=[
Look up a mapping from a given affix variant to the canonical form used in categories and links. The lookup tables are
language-specific according to `lang`, and may be ID-specific according to `affix_id`. The affixes as they appear in the
lookup tables (both the variant and the canonical form) are in "lookup affix" format (approximately speaking, they use a
regular hyphen for most scripts, but a tatweel for Arabic-script entries and a maqqef for Hebrew-script entries), but
the passed-in `affix` param is in "template affix" format (which differs from the lookup affix for Arabic-script
entries, because more types of hyphens are allowed in template affixes; see the comments at the top of the file). The
remaining parameters to this function are used to convert from template affixes to lookup affixes; see the
reconstruct_term_per_hyphens() function above.

If the affix contains brackets, no lookup is done. Otherwise, a two-stage process is used, first looking up the affix
directly and then stripping diacritics and looking it up again. The reason for this is documented above in the comments
at the top of the file (specifically, the comments describing lookup affixes).

The value of a mapping can either be a string (do the mapping regardless of affix ID) or a table indexed by affix ID
(where the special value `false` indicates no affix ID). The values of entries in this table can also be strings, or
tables with keys `affix` and `id` (again, use `false` to indicate no ID). This allows an affix mapping to map from one
ID to another (for example, this is used in English to map the [[Wiktionary:an-|an-]] prefix with no ID to the [[Wiktionary:a-|a-]] prefix with the
ID 'not').

The Given a template affix `term` and an affix type `affix_type`, change the relevant template hyphen(s) in the affix to
the display or lookup hyphen specified in `new_hyphen`, or add them if they are missing. `new_hyphen` can be a string,
specifying a fixed hyphen, or a function of two arguments (the script code `scode` and the discovered template hyphen,
or nil of no relevant template hyphen is present). `thyph_re` is a Lua pattern (which must be enclosed in parens) that
matches the possible template hyphens. Note that not all template hyphens present in the affix are changed, but only
the "relevant" ones (e.g. for a prefix, a relevant template hyphen is one coming at the end of the affix).
]=]
local function lookup_affix_mapping(affix, affix_type, lang, scode, thyph_re, lookup_hyph, affix_id)
local function do_lookup(affix)
-- Ensure that the affix uses lookup hyphens regardless of whether it used a different type of hyphens before
-- or no hyphens.
local lookup_affix = reconstruct_term_per_hyphens(affix, affix_type, scode, thyph_re, lookup_hyph)
local function do_lookup_for_langcode(langcode)
if export.langs_with_lang_specific_data[langcode] then
local langdata = mw.loadData(export.affix_lang_data_module_prefix .. langcode)
if langdata.affix_mappings then
local mapping = langdata.affix_mappings[lookup_affix]
if mapping then
if type(mapping) == "table" then
mapping = mapping[affix_id or false]
if mapping then
return mapping
end
else
return mapping
end
end
end
end
end

-- If `lang` is an etymology-only language, look for a mapping both for it and its full parent.
local langcode = lang:getCode()
local mapping = do_lookup_for_langcode(langcode)
if mapping then
return mapping
end
local full_langcode = lang:getNonEtymologicalCode()
if full_langcode ~= langcode then
mapping = do_lookup_for_langcode(full_langcode)
if mapping then
return mapping
end
end
return nil
end

if affix:find("%[%[") then
return nil
end

-- Double parens because makeEntryName() returns multiple values. Yuck.
return do_lookup(affix) or do_lookup((lang:makeEntryName(affix))) or nil
end

--[=[
For a given template term in a given language (see the definition of "template affix" near the top of the file),
possibly in an explicitly specified script `sc` (but usually nil), return the term's affix type ("prefix", "infix",
"suffix", "circumfix" or nil for non-affix) along with the corresponding link and display affixes (see definitions
near the top of the file); also the corresponding lookup affix (if `return_lookup_affix` is specified). The term passed
in should already have any fragment (after the # sign) parsed off of it. Four values are returned: `affix_type`,
`link_term`, `display_term` and `lookup_term`. The affix type can be passed in instead of autodetected (pass in `false`
if the term is not an affix); in this case, the template term need not have any attached hyphens, and the appropriate
hyphens will be added in the appropriate places. If `do_affix_mapping` is specified, look up the affix in the
lang-specific affix mappings, as described in the comment at the top of the file; otherwise, the link and display terms
will always be the same. (They will be the same in any case if the template term has a bracketed link in it or is not
an affix.) If `return_lookup_affix` is given, the fourth return value contains the term with appropriate lookup hyphens
in the appropriate places; otherwise, it is the same as the display term. (This functionality is used in
[[Module:category tree/poscatboiler/data/terms by etymology]] to convert link affixes into lookup affixes so that they
can be looked up in the affix mapping tables.)
]=]
function export.parse_term_for_affixes(term, lang, sc, affix_type, do_affix_mapping, return_lookup_affix, affix_id)
if not term then
return nil, nil, nil, nil
end

if term:find("^%^") then
-- If term begins with ^, it's not an affix no matter what. Strip off the ^ and return "no affix".
term = usub(term, 2)
return nil, term, term, term
end

-- Remove an asterisk if the morpheme is reconstructed and add it back at the end.
local reconstructed = ""
if term:find("^%*") then
reconstructed = "*"
term = term:gsub("^%*", "")
end

local scode, thyph, dhyph, lhyph = detect_script_and_hyphens(term, lang, sc)
thyph = "([" .. thyph .. "])"

if affix_type == nil then
if rfind(term, thyph .. " " .. thyph) then
affix_type = "circumfix"
else
local has_beginning_hyphen = rfind(term, "^" .. thyph)
local has_ending_hyphen = rfind(term, thyph .. "$")
if has_beginning_hyphen and has_ending_hyphen then
affix_type = "infix"
elseif has_ending_hyphen then
affix_type = "prefix"
elseif has_beginning_hyphen then
affix_type = "suffix"
end
end
end

local link_term, display_term, lookup_term
if affix_type then
display_term = reconstruct_term_per_hyphens(term, affix_type, scode, thyph, dhyph)
if do_affix_mapping then
link_term = lookup_affix_mapping(term, affix_type, lang, scode, thyph, lhyph, affix_id)
-- The return value of lookup_affix_mapping() may be an affix mapping with lookup hyphens if a mapping
-- was found, otherwise nil if a mapping was not found. We need to convert to display hyphens in
-- either case, but in the latter case we can reuse the display term, which has already been converted.
if link_term then
link_term = reconstruct_term_per_hyphens(link_term, affix_type, scode, thyph, dhyph)
else
link_term = display_term
end
else
link_term = display_term
end
if return_lookup_affix then
lookup_term = reconstruct_term_per_hyphens(term, affix_type, scode, thyph, lhyph)
else
lookup_term = display_term
end
else
link_term = term
display_term = term
lookup_term = term
end

link_term = reconstructed .. link_term
display_term = reconstructed .. display_term
lookup_term = reconstructed .. lookup_term

return affix_type, link_term, display_term, lookup_term
end

export.get_affix_type = export.parse_term_for_affixes

--[=[
Add a hyphen to a term in the appropriate place, based on the specified affix type, stripping off any existing hyphens
in that place. For example, if `affix_type` == "prefix", we'll add a hyphen onto the end if it's not already there (or
is of the wrong type). Three values are returned: the link term, display term and lookup term. This function is a thin
wrapper around `parse_term_for_affixes`; see the comments above that function for more information.
]=]
function export.make_affix(term, lang, sc, affix_type, do_affix_mapping, return_lookup_affix, affix_id)
if not (affix_type == "prefix" or affix_type == "suffix" or affix_type == "circumfix" or affix_type == "infix" or
affix_type == "interfix") then
error("Internal error: Invalid affix type " .. (affix_type or "(nil)"))
end

local _, link_term, display_term, lookup_term = export.parse_term_for_affixes(term, lang, sc, affix_type,
do_affix_mapping, return_lookup_affix, affix_id)
return link_term, display_term, lookup_term
end

-----------------------------------------------------------------------------------------
-- Main entry points --
-----------------------------------------------------------------------------------------

--[=[
Implementation of {{affix}} and {{surface analysis}}. `data` contains all the information describing the affixes to be
displayed, and contains the following:

`.lang`: Overall language object (REQUIRED). Different from term-specific language objects (see `.parts` below).
`.sc`: Overall script object (usually omitted). Different from term-specific script objects.
`.parts`: List of objects describing the affixes to show (REQUIRED). The general format of each object is as would be
passed to full_link(), except that the `.lang` field should be missing unless the term is of a language
different from the overall `.lang` value (in such a case, the language name is shown along with the term and
an additional "derived from" category is added). WARNING: The data in `.parts` will be destructively modified.
`.pos`: Overall part of speech (used in categories, defaults to "terms"). Different from term-specific part of speech.
`.sort_key`: Overall sort key. Normally omitted except e.g. in Japanese.
`.type`: Type of compound, if the parts in `.parts` describe a compound. Strictly optional, and if supplied, the
compound type is displayed before the parts (normally capitalized, unless `.nocap` is given).
`.nocap`: Don't capitalize the first letter of text displayed before the parts (relevant only if `.type` or
`.surface_analysis` is given).
`.notext`: Don't display any text before the parts (relevant only if `.type` or `.surface_analysis` is given).
`.nocat`: Disable all categorization.
`.lit`: Overall literal definition. Different from term-specific literal definitions.
`.force_cat`: Always display categories, even on userspace pages.
`.surface_analysis`: Implement {{surface analysis}}; adds "By surface analysis, " before the parts.

WARNING: This destructively modifies both `data` and the individual structures within `.parts`.
]=]
function export.show_affix(data)
data.pos = data.pos or default_pos
data.pos = pluralize(data.pos)

local text_sections, categories = process_compound_type(data.type, data.surface_analysis or data.nocap, data.notext,
#data.parts > 0)

-- Process each part
local parts_formatted = {}
local whole_words = 0
local is_affix_or_compound = false

-- Canonicalize all the parts first because when processing the first part, we may access the second part and need
-- it already canonicalized.
for i, part in ipairs_with_gaps(data.parts) do
part = part or {}
data.parts[i] = part
canonicalize_part(part, data.lang, data.sc)
end

for i, part in ipairs_with_gaps(data.parts) do
part = part or {}

-- Determine affix type and get link and display terms (see text at top of file).
local affix_type, link_term, display_term = export.parse_term_for_affixes(part.term, part.lang, part.sc, nil,
not part.alt, nil, part.id)

-- If link_term is an empty string, either a bare ^ was specified or an empty term was used along with inline
-- modifiers. The intention in either case is not to link the term.
part.term = link_term ~= "" and link_term or nil
-- If part.alt would be the same as part.term, make it nil, so that it isn't erroneously tracked as being
-- redundant alt text.
part.alt = part.alt or (display_term ~= link_term and display_term) or nil

-- Make a link for the part.
table.insert(parts_formatted, export.link_term(part, data))

if affix_type then
is_affix_or_compound = true
-- We cannot distinguish interfixes from infixes by appearance. Prefer interfixes; infixes will need to
-- use {{infix}}.
if affix_type == "infix" then affix_type = "interfix" end

-- Make a sort key. For the first part, use the second part as the sort key; the intention is that if the
-- term has a prefix, sorting by the prefix won't be very useful so we sort by what follows, which is
-- presumably the root.
local part_sort_base = nil
local part_sort = part.sort or data.sort_key

if i == 1 and data.parts[2] and data.parts[2].term then
local part2 = data.parts[2]
local part2_affix_type, part2_link_term, part2_display_term = export.parse_term_for_affixes(
part2.term, part2.lang, part2.sc, nil, not part2.alt, nil, part.id)
part_sort_base = make_entry_name_no_links(part2.lang, part2_link_term)
end

if part.pos and rfind(part.pos, "patronym") then
table.insert(categories, {cat = "patronymics", sort_key = part_sort, sort_base = part_sort_base})
end

if data.pos ~= "terms" and part.pos and rfind(part.pos, "diminutive") then
table.insert(categories, {cat = "diminutive " .. data.pos, sort_key = part_sort,
sort_base = part_sort_base})
end

-- Don't add a '*fixed with' category if the link term is empty or is in a different language.
if link_term and link_term ~= "" and not part.part_lang then
table.insert(categories, {cat = data.pos .. " " .. affix_type .. "ed with " ..
make_entry_name_no_links(part.lang, link_term) .. (part.id and " (" .. part.id .. ")" or ""),
sort_key = part_sort, sort_base = part_sort_base})
end
else
whole_words = whole_words + 1

if whole_words == 2 then
is_affix_or_compound = true
table.insert(categories, "compound " .. data.pos)
end
end
end

-- Make sure there was either an affix or a compound (two or more regular terms).
if not is_affix_or_compound then
error("The parameters did not include any affixes, and the term is not a compound. Please provide at least one affix.")
end

if data.surface_analysis then
local text = "by " .. glossary_link("surface analysis") .. ", "
if not data.nocap then
text = require("Module:string utilities").ucfirst(text)
end

table.insert(text_sections, 1, text)
end

table.insert(text_sections, export.concat_parts(data.lang, parts_formatted, categories, data.nocat, data.sort_key,
data.lit, data.force_cat))
return table.concat(text_sections)
end

function export.show_surface_analysis(data)
data.surface_analysis = true
return export.show_affix(data)
end

--[=[
Implementation of {{compound}}.

WARNING: This destructively modifies both `data` and the individual structures within `.parts`.
]=]
function export.show_compound(data)
data.pos = data.pos or default_pos
data.pos = pluralize(data.pos)

local text_sections, categories = process_compound_type(data.type, data.nocap, data.notext, #data.parts > 0)

local parts_formatted = {}
table.insert(categories, "compound " .. data.pos)

-- Make links out of all the parts
local whole_words = 0
for i, part in ipairs(data.parts) do
canonicalize_part(part, data.lang, data.sc)
-- Determine affix type and get link and display terms (see text at top of file).
local affix_type, link_term, display_term = export.parse_term_for_affixes(part.term, part.lang, part.sc,
nil, not part.alt, nil, part.id)

-- If the term is an infix, recognize it as such (which means e.g. that we will display the term without
-- hyphens for East Asian languages). Otherwise, ignore the fact that it looks like an affix and display as
-- specified in the template (but pay attention to the detected affix type for certain tracking purposes).
if affix_type == "infix" then
-- If link_term is an empty string, either a bare ^ was specified or an empty term was used along with
-- inline modifiers. The intention in either case is not to link the term. Don't add a '*fixed with'
-- category in this case, or if the term is in a different language.
-- If part.alt would be the same as part.term, make it nil, so that it isn't erroneously tracked as being
-- redundant alt text.
if link_term and link_term ~= "" and not part.part_lang then
table.insert(categories, {cat = data.pos .. " interfixed with " .. make_entry_name_no_links(part.lang,
link_term), sort_key = part.sort or data.sort_key})
end
part.term = link_term ~= "" and link_term or nil
part.alt = part.alt or (display_term ~= link_term and display_term) or nil
else
if affix_type then
local langcode = data.lang:getCode()
-- If `data.lang` is an etymology-only language, track both using its code and its full parent's code.
track { affix_type, affix_type .. "/lang/" .. langcode }
local full_langcode = data.lang:getNonEtymologicalCode()
if langcode ~= full_langcode then
track(affix_type .. "/lang/" .. full_langcode)
end
else
whole_words = whole_words + 1
end
end
table.insert(parts_formatted, export.link_term(part, data))
end

if whole_words == 1 then
track("one whole word")
elseif whole_words == 0 then
track("looks like confix")
end

table.insert(text_sections, export.concat_parts(data.lang, parts_formatted, categories, data.nocat, data.sort_key,
data.lit, data.force_cat))
return table.concat(text_sections)
end

--[=[
Implementation of {{blend}}, {{univerbation}} and similar "compound-like" templates.

WARNING: This destructively modifies both `data` and the individual structures within `.parts`.
]=]
function export.show_compound_like(data)
local parts_formatted = {}
local categories = {}

if data.cat then
table.insert(categories, data.cat)
end

-- Make links out of all the parts
for i, part in ipairs(data.parts) do
canonicalize_part(part, data.lang, data.sc)
table.insert(parts_formatted, export.link_term(part, data))
end

local text_sections = {}
if data.text then
table.insert(text_sections, data.text)
end
if #data.parts > 0 and data.oftext then
table.insert(text_sections, " ")
table.insert(text_sections, data.oftext)
table.insert(text_sections, " ")
end
table.insert(text_sections, export.concat_parts(data.lang, parts_formatted, categories, data.nocat, data.sort_key,
data.lit, data.force_cat))
return table.concat(text_sections)
end

--[=[
Make `part` (a structure holding information on an affix part) into an affix of type `affix_type`, and apply any
relevant affix mappings. For example, if the desired affix type is "suffix", this will (in general) add a hyphen onto
the beginning of the term, alt, tr and ts components of the part if not already present. The hyphen that's added is the
"display hyphen" (see above) and may be script-specific. (In the case of East Asian scripts, the display hyphen is an
empty string whereas the template hyphen is the regular hyphen, meaning that any regular hyphen at the beginning of the
part will be effectively removed.) `lang` and `sc` hold overall language and script objects.

Note that this also applies any language-specific affix mappings, so that e.g. if the language is Finnish and the user
specified [[Wiktionary:-käs|-käs]] in the affix and didn't specify an .alt value, `part.term` will contain [[Wiktionary:-kas|-kas]] and `part.alt` will
contain [[Wiktionary:-käs|-käs]].

This function is used by the "legacy" templates ({{tl|prefix}}, {{tl|suffix}}, {{tl|confix}}, etc.) where the nature of
the affix is specified by the template itself rather than auto-determined from the affix, as is the case with
{{tl|affix}}.

WARNING: This destructively modifies `part`.
]=]
local function make_part_into_affix(part, lang, sc, affix_type)
canonicalize_part(part, lang, sc)
local link_term, display_term = export.make_affix(part.term, part.lang, part.sc, affix_type, not part.alt, nil, part.id)
part.term = link_term
-- When we don't specify `do_affix_mapping` to make_affix(), link and display terms (first and second retvals of
-- make_affix()) are the same.
-- If part.alt would be the same as part.term, make it nil, so that it isn't erroneously tracked as being
-- redundant alt text.
part.alt = part.alt and export.make_affix(part.alt, part.lang, part.sc, affix_type) or (display_term ~= link_term and display_term) or nil
local Latn = require("Module:scripts").getByCode("Latn")
part.tr = export.make_affix(part.tr, part.lang, Latn, affix_type)
part.ts = export.make_affix(part.ts, part.lang, Latn, affix_type)
end

local function track_wrong_affix_type(template, part, expected_affix_type)
if part then
local affix_type = export.parse_term_for_affixes(part.term, part.lang, part.sc)
if affix_type ~= expected_affix_type then
local part_name = expected_affix_type or "base"
local langcode = part.lang:getCode()
local full_langcode = part.lang:getNonEtymologicalCode()
require("Module:debug/track") {
template,
template .. "/" .. part_name,
template .. "/" .. part_name .. "/" .. (affix_type or "none"),
template .. "/" .. part_name .. "/" .. (affix_type or "none") .. "/lang/" .. langcode
}
-- If `part.lang` is an etymology-only language, track both using its code and its full parent's code.
if full_langcode ~= langcode then
require("Module:debug/track")(
template .. "/" .. part_name .. "/" .. (affix_type or "none") .. "/lang/" .. full_langcode
)
end
end
end
end

local function insert_affix_category(categories, pos, affix_type, part, sort_key, sort_base)
-- Don't add a '*fixed with' category if the link term is empty or is in a different language.
if part.term and not part.part_lang then
local cat = pos .. " " .. affix_type .. "ed with " .. make_entry_name_no_links(part.lang, part.term) ..
(part.id and " (" .. part.id .. ")" or "")
if sort_key or sort_base then
table.insert(categories, {cat = cat, sort_key = sort_key, sort_base = sort_base})
else
table.insert(categories, cat)
end
end
end

--[=[
Implementation of {{circumfix}}.

WARNING: This destructively modifies both `data` and `.prefix`, `.base` and `.suffix`.
]=]
function export.show_circumfix(data)
data.pos = data.pos or default_pos
data.pos = pluralize(data.pos)

canonicalize_part(data.base, data.lang, data.sc)
-- Hyphenate the affixes and apply any affix mappings.
make_part_into_affix(data.prefix, data.lang, data.sc, "prefix")
make_part_into_affix(data.suffix, data.lang, data.sc, "suffix")

track_wrong_affix_type("circumfix", data.prefix, "prefix")
track_wrong_affix_type("circumfix", data.base, nil)
track_wrong_affix_type("circumfix", data.suffix, "suffix")

-- Create circumfix term.
local circumfix = nil

if data.prefix.term and data.suffix.term then
circumfix = data.prefix.term .. " " .. data.suffix.term
data.prefix.alt = data.prefix.alt or data.prefix.term
data.suffix.alt = data.suffix.alt or data.suffix.term
data.prefix.term = circumfix
data.suffix.term = circumfix
end

-- Make links out of all the parts.
local parts_formatted = {}
local categories = {}
local sort_base
if data.base.term then
sort_base = make_entry_name_no_links(data.base.lang, data.base.term)
end

table.insert(parts_formatted, export.link_term(data.prefix, data))
table.insert(parts_formatted, export.link_term(data.base, data))
table.insert(parts_formatted, export.link_term(data.suffix, data))

-- Insert the categories, but don't add a '*fixed with' category if the link term is in a different language.
if not data.prefix.part_lang then
table.insert(categories, {cat=data.pos .. " circumfixed with " .. make_entry_name_no_links(data.prefix.lang,
circumfix), sort_key=data.sort_key, sort_base=sort_base})
end

return export.concat_parts(data.lang, parts_formatted, categories, data.nocat, data.sort_key, data.lit,
data.force_cat)
end

--[=[
Implementation of {{confix}}.

WARNING: This destructively modifies both `data` and `.prefix`, `.base` and `.suffix`.
]=]
function export.show_confix(data)
data.pos = data.pos or default_pos
data.pos = pluralize(data.pos)

canonicalize_part(data.base, data.lang, data.sc)
-- Hyphenate the affixes and apply any affix mappings.
make_part_into_affix(data.prefix, data.lang, data.sc, "prefix")
make_part_into_affix(data.suffix, data.lang, data.sc, "suffix")

track_wrong_affix_type("confix", data.prefix, "prefix")
track_wrong_affix_type("confix", data.base, nil)
track_wrong_affix_type("confix", data.suffix, "suffix")

-- Make links out of all the parts.
local parts_formatted = {}
local prefix_sort_base
if data.base and data.base.term then
prefix_sort_base = make_entry_name_no_links(data.base.lang, data.base.term)
elseif data.suffix.term then
prefix_sort_base = make_entry_name_no_links(data.suffix.lang, data.suffix.term)
end

-- Insert the categories and parts.
local categories = {}

table.insert(parts_formatted, export.link_term(data.prefix, data))
insert_affix_category(categories, data.pos, "prefix", data.prefix, data.sort_key, prefix_sort_base)

if data.base then
table.insert(parts_formatted, export.link_term(data.base, data))
end

table.insert(parts_formatted, export.link_term(data.suffix, data))
-- FIXME, should we be specifying a sort base here?
insert_affix_category(categories, data.pos, "suffix", data.suffix)

return export.concat_parts(data.lang, parts_formatted, categories, data.nocat, data.sort_key, data.lit,
data.force_cat)
end

--[=[
Implementation of {{infix}}.

WARNING: This destructively modifies both `data` and `.base` and `.infix`.
]=]
function export.show_infix(data)
data.pos = data.pos or default_pos
data.pos = pluralize(data.pos)

canonicalize_part(data.base, data.lang, data.sc)
-- Hyphenate the affixes and apply any affix mappings.
make_part_into_affix(data.infix, data.lang, data.sc, "infix")

track_wrong_affix_type("infix", data.base, nil)
track_wrong_affix_type("infix", data.infix, "infix")

-- Make links out of all the parts.
local parts_formatted = {}
local categories = {}

table.insert(parts_formatted, export.link_term(data.base, data))
table.insert(parts_formatted, export.link_term(data.infix, data))

-- Insert the categories.
-- FIXME, should we be specifying a sort base here?
insert_affix_category(categories, data.pos, "infix", data.infix)

return export.concat_parts(data.lang, parts_formatted, categories, data.nocat, data.sort_key, data.lit,
data.force_cat)
end

--[=[
Implementation of {{prefix}}.

WARNING: This destructively modifies both `data` and the structures within `.prefixes`, as well as `.base`.
]=]
function export.show_prefix(data)
data.pos = data.pos or default_pos
data.pos = pluralize(data.pos)

canonicalize_part(data.base, data.lang, data.sc)
-- Hyphenate the affixes and apply any affix mappings.
for i, prefix in ipairs(data.prefixes) do
make_part_into_affix(prefix, data.lang, data.sc, "prefix")
end

for i, prefix in ipairs(data.prefixes) do
track_wrong_affix_type("prefix", prefix, "prefix")
end

track_wrong_affix_type("prefix", data.base, nil)

-- Make links out of all the parts.
local parts_formatted = {}
local first_sort_base = nil
local categories = {}

if data.prefixes[2] then
first_sort_base = make_entry_name_no_links(data.prefixes[2].lang, data.prefixes[2].term)
elseif data.base then
first_sort_base = make_entry_name_no_links(data.base.lang, data.base.term)
end

for i, prefix in ipairs(data.prefixes) do
table.insert(parts_formatted, export.link_term(prefix, data))
insert_affix_category(categories, data.pos, "prefix", prefix, data.sort_key, i == 1 and first_sort_base or nil)
end

if data.base then
table.insert(parts_formatted, export.link_term(data.base, data))
else
table.insert(parts_formatted, "")
end

return export.concat_parts(data.lang, parts_formatted, categories, data.nocat, data.sort_key, data.lit,
data.force_cat)
end

--[=[
Implementation of {{suffix}}.

WARNING: This destructively modifies both `data` and the structures within `.suffixes`, as well as `.base`.
]=]
function export.show_suffix(data)
local categories = {}

data.pos = data.pos or default_pos
data.pos = pluralize(data.pos)

canonicalize_part(data.base, data.lang, data.sc)
-- Hyphenate the affixes and apply any affix mappings.
for i, suffix in ipairs(data.suffixes) do
make_part_into_affix(suffix, data.lang, data.sc, "suffix")
end

track_wrong_affix_type("suffix", data.base, nil)
for i, suffix in ipairs(data.suffixes) do
track_wrong_affix_type("suffix", suffix, "suffix")
end

-- Make links out of all the parts.
local parts_formatted = {}

if data.base then
table.insert(parts_formatted, export.link_term(data.base, data))
else
table.insert(parts_formatted, "")
end

for i, suffix in ipairs(data.suffixes) do
table.insert(parts_formatted, export.link_term(suffix, data))
end

-- Insert the categories.
for i, suffix in ipairs(data.suffixes) do
-- FIXME, should we be specifying a sort base here?
insert_affix_category(categories, data.pos, "suffix", suffix)

if suffix.pos and rfind(suffix.pos, "patronym") then
table.insert(categories, "patronymics")
end
end

return export.concat_parts(data.lang, parts_formatted, categories, data.nocat, data.sort_key, data.lit,
data.force_cat)
end

return export

Template:Tlist-fight

2026-04-10T07:29:55Z

Jsrs701: 1 revision imported

{{trans-top|name=Tlist-fight|{{#vardefineecho:def|engage in combat}} (fight)}}
* {{t|asta|ozvilívagho}}
* {{t|chak|zama}}
* {{t|doth|lajat}}
* {{t|henl|dreith}}
* {{t|hval|vīlībagon}}
* {{t|irat|shvoshaktu}}
* {{t|kinu|t'ovet}}
* {{t|meer|ozwiliwa}}, {{t+|meer|shmoncha}}
* {{t|munj|stawa}}
* {{t|ravk|ludad}}
* {{t|sang|k'utkho}}
* {{t|shiv|geilihi}}
* {{t|sond|os}}
* {{t|trig|gon|gon daun}}
* {{t|vzaa|cafuuþonoh}}
* {{t|zeme|adawa}}
{{trans-bottom}}<includeonly>[[Category:Sense:{{ucfirst:{{#var:def}}}}]]</includeonly><noinclude>[[Category:Sense templates|fight]]</noinclude>

Template:Tracking/inflection of/tag/sg

2026-04-10T07:29:54Z

Jsrs701: 1 revision imported

<noinclude>==Subpages==
{{Special:PrefixIndex/{{FULLPAGENAME}}/|stripprefix=1}}[[Category:Tracking templates]]</noinclude>

Template:Tlist-hear

2026-04-10T07:29:54Z

Jsrs701: 1 revision imported

{{trans-top|name=Tlist-hear|{{#vardefineecho:def|perceive with the ears}} (hear)}}
* {{t|asta|rývagho}}
* {{t|chak|mara}}
* {{t|doth|charat}}
* {{t|henl|veid}}
* {{t|hval|rȳbagon}}
* {{t|inha|varó}}
* {{t|irat|shosu}}
* {{t|meer|riwa}}
* {{t|meni|íì}}
* {{t|munj|ris}}
* {{t|noal|om}}
* {{t|sang|ghaina}}
* {{t|shiv|ytsihi}}
* {{t|sond|sut}}
* {{t|trig|sen|sen in}}
* {{t|voov|sil}}
* {{t|yuli|looship}}
{{trans-bottom}}<includeonly>[[Category:Sense:{{ucfirst:{{#var:def}}}}]]</includeonly><noinclude>[[Category:Sense templates|hear]]</noinclude>

Template:Tracking/inflection of/unknown/class ix

2026-04-10T07:29:54Z

Jsrs701: 1 revision imported

<noinclude>==Subpages==
{{Special:PrefixIndex/{{FULLPAGENAME}}/|stripprefix=1}}[[Category:Tracking templates]]</noinclude>

Template:Tracking/inflection of/tag/class ix

2026-04-10T07:29:54Z

Jsrs701: 1 revision imported

<noinclude>==Subpages==
{{Special:PrefixIndex/{{FULLPAGENAME}}/|stripprefix=1}}[[Category:Tracking templates]]</noinclude>

Template:Tracking/inflection of/unknown/first-person subject

2026-04-10T07:29:54Z

Jsrs701: 1 revision imported

<noinclude>==Subpages==
{{Special:PrefixIndex/{{FULLPAGENAME}}/|stripprefix=1}}[[Category:Tracking templates]]</noinclude>

Template:Tracking/inflection of/tag/first-person subject

2026-04-10T07:29:54Z

Jsrs701: 1 revision imported

<noinclude>==Subpages==
{{Special:PrefixIndex/{{FULLPAGENAME}}/|stripprefix=1}}[[Category:Tracking templates]]</noinclude>

Template:Tracking/headword/pagename spelling mismatch/noal

2026-04-10T07:29:54Z

Jsrs701: 1 revision imported

<noinclude>==Subpages==
{{Special:PrefixIndex/{{FULLPAGENAME}}/|stripprefix=1}}[[Category:Tracking templates]]</noinclude>

Template:Noalath-noun-decl

2026-04-10T07:29:54Z

Jsrs701: 1 revision imported

{| class="wikitable"
! rowspan="2" style="width:100px; background-color: #00E8FF;"|
! colspan="2" style="text-align: center; background-color: #DDF8FF;"| Indefinite
! colspan="2" style="text-align: center; background-color: #DDF8FF;"| Definite
|-
! style="text-align: center; background-color: #EFFFFF;"| {{#ifeq: {{{class}}} | 4b |Singulative|{{#ifeq: {{{class}}} | 4 |Singulative|Singular}} }}
! style="text-align: center; background-color: #EFFFFF;"| {{#ifeq: {{{class}}} | 4b |Basic|{{#ifeq: {{{class}}} | 4 |Basic|Plural}} }}
! style="text-align: center; background-color: #EFFFFF;"| {{#ifeq: {{{class}}} | 4b |Singulative|{{#ifeq: {{{class}}} | 4 |Singulative|Singular}} }}
! style="text-align: center; background-color: #EFFFFF;"| {{#ifeq: {{{class}}} | 4b |Basic|{{#ifeq: {{{class}}} | 4 |Basic|Plural}} }}
|-
| style="text-align: center; background-color: #DDF8FF;"| '''Nominative'''
| style="text-align: center;" | [[{{{ini}}}{{{med}}}{{#ifeq: {{{class}}} | 4b |{{#switch: {{{fin}}} | sh = ha | ch = sha | f | v | th | V | Th | h = | p = fa | b = va | t = tha | d = dha | s = ha | j = zha | k = ha | g = ha | y = zha | r = ra | l = la | m = ma | n = na | {{{fin}}}a }}ch |{{#ifeq: {{{class}}} | 4 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = ach | {{{fin}}}ach }} | {{{fin}}} }} }}]]
| style="text-align: center;" | [[{{#ifeq: {{{class}}} | 4b | {{{ini}}}{{{med}}}{{{fin}}} | {{#ifeq: {{{class}}} | 4 | {{{ini}}}{{{med}}}{{{fin}}} | {{{ini}}}{{{med}}}{{#ifeq: {{{class}}} | 1b |{{#vardefineecho:ymutfin|{{#switch: {{{fin}}} | f = y | v = y | t = ch | d = j | th = sh | s = sh | k = ch | g = j | h = sh | r = zh | l = y | n = ny | = y | {{{fin}}} }} }}|{{#ifeq: {{{class}}} | 1 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = {{{fin}}} | {{{fin}}}i }} |{{#ifeq: {{{class}}} | 3b |{{#switch: {{{fin}}} | f = y | v = y | t = ch | d = j | th = sh | s = sh | k = ch | g = j | h = sh | r = zh | l = y | n = ny | = y | {{{fin}}} }}ith|{{#ifeq: {{{class}}} | 3 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = a | {{{fin}}} }}ith |{{#ifeq: {{{class}}} | 5 | {{#switch: {{{fin}}} | a = azh | e = ezh | i = izh | u = uzh | o = ozh | ü = üzh | ö = özh | {{{fin}}}i }}|{{#ifeq: {{{class}}} | 2b | {{#vardefineecho:vmutfin| {{#switch: {{{fin}}} | sh = ha | ch = sha | f | v | th | h = | p = fa | b = va | t = tha | d = dha | s = ha | y | j = zha | k | g = ha | {{{fin}}}a }} }} |{{{fin}}}{{#vardefineecho:fina|{{#switch: {{{fin}}} | a | e | i | o | u | ü | ö = | a }} }} }} }} }} }} }} }} }} }}]]
| style="text-align: center;" | [[u]] [[{{#vardefineecho:vmutini|{{#switch: {{{ini}}} | sh = h | ch = sh | f | v | th | V | Th | h = y | p = f | b = v | t = th | d = dh | s = h | j = zh | k = h | G = G | g = h | y = zh | r = r | l = l | m = m | n = n | Sh = Sh | O = Yo | A = Ya | y{{{ini}}} }} }}{{{med}}}{{#ifeq: {{{class}}} | 4b |{{#switch: {{{fin}}} | sh = ha | ch = sha | f | v | th | V | Th | h = | p = fa | b = va | t = tha | d = dha | s = ha | j = zha | k = ha | g = ha | y = zha | r = ra | l = la | m = ma | n = na | {{{fin}}}a }}ch|{{#ifeq: {{{class}}} | 4 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = ach | {{{fin}}}ach }} | {{{fin}}} }} }}]]
| style="text-align: center;" | [[u]] [[{{#ifeq: {{{class}}} | 4b | {{#var:vmutini}}{{{med}}}{{{fin}}} | {{#ifeq: {{{class}}} | 4 | {{#var:vmutini}}{{{med}}}{{{fin}}} |{{#var:vmutini}}{{{med}}}{{#ifeq: {{{class}}} | 1b |{{#var:ymutfin}}|{{#ifeq: {{{class}}} | 1 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = {{{fin}}} | {{{fin}}}i }} |{{#ifeq: {{{class}}} | 3b |{{#switch: {{{fin}}} | f = y | v = y | t = ch | d = j | th = sh | s = sh | k = ch | G = G | g = j | h = sh | r = zh | l = y | n = ny | = y | {{{fin}}} }}ith|{{#ifeq: {{{class}}} | 3 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = a | {{{fin}}} }}ith |{{#ifeq: {{{class}}} | 5 | {{#switch: {{{fin}}} | a = azh | e = ezh | i = izh | u = uzh | o = ozh | ü = üzh | ö = özh | {{{fin}}}i }}|{{#ifeq: {{{class}}} | 2b |{{#var:vmutfin}}|{{{fin}}}{{#var:fina}} }} }} }} }} }} }} }} }}]]
|-
| style="text-align: center; background-color: #DDF8FF;"| '''Objective'''
| style="text-align: center;" | [[{{#vardefineecho:ymutini|{{#switch: {{{ini}}} | f = y | v = y | t = ch | d = j | th = sh | s = sh | k = ch | g = j | h = sh | r = zh | l = y | n = ny | = y | {{{ini}}} }} }}{{{med}}}{{#ifeq: {{{class}}} | 4b |{{#switch: {{{fin}}} | sh = ha | ch = sha | f | v | th | V | Th | h = | p = fa | b = va | t = tha | d = dha | s = ha | j = zha | k = ha | g = ha | y = zha | r = ra | l = la | m = ma | n = na | {{{fin}}}a }}ch |{{#ifeq: {{{class}}} | 4 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = ach | {{{fin}}}ach }} | {{{fin}}} }} }}]]
| style="text-align: center;" | [[{{#ifeq: {{{class}}} | 4b | {{#var:ymutini}}{{{med}}}{{{fin}}} | {{#ifeq: {{{class}}} | 4 | {{#var:ymutini}}{{{med}}}{{{fin}}} | {{#var:ymutini}}{{{med}}}{{#ifeq: {{{class}}} | 1b |{{#var:ymutfin}}ik|{{#ifeq: {{{class}}} | 1 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = a | {{{fin}}} }}ik |{{#ifeq: {{{class}}} | 3b |{{#switch: {{{fin}}} | f = y | v = y | t = ch | d = j | th = sh | s = sh | k = ch | g = j | h = sh | r = zh | l = y | n = ny | = y | {{{fin}}} }}ith|{{#ifeq: {{{class}}} | 3 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = a | {{{fin}}} }}ith |{{#ifeq: {{{class}}} | 5 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = {{{fin}}}rik | {{{fin}}}ik }} |{{#ifeq: {{{class}}} | 2b |{{#var:vmutfin}}|{{{fin}}}{{#var:fina}} }}n }} }} }} }} }} }} }}]]
| style="text-align: center;" | [[ü]] [[{{#vardefineecho:ymutinidef|{{#switch: {{{ini}}} | f = y | v = y | t = ch | d = j | th = sh | s = sh | k = ch | G = G | g = j | h = sh | r = zh | l = y | n = ny | m = m | y = y | j = j | sh = sh | ch = ch | p = p | b = b | O = Yo | A = Ya | V = Y | Th = Sh | Sh = Sh | = y | y{{{ini}}} }} }}{{{med}}}{{#ifeq: {{{class}}} | 4b |{{#switch: {{{fin}}} | sh = ha | ch = sha | f | v | th | V | Th | h = | p = fa | b = va | t = tha | d = dha | s = ha | j = zha | k = ha | g = ha | y = zha | r = ra | l = la | m = ma | n = na | {{{fin}}}a }}ch |{{#ifeq: {{{class}}} | 4 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = ach | {{{fin}}}ach }} | {{{fin}}} }} }}]]
| style="text-align: center;" | [[ü]] [[{{#ifeq: {{{class}}} | 4b | {{#var:ymutini}}{{{med}}}{{{fin}}} | {{#ifeq: {{{class}}} | 4 | {{#var:ymutini}}{{{med}}}{{{fin}}} | {{#var:ymutinidef}}{{{med}}}{{#ifeq: {{{class}}} | 1b |{{#var:ymutfin}}ik|{{#ifeq: {{{class}}} | 3b |{{#switch: {{{fin}}} | f = y | v = y | t = ch | d = j | th = sh | s = sh | k = ch | G = G | g = j | h = sh | r = zh | l = y | n = ny | = y | {{{fin}}} }}ith|{{#ifeq: {{{class}}} | 3 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = a | {{{fin}}} }}ith |{{#ifeq: {{{class}}} | 1 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = a | {{{fin}}} }}ik |{{#ifeq: {{{class}}} | 5 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = {{{fin}}}rik | {{{fin}}}ik }} |{{#ifeq: {{{class}}} | 2b |{{#var:vmutfin}}|{{{fin}}}{{#var:fina}} }}n}} }} }} }} }} }} }}]]
|-
| style="text-align: center; background-color: #DDF8FF;"| '''Genitive'''
| style="text-align: center;" | [[{{#vardefineecho:nmutini|{{#switch: {{{ini}}} | p = b | b = m | f = p | v = b | t = d | d = n | th = t | s = ts | sh = ch | ch = j | j = ny | k = g | g = ng | h = | r = d | l = n | {{{ini}}} }} }}{{{med}}}{{#ifeq: {{{class}}} | 4b |{{#switch: {{{fin}}} | sh = ha | ch = sha | f | v | th | V | Th | h = | p = fa | b = va | t = tha | d = dha | s = ha | j = zha | k = ha | g = ha | y = zha | r = ra | l = la | m = ma | n = na | {{{fin}}}a }}ch |{{#ifeq: {{{class}}} | 4 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = ach | {{{fin}}}ach }} | {{{fin}}} }} }}]]
| style="text-align: center;" | [[{{#var:nmutini}}{{{med}}}{{#ifeq: {{{class}}} | 1b |{{#switch: {{{fin}}} | sh = h | ch = sh | f | v | th | h = r | p = f | b = v | t = th | d = dh | s = h | j = zh | k = h | g = h | y = zh | {{{fin}}} }}a|{{#ifeq: {{{class}}} | 1 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = {{{fin}}} | {{{fin}}}a }} |{{#ifeq: {{{class}}} | 3b | {{#switch: {{{fin}}} | sh = ha | ch = sha | f | v | th | h = | p = fa | b = va | t = tha | d = dha | s = ha | y | j = zha | k | g = ha | {{{fin}}}a }}|{{#ifeq: {{{class}}} | 3 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = {{{fin}}} | {{{fin}}}a }} |{{#ifeq: {{{class}}} | 5 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = {{{fin}}} | {{{fin}}}a }} |{{#ifeq: {{{class}}} | 3b | {{#switch: {{{fin}}} | sh = ha | ch = sha | f | v | th | h = | p = fa | b = va | t = tha | d = dha | s = ha | y | j = zha | k | g = ha | {{{fin}}}a }} |{{#ifeq: {{{class}}} | 2b |{{#var:vmutfin}}|{{{fin}}}{{#var:fina}} }} }} }} }} }} }} }}]]
| style="text-align: center;" | [[an]] [[{{#var:nmutini}}{{{med}}}{{#ifeq: {{{class}}} | 4b |{{#switch: {{{fin}}} | sh = ha | ch = sha | f | v | th | V | Th | h = | p = fa | b = va | t = tha | d = dha | s = ha | j = zha | k = ha | g = ha | y = zha | r = ra | l = la | m = ma | n = na | {{{fin}}}a }}ch |{{#ifeq: {{{class}}} | 4 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = ach | {{{fin}}}ach }} | {{{fin}}} }} }}]]
| style="text-align: center;" | [[an]] [[{{#ifeq: {{{class}}} | 4b | {{#var:nmutini}}{{{med}}}{{{fin}}} | {{#ifeq: {{{class}}} | 4 | {{#var:nmutini}}{{{med}}}{{{fin}}} | {{#var:nmutini}}{{{med}}}{{#ifeq: {{{class}}} | 1b |{{#switch: {{{fin}}} | sh = h | ch = sh | f | v | th | h = r | p = f | b = v | t = th | d = dh | s = h | j = zh | k = h | g = h | y = zh | {{{fin}}} }}a|{{#ifeq: {{{class}}} | 1 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = {{{fin}}} | {{{fin}}}a }} |{{#ifeq: {{{class}}} | 3b | {{#switch: {{{fin}}} | sh = ha | ch = sha | f | v | th | h = | p = fa | b = va | t = tha | d = dha | s = ha | y | j = zha | k | g = ha | {{{fin}}}a }}|{{#ifeq: {{{class}}} | 3 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = {{{fin}}} | {{{fin}}}a }} |{{#ifeq: {{{class}}} | 5 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = {{{fin}}} | {{{fin}}}a }} |{{#ifeq: {{{class}}} | 3b | {{#switch: {{{fin}}} | sh = ha | ch = sha | f | v | th | h = | p = fa | b = va | t = tha | d = dha | s = ha | y | j = zha | k | g = ha | {{{fin}}}a }} |{{#ifeq: {{{class}}} | 2b |{{#var:vmutfin}}|{{{fin}}}{{#var:fina}} }} }} }} }} }} }} }} }} }}]]
|-
| style="text-align: center; background-color: #DDF8FF;"| '''Vocative'''
| colspan="2" style="text-align: center;background-color: #CCCCCC;" |
| style="text-align: center;" | [[e]] [[{{#var:vmutini}}{{{med}}}{{#ifeq: {{{class}}} | 4b |{{#switch: {{{fin}}} | sh = ha | ch = sha | f | v | th | V | Th | h = | p = fa | b = va | t = tha | d = dha | s = ha | j = zha | k = ha | g = ha | y = zha | r = ra | l = la | m = ma | n = na | {{{fin}}}a }}ch|{{#ifeq: {{{class}}} | 4 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = ach | {{{fin}}}ach }} |{{#ifeq: {{{class}}} | 1b |{{#switch: {{{fin}}} | sh = h | ch = sh | f | v | th | h = r | p = f | b = v | t = th | d = dh | s = h | j = zh | k = h | g = h | y = zh | {{{fin}}} }}a|{{#ifeq: {{{class}}} | 1 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = {{{fin}}} | {{{fin}}}a }} |{{#ifeq: {{{class}}} | 5 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = {{{fin}}} | {{{fin}}}a }} |{{#ifeq: {{{class}}} | 3 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = {{{fin}}} | {{{fin}}}a }} |{{#ifeq: {{{class}}} | 3b | {{#switch: {{{fin}}} | sh = ha | ch = sha | f | v | th | h = | p = fa | b = va | t = tha | d = dha | s = ha | y | j = zha | k | g = ha | {{{fin}}}a }} |{{#ifeq: {{{class}}} | 2b |{{#var:vmutfin}}|{{{fin}}}{{#var:fina}} }} }} }} }} }} }} }} }}]]
| style="text-align: center;" | [[e]] [[{{#ifeq: {{{class}}} | 4b | {{#var:vmutini}}{{{med}}}{{#switch: {{{fin}}} | sh = ha | ch = sha | f | v | th | h = | p = fa | b = va | t = tha | d = dha | s = ha | y | j = zha | k | g = ha | {{{fin}}}a }} | {{#ifeq: {{{class}}} | 4 | {{#var:vmutini}}{{{med}}}{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = {{{fin}}} | {{{fin}}}a }} | {{#var:vmutini}}{{{med}}}{{#ifeq: {{{class}}} | 1b |{{#var:ymutfin}}ik|{{#ifeq: {{{class}}} | 1 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = a | {{{fin}}} }}ik |{{#ifeq: {{{class}}} | 3b |{{#switch: {{{fin}}} | f = y | v = y | t = ch | d = j | th = sh | s = sh | k = ch | g = j | h = sh | r = zh | l = y | n = ny | = y | {{{fin}}} }}ith|{{#ifeq: {{{class}}} | 3 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = a | {{{fin}}} }}ith |{{#ifeq: {{{class}}} | 5 |{{#switch: {{{fin}}} | a | e | i | u | ü | ö | o = {{{fin}}}zh | {{{fin}}}ik }} |{{#ifeq: {{{class}}} | 2b |{{#var:vmutfin}}|{{{fin}}}{{#var:fina}} }}n}} }} }} }} }} }} }}]]
|}<noinclude>[[Category:Noalath noun inflection-table templates]]</noinclude>

Template:Invis

2026-04-10T07:29:54Z

Jsrs701: 1 revision imported

{| class="mw-collapsible mw-collapsed wikitable"
! style="font-weight:normal; background-color:#fafafa;"|From an [[invisible proto-language]]. 
|-
| The etymology of this word comes from an [[invisible proto-language]]. If you're confident you know the etymology, feel free to add it, but reader beware should the etymology be added by someone other than the creator of the language!
|}<noinclude>[[Category:Maintenance templates]]</noinclude>

Template:Tracking/inflection of/unknown/class vi

2026-04-10T07:29:54Z

Jsrs701: 1 revision imported

<noinclude>==Subpages==
{{Special:PrefixIndex/{{FULLPAGENAME}}/|stripprefix=1}}[[Category:Tracking templates]]</noinclude>

Template:Tracking/inflection of/tag/class vi

2026-04-10T07:29:54Z

Jsrs701: 1 revision imported

<noinclude>==Subpages==
{{Special:PrefixIndex/{{FULLPAGENAME}}/|stripprefix=1}}[[Category:Tracking templates]]</noinclude>

Template:Tlist-cut

2026-04-10T07:29:54Z

Jsrs701: 1 revision imported

{{trans-top|name=Tlist-cut|{{#vardefineecho:def|incise or divide with a sharp instrument}} (cut)}}
* {{t|asta|néhtogho}}
* {{t|cast|adu}}
* {{t|chak|dimadha}}
* {{t|doth|rissat}}
* {{t|henl|kwys}}
* {{t|hval|nektogon}}
* {{t|irat|shektu}}
* {{t|meer|nyeta}}
* {{t|noal|lagus}}
* {{t|ravk|vrasad}}
* {{t|sang|mech'in}}
* {{t|shiv|todhihi}}
* {{t|trig|kot|kot op}}
* {{t|vzaa|etsonoh}}
* {{t|veda|sun}}
{{trans-bottom}}<includeonly>[[Category:Sense:{{ucfirst:{{#var:def}}}}]]</includeonly><noinclude>[[Category:Sense templates|cut]]</noinclude>

Template:Tlist-drink

2026-04-10T07:29:54Z

Jsrs701: 1 revision imported

{{trans-top|name=Tlist-drink|{{#vardefineecho:def|ingest a liquid}} (drink)}}
* {{t|afat|pübe}}
* {{t|chak|zaiha}}
* {{t|doth|indelat}}
* {{t|fjer|güget}}
* {{t|gand|pul}}
* {{t|hval|mōzugon}}
* {{t|irat|shrazu}}, {{t+|irat|shekenyuze}} {{q|used for ingesting things in general}}
* {{t|kinu|zunet}}
* {{t|meer|mozo}}
* {{t|meni|lízù}}
* {{t|trig|drein|drein daun}}
* {{t|veda|pul}}
{{trans-bottom}}<includeonly>[[Category:Sense:{{ucfirst:{{#var:def}}}}]]</includeonly><noinclude>[[Category:Sense templates|drink]]</noinclude>

Template:Tlist-come

2026-04-10T07:29:53Z

Jsrs701: 1 revision imported

{{trans-top|name=Tlist-come|{{#vardefineecho:def|move nearer to or arrive at a point}} (come)}}
* {{t|asta|májigho}}
* {{t|cast|ronu}}
* {{t|chak|hura}}
* {{t|doth|jadat}}
* {{t|fjer|leyet}}
* {{t|gand|æg}}
* {{t|henl|keim}}
* {{t|hval|māzigon}}
* {{t|irat|shetusu}}
* {{t|kezh|tanagí}}
* {{t|kinu|luset}}
* {{t|meer|maye}}
* {{t|meni|'èmé}}
* {{t|munj|'in}}
* {{t|ovus|luo}}
* {{t|ravk|syalad}}
* {{t|rooz|kém}}
* {{t|sang|jaya}}
* {{t|shiv|ääfihi}}
* {{t|sond|dus}}
* {{t|trig|kom|kom op}}
* {{t|tsit|ráì}}
* {{t|veda|ag}}
* {{t|voov|git}}
* {{t|yuli|garrip}}
{{trans-bottom}}<includeonly>[[Category:Sense:{{ucfirst:{{#var:def}}}}]]</includeonly><noinclude>[[Category:Sense templates|come]]</noinclude>

Template:Tlist-think

2026-04-10T07:29:53Z

Jsrs701: 1 revision imported

{{trans-top|name=Tlist-think|{{#vardefineecho:def|ponder ideas}} (think)}}
* {{t|asta|odábagho}}
* {{t|bodz|rǝln}}
* {{t|chak|minaza}}
* {{t|doth|dirgat}}
* {{t|fjer|köpset}}
* {{t|henl|nik}}
* {{t|hval|otāpagon}}
* {{t|irat|shekesulu}}
* {{t|kezh|ale}}
* {{t|kinu|nevimet}}
* {{t|meer|odhava}}
* {{t|meni|pán}}
* {{t|ovus|ielie}}
* {{t|sang|kkhat'a}}
* {{t|trig|fig|fig op}}
* {{t|veda|bim}}
* {{t|yuli|droomip}}
{{trans-bottom}}<includeonly>[[Category:Sense:{{ucfirst:{{#var:def}}}}]]</includeonly><noinclude>[[Category:Sense templates|think]]</noinclude>

Template:Enga-verb-conj

2026-04-10T07:29:53Z

Jsrs701: 1 revision imported

{| role="presentation" class="mw-collapsible mw-collapsed" style="background-color:#f0f0f0;border-collapse:separate;border-spacing:2px;width:35em;text-align:center;"
|- style="text-align:left;"
! colspan="8" style="background-color:#c0cfe4;" | Conjugation of ''{{{1}}}''
|-
! class="outer" |
! colspan="2" rowspan="2" class="outer" style="background-color:#95DF54; |
! colspan="2" class="outer" style="background-color:#006F01;color:white; | Plain form
! colspan="2" class="outer" style="background-color:#006F01;color:white; | Reduplicated form
|-
!
! style="background:#DEFDDB | singular
! style="background:#DEFDDB | plural
! style="background:#DEFDDB | singular
! style="background:#DEFDDB | plural
|-
|- style="background-color:#f8f8f8;"
!
! colspan="2" rowspan="1" style="background-color:#006F01;color:white;" | First Person
| [[{{#switch: {{{stress|}}} |irr={{{1}}}{{#switch: {{{fin}}} |a=on|e=un|o=un|i=un|u=un|s=un|n=un}}| {{{5|{{{3}}}}}}{{#switch: {{{fin}}} |a=on|e=un|o=un|i=un|u=un|s=un|n=un}}}}]]
| [[{{#switch: {{{stress|}}} |irr={{{1}}}{{#switch: {{{fin}}} |a=on|e=un|o=un|i=un|u=un|s=un|n=un}}|{{{5|{{{3}}}}}}{{#switch: {{{fin}}} |a=au|e=o|o=o|i=u|u=u|s=u|n=gu}}}}]]
| [[{{{6|{{{4}}}}}}{{#switch: {{{fin}}} |a=on|e=un|o=un|i=un|u=un|s=un|n=un}}]]
| [[{{{6|{{{4}}}}}}{{#switch: {{{fin}}} |a=au|e=o|o=o|i=u|u=u|s=u|n=gu}}]]
|-
|- style="background-color:#f8f8f8;"
!
! colspan="2" rowspan="1" style="background-color:#006F01;color:white;" | Second Person
| [[{{#switch: {{{stress|}}} |irr={{{1}}}{{#switch: {{{fin}}} |a=on|e=un|o=un|i=un|u=un|s=un|n=un}}|{{#ifeq: {{{fin}}} | i | {{{3}}}is | {{{5|{{{3}}}}}}{{#switch: {{{fin}}} |a=es|e=es|o=es|i=is|u=wis|s=is|n=is}}}}}}]]
| [[{{#ifeq: {{{fin}}} | i | {{{3}}}isís | {{#ifeq: {{{fin}}} | n | {{{3}}}tsís | {{{5|{{{3}}}}}}{{#switch: {{{fin}}} |a=aisís|e=esís|o=esís|i=is|u=wisís|s=isís|n=tsís}}}}}}]]
| [[{{#ifeq: {{{fin}}} | i | {{{4}}}is | {{{6|{{{4}}}}}}{{#switch: {{{fin}}} |a=es|e=es|o=es|i=is|u=wis|s=is|n=is}}}}]]
| [[{{#ifeq: {{{fin}}} | i | {{{4}}}isís | {{#ifeq: {{{fin}}} | n | {{{4}}}tsís | {{{6|{{{4}}}}}}{{#switch: {{{fin}}} |a=aisís|e=esís|o=esís|i=is|u=wisís|s=isís|n=tsís}}}}}}]]
|-
|- style="background-color:#f8f8f8;"
!
! colspan="2" rowspan="1" style="background-color:#006F01;color:white;" | Third Person
| [[{{{1}}}]]
| [[{{#ifeq: {{{fin}}} | n | {{{3}}}tsás | {{{5|{{{3}}}}}}{{#switch: {{{fin}}} |a=asás|e=asás|o=osás|i=asás|u=wasás|s=asás|n=tsás}}}}]]
| [[{{{2}}}]]
| [[{{#ifeq: {{{fin}}} | n | {{{4}}}tsás | {{{6|{{{4}}}}}}{{#switch: {{{fin}}} |a=asás|e=asás|o=osás|i=asás|u=wasás|s=asás|n=tsás}}}}]]
|-
|- style="background-color:#f8f8f8;"
!
! colspan="2" rowspan="1" style="background-color:#006F01;color:white;" | Reflexive
| colspan="2" | [[{{#ifeq: {{{fin}}} | n | {{{1}}}í | {{{1}}}mí}}]]
| colspan="2" | [[{{#ifeq: {{{fin}}} | n | {{{2}}}í | {{{2}}}mí}}]]
|}<noinclude>{{documentation}}

[[Category:Engála templates]][[Category:Engála verb inflection-table templates]]</noinclude>

Template:Enga-orth

2026-04-10T07:29:53Z

Jsrs701: 1 revision imported

<span style="font-family: EngalaGrass;">{{huge|valign=normal|{{{form}}}|140%}}</span><noinclude>[[Category:Engála templates]][[Category:Orthography templates]]</noinclude>

Template:Tracking/headword/pagename spelling mismatch/enga

2026-04-10T07:29:53Z

Jsrs701: 1 revision imported

<noinclude>==Subpages==
{{Special:PrefixIndex/{{FULLPAGENAME}}/|stripprefix=1}}[[Category:Tracking templates]]</noinclude>

Template:Tlist-hit

2026-04-10T07:29:53Z

Jsrs701: 1 revision imported

{{trans-top|name=Tlist-hit|{{#vardefineecho:def|come into contact with forcefully and suddenly}} (hit)}}
* {{t|chak|aga}}, {{t+|chak|tasa}}
* {{t|doth|lojat}}
* {{t|hval|hīlagon}}
* {{t|irat|shemegvu}}
* {{t|kinu|t'opet}}, {{t+|kinu|iiret}}, {{t+|kinu|k'uret}}
* {{t|sang|itskha}}
* {{t|sond|gup}}
* {{t|veda|suk}}
{{trans-bottom}}<includeonly>[[Category:Sense:{{ucfirst:{{#var:def}}}}]]</includeonly><noinclude>[[Category:Sense templates|hit]]</noinclude>

Template:Tracking/inflection of/unknown/class iii

2026-04-10T07:29:52Z

Jsrs701: 1 revision imported

<noinclude>==Subpages==
{{Special:PrefixIndex/{{FULLPAGENAME}}/|stripprefix=1}}[[Category:Tracking templates]]</noinclude>

Template:Tracking/inflection of/tag/class iii

2026-04-10T07:29:52Z

Jsrs701: 1 revision imported

<noinclude>==Subpages==
{{Special:PrefixIndex/{{FULLPAGENAME}}/|stripprefix=1}}[[Category:Tracking templates]]</noinclude>

Template:Tlist-hunt

2026-04-10T07:29:52Z

Jsrs701: 1 revision imported

{{trans-top|name=Tlist-hunt|{{#vardefineecho:def|search for an animal in the wild with the intention of killing it}} (hunt)}}
* {{t|chak|vizala}}
* {{t|doth|fonat}}
* {{t|hval|arghugon}}
* {{t|irat|sheshinku}}
* {{t|kinu|maret}}
* {{t|meni|óvrè}}
* {{t|ovus|fausie}}
* {{t|sang|chkha'a}}
* {{t|sond|kul}}
* {{t|vzaa|vaneneh}}
* {{t|veda|qankho}}
{{trans-bottom}}<includeonly>[[Category:Sense:{{ucfirst:{{#var:def}}}}]]</includeonly><noinclude>[[Category:Sense templates|hunt]]</noinclude>

Template:Tlist-say

2026-04-10T07:29:52Z

Jsrs701: 1 revision imported

{{trans-top|name=Tlist-say|{{#vardefineecho:def|produce a verbal message}} (say)}}
* {{t|asta|ivétragho}}
* {{t|cast|erustalu}}, {{t+|cast|pengu}} {{q|flood form}}
* {{t|chak|jara}}
* {{t|doth|astat}}
* {{t|henl|dike}}
* {{t|hval|vestragon}}
* {{t|inha|zhonó}}
* {{t|irat|shalu}}, {{t+|irat|shalaktu}}
* {{t|kezh|izu}}
* {{t|meer|poghá}}, {{t+|meer|yewetra}}
* {{t|munj|hio}}
* {{t|noal|vek}}
* {{t|ovus|mikaa}}
* {{t|ravk|ashad}}
* {{t|rooz|díge}}
* {{t|sang|khawa}}
* {{t|sond|pwi}}
* {{t|trig|tel|tel op}}, {{t+|trig|biyo}} {{q|only with a full clause complement}}, {{t+|trig|mema|mema in}}
* {{t|veda|qas}}
* {{t|yuli|göörip}}, {{t+|yuli|biilip}}
{{trans-bottom}}<includeonly>[[Category:Sense:{{ucfirst:{{#var:def}}}}]]</includeonly><noinclude>[[Category:Sense templates|say]]</noinclude>

Module:Attention

2026-04-10T07:29:52Z

Jsrs701: 1 revision imported

local m_params = require("Module:parameters")
local m_params_data = mw.loadData("Module:parameters/data").attention
local format_categories = require("Module:utilities").format_categories

local export = {}

function export.show(frame)
local args = m_params.process(frame:getParent().args, m_params_data.show)

local lang_code = args[1]
local title = args[2] and mw.text.encode(args[2])
local id = args["id"] and mw.uri.anchorEncode(args["id"]) or ""

local categories = {}

if not args["nocat"] then
local lang = require("Module:languages").getByCode(lang_code, 1)

table.insert(categories, format_categories({"Requests for attention concerning " .. lang:getCanonicalName()}, lang))

if not (title or mw.title.getCurrentTitle().nsText == "Template") then
table.insert(categories, format_categories({"attention lacking explanation"}, lang, "-"))
end
end

local ret = mw.html.create("span")
:attr("id", "attentionseeking" .. lang_code .. id)
:addClass("attentionseeking")
:attr("lang", lang_code)

if title then
ret = ret:attr("title", title)
end

return tostring(ret) .. table.concat(categories)
end

return export

Template:Attention

2026-04-10T07:29:52Z

Jsrs701: 1 revision imported

<includeonly>{{#invoke:attention|show}}</includeonly><noinclude>{{documentation}}</noinclude>

Template:Tlist-see

2026-04-10T07:29:51Z

Jsrs701: 1 revision imported

{{trans-top|name=Tlist-see|{{#vardefineecho:def|perceive with the eyes}} (see)}}
* {{t|asta|órnegho}}
* {{t|azra|be}}
* {{t|cast|banérulu}}
* {{t|chak|heshya}}
* {{t|doth|tihat}}
* {{t|enga|lusi}}
* {{t|fjer|ibet}}
* {{t|hval|urnegon}}
* {{t|irat|shetu}}
* {{t|kinu|helet}}
* {{t|meer|ornya}}
* {{t|meni|vem}}
* {{t|munj|lon}}
* {{t|noal|ais}}
* {{t|sang|ch'anik'o}}
* {{t|shiv|vurihi}}
* {{t|sond|pur}}
* {{t|trig|sin|sin in}}
* {{t|tsit|báì}}
* {{t|vzaa|tosonoh}}
* {{t|veda|yun}}
* {{t|yuli|muukip}}
{{trans-bottom}}<includeonly>[[Category:Sense:{{ucfirst:{{#var:def}}}}]]</includeonly><noinclude>[[Category:Sense templates|see]]</noinclude>

Template:Tlist-know

2026-04-10T07:29:51Z

Jsrs701: 1 revision imported

{{trans-top|name=Tlist-know|{{#vardefineecho:def|be aware of facts or information}} (know)}}
* {{t|asta|gímigho}}
* {{t|cast|hinjilu}}
* {{t|chak|leda}}
* {{t|doth|nesat}}
* {{t|henl|vesh}}
* {{t|hval|gīmigon}}
* {{t|irat|shebishu}}
* {{t|kezh|akwat}}
* {{t|meer|khime}}
* {{t|meni|íìzén}}
* {{t|noal|pal}}
* {{t|ovus|ranie}}
* {{t|sang|iik'u}}
* {{t|shiv|uathihi}}
* {{t|sond|puk}}
* {{t|trig|get|get in}}
* {{t|vzaa|memeneh}}
* {{t|veda|lǝr}}
* {{t|voov|vēm}}
* {{t|yuli|vöklip}}
{{trans-bottom}}<includeonly>[[Category:Sense:{{ucfirst:{{#var:def}}}}]]</includeonly><noinclude>[[Category:Sense templates|know]]</noinclude>

Template:Tlist-skin

2026-04-10T07:29:51Z

Jsrs701: 1 revision imported

{{trans-top|name=Tlist-skin|{{#vardefineecho:def|outer protective layer of the body}} (skin)}}
* {{t|asta|rungo}}
* {{t|doth|ilek}}
* {{t|hval|ñellyr}}
* {{t|kinu|zek}}
* {{t|lish|pelu}}
* {{t|noal|resh}}
* {{t|trig|leda}}
* {{t|vdia|gildust}}
{{trans-bottom}}<includeonly>[[Category:Sense:{{ucfirst:{{#var:def}}}}]]</includeonly><noinclude>[[Category:Sense templates|skin]]</noinclude>

Template:Tlist-leaf

2026-04-10T07:29:51Z

Jsrs701: 1 revision imported

{{trans-top|name=Tlist-leaf|{{#vardefineecho:def|typically green, flat part of a plant}} (leaf)}}
* {{t|doth|daeni}}
* {{t|hval|temby}}
* {{t|irat|dihagyi}} {{q|of a flower, branched-off}}, {{t+|irat|dvumma}} {{q|large, flat}}
* {{t|kinu|t'is}}
* {{t|noal|felsa}}
* {{t|okok|fii}}
* {{t|ovus|aashau}}
* {{t|ravk|vlon}}
* {{t|sond|novod}}
* {{t|tpaa|shtah}}
* {{t|trig|leda}}
* {{t|zeme|fane}}
{{trans-bottom}}<includeonly>[[Category:Sense:{{ucfirst:{{#var:def}}}}]]</includeonly><noinclude>[[Category:Sense templates|leaf]]</noinclude>

Template:Trig-blend-en

2026-04-10T07:29:50Z

Jsrs701: 1 revision imported

[[Appendix:Glossary#blend|Blend]] of {{w|English language|English}} ''{{wt|{{{1}}}}}'' + ''{{wt|{{{2}}}}}''{{#if:{{{3|}}}| + ''{{wt|{{{3}}}}}''{{#if:{{{4|}}}| + ''{{wt|{{{4}}}}}''{{#if:{{{5|}}}| + ''{{wt|{{{5}}}}}''|}}|}}|}}<includeonly>[[Category:Trigedasleng blends of English terms]][[Category:Trigedasleng terms inherited from English]][[Category:Trigedasleng terms derived from English]]</includeonly><noinclude>[[Category:Trigedasleng templates]]</noinclude>

Template:Wt

2026-04-10T07:29:50Z

Jsrs701: 1 revision imported

[[Wiktionary:{{{1}}}|{{{2|{{{1}}}}}}]]<noinclude>[[Category:Templates]]</noinclude>

Template:Tracking/headword/pagename spelling mismatch/trig

2026-04-10T07:29:50Z

Jsrs701: 1 revision imported

<noinclude>==Subpages==
{{Special:PrefixIndex/{{FULLPAGENAME}}/|stripprefix=1}}[[Category:Tracking templates]]</noinclude>

Module:Languages/data/2

2026-04-10T07:29:50Z

Jsrs701: 1 revision imported

local u = mw.ustring.char
local m_langdata = require("Module:languages/data")
local c = m_langdata.chars
local p = m_langdata.puaChars
local s = m_langdata.shared

-- Ideally, we want to move these into [[Module:languages/data]], but because (a) it's necessary to use require on that module, and (b) they're only used in this data module, it's less memory-efficient to do that at the moment. If it becomes possible to use mw.loadData, then these should be moved there.
s["no-sortkey"] = {
from = {"æ", "ø", "å"},
to = {"z" .. p[1], "z" .. p[2], "z" .. p[3]}
}

s["no-standardchars"] = "AaBbDdEeFfGgHhIiJjKkLlMmNnOoPpRrSsTtUuVvYyÆæØøÅå" .. c.punc

s["ru-Cyrl-entryname"] = {
remove_diacritics = c.grave .. c.acute .. c.diaer,
remove_exceptions = {"Ё", "ё", "Ѣ̈", "ѣ̈", "Я̈", "я̈"}
}

s["ru-Cyrl-sortkey"] = {
from = {
"ё", "ѣ̈", "я̈", -- 2 chars
"і", "ѣ", "ѳ", "ѵ" -- 1 char
},
to = {
"е" .. p[1], "ь" .. p[2], "я" .. p[1],
"и" .. p[1], "ь" .. p[1], "я" .. p[2], "я" .. p[3]
}
}

local m = {}

m["aa"] = {
"Afar",
27811,
"cus-eas",
"Latn",
entry_name = {remove_diacritics = c.acute},
}

m["ab"] = {
"Abkhaz",
5111,
"cau-abz",
"Cyrl, Geor, Latn",
translit = {
Cyrl = "ab-translit",
Geor = "Geor-translit",
},
override_translit = true,
display_text = {Cyrl = s["cau-Cyrl-displaytext"]},
entry_name = {
Cyrl = s["cau-Cyrl-entryname"],
Latn = s["cau-Latn-entryname"],
},
sort_key = {
Cyrl = {
from = {
"х'ә", -- 3 chars
"гь", "гә", "ӷь", "ҕь", "ӷә", "ҕә", "дә", "ё", "жь", "жә", "ҙә", "ӡә", "ӡ'", "кь", "кә", "қь", "қә", "ҟь", "ҟә", "ҫә", "тә", "ҭә", "ф'", "хь", "хә", "х'", "ҳә", "ць", "цә", "ц'", "ҵә", "ҵ'", "шь", "шә", "џь", -- 2 chars
"ӷ", "ҕ", "ҙ", "ӡ", "қ", "ҟ", "ԥ", "ҧ", "ҫ", "ҭ", "ҳ", "ҵ", "ҷ", "ҽ", "ҿ", "ҩ", "џ", "ә" -- 1 char
},
to = {
"х" .. p[4],
"г" .. p[1], "г" .. p[2], "г" .. p[5], "г" .. p[6], "г" .. p[7], "г" .. p[8], "д" .. p[1], "е" .. p[1], "ж" .. p[1], "ж" .. p[2], "з" .. p[2], "з" .. p[4], "з" .. p[5], "к" .. p[1], "к" .. p[2], "к" .. p[4], "к" .. p[5], "к" .. p[7], "к" .. p[8], "с" .. p[2], "т" .. p[1], "т" .. p[3], "ф" .. p[1], "х" .. p[1], "х" .. p[2], "х" .. p[3], "х" .. p[6], "ц" .. p[1], "ц" .. p[2], "ц" .. p[3], "ц" .. p[5], "ц" .. p[6], "ш" .. p[1], "ш" .. p[2], "ы" .. p[3],
"г" .. p[3], "г" .. p[4], "з" .. p[1], "з" .. p[3], "к" .. p[3], "к" .. p[6], "п" .. p[1], "п" .. p[2], "с" .. p[1], "т" .. p[2], "х" .. p[5], "ц" .. p[4], "ч" .. p[1], "ч" .. p[2], "ч" .. p[3], "ы" .. p[1], "ы" .. p[2], "ь" .. p[1]
}
},
},
}

m["ae"] = {
"Avestan",
29572,
"ira-cen",
"Avst, Gujr",
translit = {Avst = "Avst-translit"},
wikipedia_article = "Avestan",
}

m["af"] = {
"Afrikaans",
14196,
"gmw",
"Latn, Arab",
ancestors = "nl",
sort_key = {
Latn = {
remove_diacritics = c.grave .. c.acute .. c.circ .. c.tilde .. c.diaer .. c.ringabove .. c.cedilla .. "'",
from = {"['ʼ]n"},
to = {"n" .. p[1]}
}
},
}

m["ak"] = {
"Akan",
28026,
"alv-ctn",
"Latn",
}

m["am"] = {
"Amharic",
28244,
"sem-eth",
"Ethi",
translit = "Ethi-translit",
}

m["an"] = {
"Aragonese",
8765,
"roa-ibe",
"Latn",
ancestors = "roa-oan",
}

m["ar"] = {
"Arabic",
13955,
"sem-arb",
"Arab, Hebr, Brai, Syrc",
translit = "ar-translit",
entry_name = {Arab = "ar-entryname"},
-- put Judeo-Arabic (Hebrew-script Arabic) under the category header
-- U+FB21 HEBREW LETTER WIDE ALEF so that it sorts after Arabic script titles
sort_key = {
Hebr = {
from = {"^%f[" .. u(0x5D0) .. "-" .. u(0x5EA) .. "]"},
to = {u(0xFB21)},
},
},
}

m["as"] = {
"Assamese",
29401,
"inc-eas",
"as-Beng",
ancestors = "inc-mas",
translit = "as-translit",
}

m["av"] = {
"Avar",
29561,
"cau-ava",
"Cyrl, Latn, Arab",
ancestors = "oav",
translit = {
Cyrl = "cau-nec-translit",
Arab = "ar-translit",
},
override_translit = true,
display_text = {Cyrl = s["cau-Cyrl-displaytext"]},
entry_name = {
Cyrl = s["cau-Cyrl-entryname"],
Latn = s["cau-Latn-entryname"],
},
sort_key = {
Cyrl = {
from = {"гъ", "гь", "гӏ", "ё", "кк", "къ", "кь", "кӏ", "лъ", "лӏ", "тӏ", "хх", "хъ", "хь", "хӏ", "цӏ", "чӏ"},
to = {"г" .. p[1], "г" .. p[2], "г" .. p[3], "е" .. p[1], "к" .. p[1], "к" .. p[2], "к" .. p[3], "к" .. p[4], "л" .. p[1], "л" .. p[2], "т" .. p[1], "х" .. p[1], "х" .. p[2], "х" .. p[3], "х" .. p[4], "ц" .. p[1], "ч" .. p[1]}
},
},
}

m["ay"] = {
"Aymara",
4627,
"sai-aym",
"Latn",
}

m["az"] = {
"Azerbaijani",
9292,
"trk-ogz",
"Latn, Cyrl, fa-Arab",
ancestors = "trk-oat",
dotted_dotless_i = true,
entry_name = {["fa-Arab"] = "ar-entryname"},
sort_key = {
Latn = {
from = {
"i", -- Ensure "i" comes after "ı".
"ç", "ə", "ğ", "x", "ı", "q", "ö", "ş", "ü", "w"
},
to = {
"i" .. p[1],
"c" .. p[1], "e" .. p[1], "g" .. p[1], "h" .. p[1], "i", "k" .. p[1], "o" .. p[1], "s" .. p[1], "u" .. p[1], "z" .. p[1]
}
},
Cyrl = {
from = {"ғ", "ә", "ы", "ј", "ҝ", "ө", "ү", "һ", "ҹ"},
to = {"г" .. p[1], "е" .. p[1], "и" .. p[1], "и" .. p[2], "к" .. p[1], "о" .. p[1], "у" .. p[1], "х" .. p[1], "ч" .. p[1]}
},
},
}

m["ba"] = {
"Bashkir",
13389,
"trk-kbu",
"Cyrl",
translit = "ba-translit",
override_translit = true,
sort_key = {
from = {"ғ", "ҙ", "ё", "ҡ", "ң", "ө", "ҫ", "ү", "һ", "ә"},
to = {"г" .. p[1], "д" .. p[1], "е" .. p[1], "к" .. p[1], "н" .. p[1], "о" .. p[1], "с" .. p[1], "у" .. p[1], "х" .. p[1], "э" .. p[1]}
},
}

m["be"] = {
"Belarusian",
9091,
"zle",
"Cyrl, Latn",
ancestors = "zle-obe",
translit = {Cyrl = "be-translit"},
entry_name = {
remove_diacritics = c.grave .. c.acute,
remove_exceptions = {"Ć", "ć", "Ń", "ń", "Ś", "ś", "Ź", "ź"},
},
sort_key = {
Cyrl = {
from = {"ґ", "ё", "і", "ў"},
to = {"г" .. p[1], "е" .. p[1], "и" .. p[1], "у" .. p[1]}
},
Latn = {
from = {"ć", "č", "dz", "dź", "dž", "ch", "ł", "ń", "ś", "š", "ŭ", "ź", "ž"},
to = {"c" .. p[1], "c" .. p[2], "d" .. p[1], "d" .. p[2], "d" .. p[3], "h" .. p[1], "l" .. p[1], "n" .. p[1], "s" .. p[1], "s" .. p[2], "u" .. p[1], "z" .. p[1], "z" .. p[2]}
},
},
standardChars = {
Cyrl = "АаБбВвГгДдЕеЁёЖжЗзІіЙйКкЛлМмНнОоПпРрСсТтУуЎўФфХхЦцЧчШшЫыЬьЭэЮюЯя",
Latn = "AaBbCcĆćČčDdEeFfGgHhIiJjKkLlŁłMmNnŃńOoPpRrSsŚśŠšTtUuŬŭVvYyZzŹźŽž",
c.punc
},
}

m["bg"] = {
"Bulgarian",
7918,
"zls",
"Cyrl",
ancestors = "cu-bgm",
translit = "bg-translit",
entry_name = {remove_diacritics = c.grave .. c.acute},
standardChars = "АаБбВвГгДдЕеЖжЗзИиЙйКкЛлМмНнОоПпРрСсТтУуФфХхЦцЧчШшЩщЪъЬьЮюЯя" .. c.punc,
}

m["bh"] = {
"Bihari",
135305,
"inc-eas",
"Deva",
ancestors = "inc-mgd",
}

m["bi"] = {
"Bislama",
35452,
"crp",
"Latn",
ancestors = "en",
}

m["bm"] = {
"Bambara",
33243,
"dmn-emn",
"Latn",
sort_key = {
from = {"ɛ", "ɲ", "ŋ", "ɔ"},
to = {"e" .. p[1], "n" .. p[1], "n" .. p[2], "o" .. p[1]}
},
}

m["bn"] = {
"Bengali",
9610,
"inc-eas",
"Beng, Newa",
ancestors = "inc-mbn",
translit = {Beng = "bn-translit"},
}

m["bo"] = {
"Tibetan",
34271,
"sit-tib",
"Tibt", -- sometimes Deva?
ancestors = "xct",
translit = "Tibt-translit",
override_translit = true,
display_text = s["Tibt-displaytext"],
entry_name = s["Tibt-entryname"],
sort_key = "Tibt-sortkey",
}

m["br"] = {
"Breton",
12107,
"cel-bry",
"Latn",
ancestors = "xbm",
sort_key = {
from = {"ch", "c['ʼ’]h"},
to = {"c" .. p[1], "c" .. p[2]}
},
}

m["ca"] = {
"Catalan",
7026,
"roa-ocr",
"Latn",
ancestors = "roa-oca",
sort_key = {
remove_diacritics = c.grave .. c.acute .. c.diaer .. c.cedilla,
from = {"l·l"},
to = {"ll"}
},
standardChars = "AaÀàBbCcÇçDdEeÉéÈèFfGgHhIiÍíÏïJjLlMmNnOoÓóÒòPpQqRrSsTtUuÚúÜüVvXxYyZz·" .. c.punc,
}

m["ce"] = {
"Chechen",
33350,
"cau-vay",
"Cyrl, Latn, Arab",
translit = {
Cyrl = "cau-nec-translit",
Arab = "ar-translit",
},
override_translit = true,
display_text = {Cyrl = s["cau-Cyrl-displaytext"]},
entry_name = {
Cyrl = s["cau-Cyrl-entryname"],
Latn = s["cau-Latn-entryname"],
},
sort_key = {
Cyrl = {
from = {"аь", "гӏ", "ё", "кх", "къ", "кӏ", "оь", "пӏ", "тӏ", "уь", "хь", "хӏ", "цӏ", "чӏ", "юь", "яь"},
to = {"а" .. p[1], "г" .. p[1], "е" .. p[1], "к" .. p[1], "к" .. p[2], "к" .. p[3], "о" .. p[1], "п" .. p[1], "т" .. p[1], "у" .. p[1], "х" .. p[1], "х" .. p[2], "ц" .. p[1], "ч" .. p[1], "ю" .. p[1], "я" .. p[1]}
},
},
}

m["ch"] = {
"Chamorro",
33262,
"poz-sus",
"Latn",
sort_key = {
remove_diacritics = "'",
from = {"å", "ch", "ñ", "ng"},
to = {"a" .. p[1], "c" .. p[1], "n" .. p[1], "n" .. p[2]}
},
}

m["co"] = {
"Corsican",
33111,
"roa-itd",
"Latn",
sort_key = {
from = {"chj", "ghj", "sc", "sg"},
to = {"c" .. p[1], "g" .. p[1], "s" .. p[1], "s" .. p[2]}
},
standardChars = "AaÀàBbCcDdEeÈèFfGgHhIiÌìÏïJjLlMmNnOoÒòPpQqRrSsTtUuÙùÜüVvZz" .. c.punc,
}

m["cr"] = {
"Cree",
33390,
"alg",
"Cans, Latn",
translit = {Cans = "cr-translit"},
}

m["cs"] = {
"Czech",
9056,
"zlw",
"Latn",
ancestors = "cs-ear",
sort_key = {
from = {"á", "č", "ď", "é", "ě", "ch", "í", "ň", "ó", "ř", "š", "ť", "ú", "ů", "ý", "ž"},
to = {"a" .. p[1], "c" .. p[1], "d" .. p[1], "e" .. p[1], "e" .. p[2], "h" .. p[1], "i" .. p[1], "n" .. p[1], "o" .. p[1], "r" .. p[1], "s" .. p[1], "t" .. p[1], "u" .. p[1], "u" .. p[2], "y" .. p[1], "z" .. p[1]}
},
standardChars = "AaÁáBbCcČčDdĎďEeÉéĚěFfGgHhIiÍíJjKkLlMmNnŇňOoÓóPpRrŘřSsŠšTtŤťUuÚúŮůVvYyÝýZzŽž" .. c.punc,
}

m["cu"] = {
"Old Church Slavonic",
35499,
"zls",
"Cyrs, Glag",
translit = "Cyrs-Glag-translit",
entry_name = {Cyrs = s["Cyrs-entryname"]},
sort_key = {Cyrs = s["Cyrs-sortkey"]},
}

m["cv"] = {
"Chuvash",
33348,
"trk-ogr",
"Cyrl",
ancestors = "xbo",
translit = "cv-translit",
override_translit = true,
sort_key = {
from = {"ӑ", "ё", "ӗ", "ҫ", "ӳ"},
to = {"а" .. p[1], "е" .. p[1], "е" .. p[2], "с" .. p[1], "у" .. p[1]}
},
}

m["cy"] = {
"Welsh",
9309,
"cel-bry",
"Latn",
ancestors = "wlm",
sort_key = {
remove_diacritics = c.grave .. c.acute .. c.circ .. c.diaer .. "'",
from = {"ch", "dd", "ff", "ng", "ll", "ph", "rh", "th"},
to = {"c" .. p[1], "d" .. p[1], "f" .. p[1], "g" .. p[1], "l" .. p[1], "p" .. p[1], "r" .. p[1], "t" .. p[1]}
},
standardChars = "ÂâAaBbCcDdEeÊêFfGgHhIiÎîLlMmNnOoÔôPpRrSsTtUuÛûWwŴŵYyŶŷ" .. c.punc,
}

m["da"] = {
"Danish",
9035,
"gmq",
"Latn",
ancestors = "gmq-oda",
sort_key = {
from = {"æ", "ø", "å"},
to = {"z" .. p[1], "z" .. p[2], "z" .. p[3]}
},
standardChars = "AaBbDdEeFfGgHhIiJjKkLlMmNnOoPpRrSsTtUuVvYyÆæØøÅå" .. c.punc,
}

m["de"] = {
"German",
188,
"gmw",
"Latn, Latf",
ancestors = "gmh",
sort_key = {
remove_diacritics = c.grave .. c.acute .. c.circ .. c.diaer .. c.ringabove,
from = {"ß"},
to = {"ss"}
},
standardChars = "AaÄäBbCcDdEeFfGgHhIiJjKkLlMmNnOoÖöPpQqRrSsßTtUuÜüVvWwXxYyZz" .. c.punc,
}

m["dv"] = {
"Dhivehi",
32656,
"inc-ins",
"Thaa, Diak",
ancestors = "elu-prk",
translit = {
Thaa = "dv-translit",
Diak = "Diak-translit",
},
override_translit = true,
}

m["dz"] = {
"Dzongkha",
33081,
"sit-tib",
"Tibt",
ancestors = "xct",
translit = "Tibt-translit",
override_translit = true,
display_text = s["Tibt-displaytext"],
entry_name = s["Tibt-entryname"],
sort_key = "Tibt-sortkey",
}

m["ee"] = {
"Ewe",
30005,
"alv-gbe",
"Latn",
sort_key = {
remove_diacritics = c.tilde,
from = {"ɖ", "dz", "ɛ", "ƒ", "gb", "ɣ", "kp", "ny", "ŋ", "ɔ", "ts", "ʋ"},
to = {"d" .. p[1], "d" .. p[2], "e" .. p[1], "f" .. p[1], "g" .. p[1], "g" .. p[2], "k" .. p[1], "n" .. p[1], "n" .. p[2], "o" .. p[1], "t" .. p[1], "v" .. p[1]}
},
}

m["el"] = {
"Greek",
9129,
"grk",
"Grek, Brai",
ancestors = "el-kth",
translit = {Grek = "el-translit"},
override_translit = true,
entry_name = {Grek = {remove_diacritics = c.caron .. c.diaerbelow .. c.brevebelow}},
sort_key = {Grek = s["Grek-sortkey"]},
standardChars = {
Grek = "΅·ͺ΄ΑαΆάΒβΓγΔδΕεέΈΖζΗηΉήΘθΙιΊίΪϊΐΚκΛλΜμΝνΞξΟοΌόΠπΡρΣσςΤτΥυΎύΫϋΰΦφΧχΨψΩωΏώ",
Brai = c.braille,
c.punc
},
}

m["en"] = {
"English",
1860,
"gmw",
"Latn, Brai, Shaw, Dsrt", -- entries in Shaw or Dsrt might require prior discussion
wikimedia_codes = "en, simple",
ancestors = "enm",
sort_key = {
Latn = {
remove_diacritics = c.grave .. c.acute .. c.circ .. c.tilde .. c.macron .. c.diaer .. c.ringabove .. c.caron .. c.cedilla .. "'%-%s",
from = {"æ", "œ"},
to = {"ae", "oe"}
},
},
standardChars = {
Latn = "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz",
Brai = c.braille,
c.punc
},
}

m["eo"] = {
"Esperanto",
143,
"art",
"Latn",
sort_key = {
remove_diacritics = c.grave .. c.acute,
from = {"ĉ", "ĝ", "ĥ", "ĵ", "ŝ", "ŭ"},
to = {"c" .. p[1], "g" .. p[1], "h" .. p[1], "j" .. p[1], "s" .. p[1], "u" .. p[1]}
},
standardChars = "AaBbCcĈĉDdEeFfGgĜĝHhIiJjĴĵKkLlMmNnOoPpRrSsŜŝTtUuŬŭVvZz" .. c.punc,
}

m["es"] = {
"Spanish",
1321,
"roa-ibe",
"Latn, Brai",
ancestors = "osp",
sort_key = {
Latn = {
remove_diacritics = c.acute .. c.diaer .. c.cedilla,
from = {"ñ"},
to = {"n" .. p[1]}
},
},
standardChars = {
Latn = "AaÁáBbCcDdEeÉéFfGgHhIiÍíJjLlMmNnÑñOoÓóPpQqRrSsTtUuÚúVvXxYyZz",
Brai = c.braille,
c.punc
},
}

m["et"] = {
"Estonian",
9072,
"urj-fin",
"Latn",
sort_key = {
from = {
"š", "ž", "õ", "ä", "ö", "ü", -- 2 chars
"z" -- 1 char
},
to = {
"s" .. p[1], "s" .. p[3], "w" .. p[1], "w" .. p[2], "w" .. p[3], "w" .. p[4],
"s" .. p[2]
}
},
standardChars = "AaBbDdEeFfGgHhIiJjKkLlMmNnOoPpRrSsTtUuVvÕõÄäÖöÜü" .. c.punc,
}

m["eu"] = {
"Basque",
8752,
"euq",
"Latn",
sort_key = {
from = {"ç", "ñ"},
to = {"c" .. p[1], "n" .. p[1]}
},
standardChars = "AaBbDdEeFfGgHhIiJjKkLlMmNnÑñOoPpRrSsTtUuXxZz" .. c.punc,
}

m["fa"] = {
"Persian",
9168,
"ira-swi",
"fa-Arab",
ancestors = "fa-cls",
entry_name = {
from = {""},
to = {""},
remove_diacritics = c.fathatan .. c.dammatan .. c.kasratan .. c.kashida .. c.fatha .. c.damma .. c.kasra .. c.shadda .. c.sukun .. c.superalef,
},
}

m["ff"] = {
"Fula",
33454,
"alv-fwo",
"Latn, Adlm",
}

m["fi"] = {
"Finnish",
1412,
"urj-fin",
"Latn",
display_text = {
from = {"'"},
to = {"’"}
},
entry_name = {
remove_diacritics = "ˣ",
from = {"’"},
to = {"'"},
}, -- used to indicate gemination of the next consonant
sort_key = {
remove_diacritics = c.grave .. c.acute .. c.circ .. c.tilde .. c.dacute .. c.caron .. c.cedilla .. "':",
from = {"ø", "æ", "œ", "ß"},
to = {"o", "ae", "oe", "ss"}
},
standardChars = "AaBbDdEeFfGgHhIiJjKkLlMmNnOoPpRrSsTtUuVvYyÄäÖö" .. c.punc,
}

m["fj"] = {
"Fijian",
33295,
"poz-occ",
"Latn",
}

m["fo"] = {
"Faroese",
25258,
"gmq",
"Latn",
ancestors = "non",
sort_key = {
from = {"á", "ð", "í", "ó", "ú", "ý", "æ", "ø"},
to = {"a" .. p[1], "d" .. p[1], "i" .. p[1], "o" .. p[1], "u" .. p[1], "y" .. p[1], "z" .. p[1], "z" .. p[2]}
},
standardChars = "AaÁáBbDdÐðEeFfGgHhIiÍíJjKkLlMmNnOoÓóPpRrSsTtUuÚúVvYyÝýÆæØø" .. c.punc,
}

m["fr"] = {
"French",
150,
"roa-oil",
"Latn, Brai",
ancestors = "frm",
sort_key = {Latn = s["roa-oil-sortkey"]},
standardChars = {
Latn = "AaÀàÂâBbCcÇçDdEeÉéÈèÊêËëFfGgHhIiÎîÏïJjLlMmNnOoÔôŒœPpQqRrSsTtUuÙùÛûÜüVvXxYyZz",
Brai = c.braille,
c.punc
},
}

m["fy"] = {
"West Frisian",
27175,
"gmw-fri",
"Latn",
ancestors = "ofs",
sort_key = {
remove_diacritics = c.grave .. c.acute .. c.circ .. c.diaer,
from = {"y"},
to = {"i"}
},
standardChars = "AaâäàÆæBbCcDdEeéêëèFfGgHhIiïìYyỳJjKkLlMmNnOoôöòPpRrSsTtUuúûüùVvWwZz" .. c.punc,
}

m["ga"] = {
"Irish",
9142,
"cel-gae",
"Latn, Latg",
ancestors = "mga",
sort_key = {
remove_diacritics = c.acute,
from = {"ḃ", "ċ", "ḋ", "ḟ", "ġ", "ṁ", "ṗ", "ṡ", "ṫ"},
to = {"bh", "ch", "dh", "fh", "gh", "mh", "ph", "sh", "th"}
},
standardChars = "AaÁáBbCcDdEeÉéFfGgHhIiÍíLlMmNnOoÓóPpRrSsTtUuÚúVv" .. c.punc,
}

m["gd"] = {
"Scottish Gaelic",
9314,
"cel-gae",
"Latn, Latg",
ancestors = "mga",
sort_key = {remove_diacritics = c.grave .. c.acute},
standardChars = "AaÀàBbCcDdEeÈèFfGgHhIiÌìLlMmNnOoÒòPpRrSsTtUuÙù" .. c.punc,
}

m["gl"] = {
"Galician",
9307,
"roa-ibe",
"Latn",
ancestors = "roa-opt",
sort_key = {
remove_diacritics = c.acute,
from = {"ñ"},
to = {"n" .. p[1]}
},
standardChars = "AaÁáBbCcDdEeÉéFfGgHhIiÍíLlMmNnÑñOoÓóPpQqRrSsTtUuÚúVvXxZz" .. c.punc,
}

m["gn"] = {
"Guaraní",
35876,
"tup-gua",
"Latn",
}

m["gu"] = {
"Gujarati",
5137,
"inc-wes",
"Arab, Gujr",
ancestors = "inc-mgu",
translit = {
Gujr = "gu-translit",
},
entry_name = {
remove_diacritics = "઼",
},
}

m["gv"] = {
"Manx",
12175,
"cel-gae",
"Latn",
ancestors = "mga",
sort_key = {remove_diacritics = c.cedilla .. "-"},
standardChars = "AaBbCcÇçDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwYy" .. c.punc,
}

m["ha"] = {
"Hausa",
56475,
"cdc-wst",
"Latn, Arab",
entry_name = {Latn = {remove_diacritics = c.grave .. c.acute .. c.circ .. c.tilde .. c.macron}},
sort_key = {
Latn = {
from = {"ɓ", "b'", "ɗ", "d'", "ƙ", "k'", "sh", "ƴ", "'y"},
to = {"b" .. p[1], "b" .. p[2], "d" .. p[1], "d" .. p[2], "k" .. p[1], "k" .. p[2], "s" .. p[1], "y" .. p[1], "y" .. p[2]}
},
},
}

m["he"] = {
"Hebrew",
9288,
"sem-can",
"Hebr, Phnx, Brai",
ancestors = "he-med",
entry_name = {Hebr = {remove_diacritics = u(0x0591) .. "-" .. u(0x05BD) .. u(0x05BF) .. "-" .. u(0x05C5) .. u(0x05C7) .. c.CGJ}},
}

m["hi"] = {
"Hindi",
1568,
"inc-hnd",
"Deva, Kthi, Newa",
ancestors = "inc-ohi",
translit = {Deva = "hi-translit"},
standardChars = "ँंअ-ऊएऐओ-घच-झट-नप-रलवशसहा-ूेैो-्।-॰ड़ढ़" .. c.punc,
}

m["ho"] = {
"Hiri Motu",
33617,
"crp",
"Latn",
ancestors = "meu",
}

m["ht"] = {
"Haitian Creole",
33491,
"crp",
"Latn",
ancestors = "ht-sdm",
sort_key = {
from = {
"oun", -- 3 chars
"an", "ch", "è", "en", "ng", "ò", "on", "ou", "ui" -- 2 chars
},
to = {
"o" .. p[4],
"a" .. p[1], "c" .. p[1], "e" .. p[1], "e" .. p[2], "n" .. p[1], "o" .. p[1], "o" .. p[2], "o" .. p[3], "u" .. p[1]
}
},
}

m["hu"] = {
"Hungarian",
9067,
"urj-ugr",
"Latn, Hung",
ancestors = "ohu",
sort_key = {
Latn = {
from = {
"dzs", -- 3 chars
"á", "cs", "dz", "é", "gy", "í", "ly", "ny", "ó", "ö", "ő", "sz", "ty", "ú", "ü", "ű", "zs", -- 2 chars
},
to = {
"d" .. p[2],
"a" .. p[1], "c" .. p[1], "d" .. p[1], "e" .. p[1], "g" .. p[1], "i" .. p[1], "l" .. p[1], "n" .. p[1], "o" .. p[1], "o" .. p[2], "o" .. p[3], "s" .. p[1], "t" .. p[1], "u" .. p[1], "u" .. p[2], "u" .. p[3], "z" .. p[1],
}
},
},
standardChars = {
Latn = "AaÁáBbCcDdEeÉéFfGgHhIiÍíJjKkLlMmNnOoÓóÖöŐőPpQqRrSsTtUuÚúÜüŰűVvWwXxYyZz",
c.punc
},
}

m["hy"] = {
"Armenian",
8785,
"hyx",
"Armn, Brai",
ancestors = "axm",
translit = {Armn = "Armn-translit"},
override_translit = true,
entry_name = {
Armn = {
remove_diacritics = "՛՜՞՟",
from = {"եւ", "", "", ""},
to = {"և", "յ", "ի", "է"}
},
},
sort_key = {
Armn = {
from = {
"ու", "եւ", -- 2 chars
"և" -- 1 char
},
to = {
"ւ", "եվ",
"եվ"
}
},
},
}

m["hz"] = {
"Herero",
33315,
"bnt-swb",
"Latn",
}

m["ia"] = {
"Interlingua",
35934,
"art",
"Latn",
}

m["id"] = {
"Indonesian",
9240,
"poz-mly",
"Latn",
ancestors = "ms",
standardChars = "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz" .. c.punc,
}

m["ie"] = {
"Interlingue",
35850,
"art",
"Latn",
type = "appendix-constructed",
entry_name = {remove_diacritics = c.grave .. c.acute .. c.circ},
}

m["ig"] = {
"Igbo",
33578,
"alv-igb",
"Latn",
entry_name = {remove_diacritics = c.grave .. c.acute .. c.macron},
sort_key = {
from = {"gb", "gh", "gw", "ị", "kp", "kw", "ṅ", "nw", "ny", "ọ", "sh", "ụ"},
to = {"g" .. p[1], "g" .. p[2], "g" .. p[3], "i" .. p[1], "k" .. p[1], "k" .. p[2], "n" .. p[1], "n" .. p[2], "n" .. p[3], "o" .. p[1], "s" .. p[1], "u" .. p[1]}
},
}

m["ii"] = {
"Sichuan Yi",
34235,
"tbq-lol",
"Yiii",
translit = "ii-translit",
}

m["ik"] = {
"Inupiaq",
27183,
"esx-inu",
"Latn",
sort_key = {
from = {
"ch", "ġ", "dj", "ḷ", "ł̣", "ñ", "ng", "r̂", "sr", "zr", -- 2 chars
"ł", "ŋ", "ʼ" -- 1 char
},
to = {
"c" .. p[1], "g" .. p[1], "h" .. p[1], "l" .. p[1], "l" .. p[3], "n" .. p[1], "n" .. p[2], "r" .. p[1], "s" .. p[1], "z" .. p[1],
"l" .. p[2], "n" .. p[2], "z" .. p[2]
}
},
}

m["io"] = {
"Ido",
35224,
"art",
"Latn",
}

m["is"] = {
"Icelandic",
294,
"gmq",
"Latn",
ancestors = "non",
sort_key = {
from = {"á", "ð", "é", "í", "ó", "ú", "ý", "þ", "æ", "ö"},
to = {"a" .. p[1], "d" .. p[1], "e" .. p[1], "i" .. p[1], "o" .. p[1], "u" .. p[1], "y" .. p[1], "z" .. p[1], "z" .. p[2], "z" .. p[3]}
},
standardChars = "AaÁáBbDdÐðEeÉéFfGgHhIiÍíJjKkLlMmNnOoÓóPpRrSsTtUuÚúVvXxYyÝýÞþÆæÖö" .. c.punc,
}

m["it"] = {
"Italian",
652,
"roa-itd",
"Latn",
ancestors = "it-oit",
sort_key = {remove_diacritics = c.grave .. c.acute .. c.circ .. c.diaer .. c.ringabove},
standardChars = "AaÀàBbCcDdEeÈèÉéFfGgHhIiÌìLlMmNnOoÒòPpQqRrSsTtUuÙùVvZz" .. c.punc,
}

m["iu"] = {
"Inuktitut",
29921,
"esx-inu",
"Cans, Latn",
translit = {Cans = "cr-translit"},
override_translit = true,
}

m["ja"] = {
"Japanese",
5287,
"jpx",
"Jpan, Brai",
ancestors = "ja-ear",
sort_key = {Jpan = "Jpan-sortkey"},
}

m["jv"] = {
"Javanese",
33549,
"poz-sus",
"Latn, Java",
ancestors = "kaw",
translit = {Java = "jv-translit"},
link_tr = true,
sort_key = {
Latn = {
from = {"dh", "é", "è", "ng", "ny", "th"},
to = {"d" .. p[1], "e" .. p[1], "e" .. p[2], "n" .. p[1], "n" .. p[2], "t" .. p[1]}
},
},
}

m["ka"] = {
"Georgian",
8108,
"ccs-gzn",
"Geor, Geok, Hebr", -- Hebr is used to write Judeo-Georgian
ancestors = "ka-mid",
translit = {
Geor = "Geor-translit",
Geok = "Geok-translit",
},
override_translit = true,
entry_name = {remove_diacritics = c.circ},
}

m["kg"] = {
"Kongo",
33702,
"bnt-kng",
"Latn",
}

m["ki"] = {
"Kikuyu",
33587,
"bnt-kka",
"Latn",
}

m["kj"] = {
"Kwanyama",
1405077,
"bnt-ova",
"Latn",
}

m["kk"] = {
"Kazakh",
9252,
"trk-kno",
"Cyrl, Latn, kk-Arab",
translit = {
Cyrl = {
from = {
"Ё", "ё", "Й", "й", "Нг", "нг", "Ӯ", "ӯ", -- 2 chars; are "Ӯ" and "ӯ" actually used?
"А", "а", "Ә", "ә", "Б", "б", "В", "в", "Г", "г", "Ғ", "ғ", "Д", "д", "Е", "е", "Ж", "ж", "З", "з", "И", "и", "К", "к", "Қ", "қ", "Л", "л", "М", "м", "Н", "н", "Ң", "ң", "О", "о", "Ө", "ө", "П", "п", "Р", "р", "С", "с", "Т", "т", "У", "у", "Ұ", "ұ", "Ү", "ү", "Ф", "ф", "Х", "х", "Һ", "һ", "Ц", "ц", "Ч", "ч", "Ш", "ш", "Щ", "щ", "Ъ", "ъ", "Ы", "ы", "І", "і", "Ь", "ь", "Э", "э", "Ю", "ю", "Я", "я", -- 1 char
},
to = {
"E", "e", "İ", "i", "Ñ", "ñ", "U", "u",
"A", "a", "Ä", "ä", "B", "b", "V", "v", "G", "g", "Ğ", "ğ", "D", "d", "E", "e", "J", "j", "Z", "z", "İ", "i", "K", "k", "Q", "q", "L", "l", "M", "m", "N", "n", "Ñ", "ñ", "O", "o", "Ö", "ö", "P", "p", "R", "r", "S", "s", "T", "t", "U", "u", "Ū", "ū", "Ü", "ü", "F", "f", "X", "x", "H", "h", "S", "s", "Ç", "ç", "Ş", "ş", "Şş", "şş", "", "", "Y", "y", "I", "ı", "", "", "É", "é", "Ü", "ü", "Ä", "ä",
}
}
},
override_translit = true,
sort_key = {
Cyrl = {
from = {"ә", "ғ", "ё", "қ", "ң", "ө", "ұ", "ү", "һ", "і"},
to = {"а" .. p[1], "г" .. p[1], "е" .. p[1], "к" .. p[1], "н" .. p[1], "о" .. p[1], "у" .. p[1], "у" .. p[2], "х" .. p[1], "ы" .. p[1]}
},
},
}

m["kl"] = {
"Greenlandic",
25355,
"esx-inu",
"Latn",
sort_key = {
from = {"æ", "ø", "å"},
to = {"z" .. p[1], "z" .. p[2], "z" .. p[3]}
}
}

m["km"] = {
"Khmer",
9205,
"mkh-kmr",
"Khmr",
ancestors = "xhm",
translit = "km-translit",
}

m["kn"] = {
"Kannada",
33673,
"dra",
"Knda",
ancestors = "dra-mkn",
translit = "kn-translit",
}

m["ko"] = {
"Korean",
9176,
"qfa-kor",
"Kore, Brai",
ancestors = "ko-ear",
translit = {Kore = "ko-translit"},
entry_name = {Kore = s["Kore-entryname"]},
}

m["kr"] = {
"Kanuri",
36094,
"ssa-sah",
"Latn, Arab",
entry_name = {Latn = {remove_diacritics = c.grave .. c.acute .. c.circ .. c.breve}}, -- the sortkey and entry_name are only for standard Kanuri; when dialectal entries get added, someone will have to work out how the dialects should be represented orthographically
sort_key = {
Latn = {
from = {"ǝ", "ny", "ɍ", "sh"},
to = {"e" .. p[1], "n" .. p[1], "r" .. p[1], "s" .. p[1]}
},
},
}

m["ks"] = {
"Kashmiri",
33552,
"inc-dar",
"ks-Arab, Deva, Shrd, Latn",
translit = {
["ks-Arab"] = "ks-Arab-translit",
Deva = "ks-Deva-translit",
Shrd = "Shrd-translit",
},
}

-- "kv" IS TREATED AS "koi", "kpv", SEE WT:LT

m["kw"] = {
"Cornish",
25289,
"cel-bry",
"Latn",
ancestors = "cnx",
sort_key = {
from = {"ch"},
to = {"c" .. p[1]}
},
}

m["ky"] = {
"Kyrgyz",
9255,
"trk-kip",
"Cyrl, Latn, Arab",
translit = {Cyrl = "ky-translit"},
override_translit = true,
sort_key = {
Cyrl = {
from = {"ё", "ң", "ө", "ү"},
to = {"е" .. p[1], "н" .. p[1], "о" .. p[1], "у" .. p[1]}
},
},
}

m["la"] = {
"Latin",
397,
"itc",
"Latn, Ital",
ancestors = "itc-ola",
entry_name = {Latn = {remove_diacritics = c.macron .. c.breve .. c.diaer .. c.dinvbreve}},
sort_key = {
Latn = {
from = {"æ", "œ"},
to = {"ae", "oe"}
},
},
standardChars = {
Latn = "AaBbCcDdEeFfGgHhIiLlMmNnOoPpQqRrSsTtUuVvXxZz",
c.punc
},
}

m["lb"] = {
"Luxembourgish",
9051,
"gmw",
"Latn",
ancestors = "gmw-cfr",
sort_key = {
from = {"ä", "ë", "é"},
to = {"z" .. p[1], "z" .. p[2], "z" .. p[3]}
},
}

m["lg"] = {
"Luganda",
33368,
"bnt-nyg",
"Latn",
entry_name = {remove_diacritics = c.acute .. c.circ},
sort_key = {
from = {"ŋ"},
to = {"n" .. p[1]}
},
}

m["li"] = {
"Limburgish",
102172,
"gmw",
"Latn",
ancestors = "dum",
}

m["ln"] = {
"Lingala",
36217,
"bnt-bmo",
"Latn",
sort_key = {
remove_diacritics = c.acute .. c.circ .. c.caron,
from = {"ɛ", "gb", "mb", "mp", "nd", "ng", "nk", "ns", "nt", "ny", "nz", "ɔ"},
to = {"e" .. p[1], "g" .. p[1], "m" .. p[1], "m" .. p[2], "n" .. p[1], "n" .. p[2], "n" .. p[3], "n" .. p[4], "n" .. p[5], "n" .. p[6], "n" .. p[7], "o" .. p[1]}
},
}

m["lo"] = {
"Lao",
9211,
"tai-swe",
"Laoo",
translit = "lo-translit",
sort_key = "Laoo-sortkey",
standardChars = "0-9ກຂຄງຈຊຍດຕຖທນບປຜຝພຟມຢຣລວສຫອຮຯ-ໝ" .. c.punc,
}

m["lt"] = {
"Lithuanian",
9083,
"bat",
"Latn",
ancestors = "olt",
entry_name = {remove_diacritics = c.grave .. c.acute .. c.tilde},
sort_key = {
from = {"ą", "č", "ę", "ė", "į", "y", "š", "ų", "ū", "ž"},
to = {"a" .. p[1], "c" .. p[1], "e" .. p[1], "e" .. p[2], "i" .. p[1], "i" .. p[2], "s" .. p[1], "u" .. p[1], "u" .. p[2], "z" .. p[1]}
},
standardChars = "AaĄąBbCcČčDdEeĘęĖėFfGgHhIiĮįYyJjKkLlMmNnOoPpRrSsŠšTtUuŲųŪūVvZzŽž" .. c.punc,
}

m["lu"] = {
"Luba-Katanga",
36157,
"bnt-lub",
"Latn",
}

m["lv"] = {
"Latvian",
9078,
"bat",
"Latn",
entry_name = {
-- This attempts to convert vowels with tone marks to vowels either with or without macrons. Specifically, there should be no macrons if the vowel is part of a diphthong (including resonant diphthongs such pìrksts -> pirksts not #pīrksts). What we do is first convert the vowel + tone mark to a vowel + tilde in a decomposed fashion, then remove the tilde in diphthongs, then convert the remaining vowel + tilde sequences to macroned vowels, then delete any other tilde. We leave already-macroned vowels alone: Both e.g. ar and ār occur before consonants. FIXME: This still might not be sufficient.
from = {"([Ee])" .. c.cedilla, "[" .. c.grave .. c.circ .. c.tilde .."]", "([aAeEiIoOuU])" .. c.tilde .."?([lrnmuiLRNMUI])" .. c.tilde .. "?([^aAeEiIoOuU])", "([aAeEiIoOuU])" .. c.tilde .."?([lrnmuiLRNMUI])" .. c.tilde .."?$", "([iI])" .. c.tilde .. "?([eE])" .. c.tilde .. "?", "([aAeEiIuU])" .. c.tilde, c.tilde},
to = {"%1", c.tilde, "%1%2%3", "%1%2", "%1%2", "%1" .. c.macron}
},
sort_key = {
from = {"ā", "č", "ē", "ģ", "ī", "ķ", "ļ", "ņ", "š", "ū", "ž"},
to = {"a" .. p[1], "c" .. p[1], "e" .. p[1], "g" .. p[1], "i" .. p[1], "k" .. p[1], "l" .. p[1], "n" .. p[1], "s" .. p[1], "u" .. p[1], "z" .. p[1]}
},
standardChars = "AaĀāBbCcČčDdEeĒēFfGgĢģHhIiĪīJjKkĶķLlĻļMmNnŅņOoPpRrSsŠšTtUuŪūVvZzŽž" .. c.punc,
}

m["mg"] = {
"Malagasy",
7930,
"poz-bre",
"Latn",
}

m["mh"] = {
"Marshallese",
36280,
"poz-mic",
"Latn",
sort_key = {
from = {"ā", "ļ", "m̧", "ņ", "n̄", "o̧", "ō", "ū"},
to = {"a" .. p[1], "l" .. p[1], "m" .. p[1], "n" .. p[1], "n" .. p[2], "o" .. p[1], "o" .. p[2], "u" .. p[1]}
},
}

m["mi"] = {
"Maori",
36451,
"poz-pep",
"Latn",
sort_key = {
remove_diacritics = c.macron,
from = {"ng", "wh"},
to = {"z" .. p[1], "z" .. p[2]}
},
}

m["mk"] = {
"Macedonian",
9296,
"zls",
"Cyrl",
translit = "mk-translit",
entry_name = {
remove_diacritics = c.acute,
remove_exceptions = {"Ѓ", "ѓ", "Ќ", "ќ"}
},
sort_key = {
remove_diacritics = c.grave,
from = {"ѓ", "ѕ", "ј", "љ", "њ", "ќ", "џ"},
to = {"д" .. p[1], "з" .. p[1], "и" .. p[1], "л" .. p[1], "н" .. p[1], "т" .. p[1], "ч" .. p[1]}
},
standardChars = "АаБбВвГгДдЃѓЕеЖжЗзЅѕИиЈјКкЛлЉљМмНнЊњОоПпРрСсТтЌќУуФфХхЦцЧчЏџШш" .. c.punc,
}

m["ml"] = {
"Malayalam",
36236,
"dra",
"Mlym",
translit = "ml-translit",
override_translit = true,
}

m["mn"] = {
"Mongolian",
9246,
"xgn-cen",
"Cyrl, Mong, Latn, Brai",
ancestors = "cmg",
translit = {
Cyrl = "mn-translit",
Mong = "Mong-translit",
},
override_translit = true,
display_text = {Mong = s["Mong-displaytext"]},
entry_name = {
Cyrl = {remove_diacritics = c.grave .. c.acute},
Mong = s["Mong-entryname"],
},
sort_key = {
Cyrl = {
remove_diacritics = c.grave,
from = {"ё", "ө", "ү"},
to = {"е" .. p[1], "о" .. p[1], "у" .. p[1]}
},
},
standardChars = {
Cyrl = "АаБбВвГгДдЕеЁёЖжЗзИиЙйЛлМмНнОоӨөРрСсТтУуҮүХхЦцЧчШшЫыЬьЭэЮюЯя—",
Brai = c.braille,
c.punc
},
}

-- "mo" IS TREATED AS "ro", SEE WT:LT

m["mr"] = {
"Marathi",
1571,
"inc-sou",
"Deva, Modi",
ancestors = "omr",
translit = {
Deva = "mr-translit",
Modi = "mr-Modi-translit",
},
entry_name = {
Deva = {
from = {"च़", "ज़", "झ़"},
to = {"च", "ज", "झ"}
},
},
}

m["ms"] = {
"Malay",
9237,
"poz-mly",
"Latn, ms-Arab",
ancestors = "ms-cla",
standardChars = {
Latn = "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz",
c.punc
},
}

m["mt"] = {
"Maltese",
9166,
"sem-arb",
"Latn",
display_text = {
from = {"'"},
to = {"’"}
},
entry_name = {
from = {"’"},
to = {"'"},
},
ancestors = "sqr",
sort_key = {
from = {
"ċ", "ġ", "ż", -- Convert into PUA so that decomposed form does not get caught by the next step.
"([cgz])", -- Ensure "c" comes after "ċ", "g" comes after "ġ" and "z" comes after "ż".
"g" .. p[1] .. "ħ", -- "għ" after initial conversion of "g".
p[3], p[4], "ħ", "ie", p[5] -- Convert "ċ", "ġ", "ħ", "ie", "ż" into final output.
},
to = {
p[3], p[4], p[5],
"%1" .. p[1],
"g" .. p[2],
"c", "g", "h" .. p[1], "i" .. p[1], "z"
}
},
}

m["my"] = {
"Burmese",
9228,
"tbq-brm",
"Mymr",
ancestors = "obr",
translit = "my-translit",
override_translit = true,
sort_key = {
from = {"ျ", "ြ", "ွ", "ှ", "ဿ"},
to = {"္ယ", "္ရ", "္ဝ", "္ဟ", "သ္သ"}
},
}

m["na"] = {
"Nauruan",
13307,
"poz-mic",
"Latn",
}

m["nb"] = {
"Norwegian Bokmål",
25167,
"gmq",
"Latn",
wikimedia_codes = "no",
ancestors = "gmq-mno, da",
sort_key = s["no-sortkey"],
standardChars = s["no-standardchars"],
}

m["nd"] = {
"Northern Ndebele",
35613,
"bnt-ngu",
"Latn",
entry_name = {remove_diacritics = c.grave .. c.acute .. c.circ .. c.macron .. c.caron},
}

m["ne"] = {
"Nepali",
33823,
"inc-pah",
"Deva, Newa",
translit = {Deva = "ne-translit"},
}

m["ng"] = {
"Ndonga",
33900,
"bnt-ova",
"Latn",
}

m["nl"] = {
"Dutch",
7411,
"gmw",
"Latn, Brai",
ancestors = "dum",
sort_key = {remove_diacritics = c.grave .. c.acute .. c.circ .. c.tilde .. c.diaer .. c.ringabove .. c.cedilla .. "'"},
standardChars = {
Latn = "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz",
Brai = c.braille,
c.punc
},
}

m["nn"] = {
"Norwegian Nynorsk",
25164,
"gmq",
"Latn",
ancestors = "gmq-mno",
sort_key = s["no-sortkey"],
standardChars = s["no-standardchars"],
}

m["no"] = {
"Norwegian",
9043,
"gmq",
"Latn",
ancestors = "gmq-mno",
sort_key = s["no-sortkey"],
standardChars = s["no-standardchars"],
}

m["nr"] = {
"Southern Ndebele",
36785,
"bnt-ngu",
"Latn",
entry_name = {remove_diacritics = c.grave .. c.acute .. c.circ .. c.macron .. c.caron},
}

m["nv"] = {
"Navajo",
13310,
"apa",
"Latn",
sort_key = {
remove_diacritics = c.acute .. c.ogonek,
from = {
"chʼ", "tłʼ", "tsʼ", -- 3 chars
"ch", "dl", "dz", "gh", "hw", "kʼ", "kw", "sh", "tł", "ts", "zh", -- 2 chars
"ł", "ʼ" -- 1 char
},
to = {
"c" .. p[2], "t" .. p[2], "t" .. p[4],
"c" .. p[1], "d" .. p[1], "d" .. p[2], "g" .. p[1], "h" .. p[1], "k" .. p[1], "k" .. p[2], "s" .. p[1], "t" .. p[1], "t" .. p[3], "z" .. p[1],
"l" .. p[1], "z" .. p[2]
}
},
}

m["ny"] = {
"Chichewa",
33273,
"bnt-nys",
"Latn",
entry_name = {remove_diacritics = c.acute .. c.circ},
sort_key = {
from = {"ng'"},
to = {"ng"}
},
}

m["oc"] = {
"Occitan",
14185,
"roa-ocr",
"Latn, Hebr",
ancestors = "pro",
sort_key = {
Latn = {
remove_diacritics = c.grave .. c.acute .. c.diaer .. c.cedilla,
from = {"([lns])·h"},
to = {"%1h"}
},
},
}

m["oj"] = {
"Ojibwe",
33875,
"alg",
"Cans, Latn",
sort_key = {
Latn = {
from = {"aa", "ʼ", "ii", "oo", "sh", "zh"},
to = {"a" .. p[1], "h" .. p[1], "i" .. p[1], "o" .. p[1], "s" .. p[1], "z" .. p[1]}
},
},
}

m["om"] = {
"Oromo",
33864,
"cus-eas",
"Latn, Ethi",
}

m["or"] = {
"Oriya",
33810,
"inc-eas",
"Orya",
ancestors = "inc-mor",
translit = "or-translit",
}

m["os"] = {
"Ossetian",
33968,
"xsc",
"Cyrl, Geor, Latn",
ancestors = "oos",
translit = {
Cyrl = "os-translit",
Geor = "Geor-translit",
},
override_translit = true,
display_text = {
Cyrl = {
from = {"æ"},
to = {"ӕ"}
},
Latn = {
from = {"ӕ"},
to = {"æ"}
},
},
entry_name = {
Cyrl = {
remove_diacritics = c.grave .. c.acute,
from = {"æ"},
to = {"ӕ"}
},
Latn = {
from = {"ӕ"},
to = {"æ"}
},
},
sort_key = {
Cyrl = {
from = {"ӕ", "гъ", "дж", "дз", "ё", "къ", "пъ", "тъ", "хъ", "цъ", "чъ"},
to = {"а" .. p[1], "г" .. p[1], "д" .. p[1], "д" .. p[2], "е" .. p[1], "к" .. p[1], "п" .. p[1], "т" .. p[1], "х" .. p[1], "ц" .. p[1], "ч" .. p[1]}
},
},
}

m["pa"] = {
"Punjabi",
58635,
"inc-pan",
"Guru, pa-Arab",
ancestors = "inc-opa",
translit = {
Guru = "Guru-translit",
["pa-Arab"] = "pa-Arab-translit",
},
entry_name = {
["pa-Arab"] = {
remove_diacritics = c.fathatan .. c.dammatan .. c.kasratan .. c.fatha .. c.damma .. c.kasra .. c.shadda .. c.sukun .. c.nunghunna,
from = {"", ""},
to = {"", ""}
},
},
}

m["pi"] = {
"Pali",
36727,
"inc-mid",
"Latn, Brah, Deva, Beng, Sinh, Mymr, Thai, Lana, Laoo, Khmr, Cakm",
ancestors = "sa",
translit = {
Brah = "Brah-translit",
Deva = "sa-translit",
Beng = "pi-translit",
Sinh = "si-translit",
Mymr = "pi-translit",
Thai = "pi-translit",
Lana = "pi-translit",
Laoo = "pi-translit",
Khmr = "pi-translit",
Cakm = "Cakm-translit",
},
entry_name = {
Thai = {
from = {"ึ", u(0xF700), u(0xF70F)}, -- FIXME: Not clear what's going on with the PUA characters here.
to = {"ิํ", "ฐ", "ญ"}
},
remove_diacritics = c.VS01
},
sort_key = { -- FIXME: This needs to be converted into the current standardized format.
from = {"ā", "ī", "ū", "ḍ", "ḷ", "m[" .. c.dotabove .. c.dotbelow .. "]", "ṅ", "ñ", "ṇ", "ṭ", "([เโ])([ก-ฮ])", "([ເໂ])([ກ-ຮ])", "ᩔ", "ᩕ", "ᩖ", "ᩘ", "([ᨭ-ᨱ])ᩛ", "([ᨷ-ᨾ])ᩛ", "ᩤ", u(0xFE00), u(0x200D)},
to = {"a~", "i~", "u~", "d~", "l~", "m~", "n~", "n~~", "n~~~", "t~", "%2%1", "%2%1", "ᩈ᩠ᩈ", "᩠ᩁ", "᩠ᩃ", "ᨦ᩠", "%1᩠ᨮ", "%1᩠ᨻ", "ᩣ"}
},
}

m["pl"] = {
"Polish",
809,
"zlw-lch",
"Latn",
ancestors = "zlw-mpl",
sort_key = {
from = {"ą", "ć", "ę", "ł", "ń", "ó", "ś", "ź", "ż"},
to = {"a" .. p[1], "c" .. p[1], "e" .. p[1], "l" .. p[1], "n" .. p[1], "o" .. p[1], "s" .. p[1], "z" .. p[1], "z" .. p[2]}
},
standardChars = "AaĄąBbCcĆćDdEeĘęFfGgHhIiJjKkLlŁłMmNnŃńOoÓóPpRrSsŚśTtUuWwYyZzŹźŻż" .. c.punc,
}

m["ps"] = {
"Pashto",
58680,
"ira-pat",
"ps-Arab",
entry_name = {remove_diacritics = c.fathatan .. c.dammatan .. c.kasratan .. c.fatha .. c.damma .. c.kasra .. c.shadda .. c.sukun .. c.superalef},
}

m["pt"] = {
"Portuguese",
5146,
"roa-ibe",
"Latn, Brai",
ancestors = "roa-opt",
sort_key = {Latn = {remove_diacritics = c.grave .. c.acute .. c.circ .. c.tilde .. c.diaer .. c.cedilla}},
standardChars = {
Latn = "AaÁáÂâÃãBbCcÇçDdEeÉéÊêFfGgHhIiÍíJjLlMmNnOoÓóÔôÕõPpQqRrSsTtUuÚúVvXxZz",
Brai = c.braille,
c.punc
},
}

m["qu"] = {
"Quechua",
5218,
"qwe",
"Latn",
}

m["rm"] = {
"Romansch",
13199,
"roa-rhe",
"Latn",
}

m["ro"] = {
"Romanian",
7913,
"roa-eas",
"Latn, Cyrl",
sort_key = {
Latn = {
from = {"ă", "â", "î", "ș", "ț"},
to = {"a" .. p[1], "a" .. p[2], "i" .. p[1], "s" .. p[1], "t" .. p[1]}
},
Cyrl = {
from = {"ӂ"},
to = {"ж" .. p[1]}
},
},
standardChars = {
Latn = "AaĂăÂâBbCcDdEeFfGgHhIiÎîJjLlMmNnOoPpRrSsȘșTtȚțUuVvXxZz",
Cyrl = "АаБбВвГгДдЕеЖжӁӂЗзИиЙйКкЛлМмНнОоПпРрСсТтУуФфХхЦцЧчШшЫыЬьЭэЮюЯя",
c.punc
},
}

m["ru"] = {
"Russian",
7737,
"zle",
"Cyrl, Cyrs, Brai",
ancestors = "zle-mru",
translit = {
Cyrl = "ru-translit",
Cyrs = "ru-translit",
},
entry_name = {
Cyrl = s["ru-Cyrl-entryname"],
Cyrs = s["ru-Cyrl-entryname"],
},
sort_key = {
Cyrl = s["ru-Cyrl-sortkey"],
Cyrs = s["ru-Cyrl-sortkey"],
},
standardChars = {
Cyrl = "АаБбВвГгДдЕеЁёЖжЗзИиЙйКкЛлМмНнОоПпРрСсТтУуФфХхЦцЧчШшЩщЪъЫыЬьЭэЮюЯя—",
Brai = c.braille,
c.punc
},
}

m["rw"] = {
"Rwanda-Rundi",
3217514,
"bnt-glb",
"Latn",
entry_name = {remove_diacritics = c.acute .. c.circ .. c.macron .. c.caron},
}

m["sa"] = {
"Sanskrit",
11059,
"inc-old",
"Deva, Bali, as-Beng, Beng, Bhks, Brah, Gran, Gujr, Guru, Hani, Java, Kawi, Khar, Khmr, Knda, Lana, Laoo, Marc, Mlym, Modi, Mong, mnc-Mong, xwo-Mong, Mymr, Nand, Newa, Orya, Phag, Ranj, Saur, Shrd, Sidd, Sinh, Taml, Tang, Telu, Thai, Tibt, Tirh",
translit = {
Deva = "sa-translit",
["as-Beng"] = "sa-Beng-translit",
Beng = "sa-Beng-translit",
Brah = "Brah-translit",
Gujr = "sa-Gujr-translit",
Java = "sa-Java-translit",
Khmr = "pi-translit",
Knda = "sa-Knda-translit",
Lana = "pi-translit",
Laoo = "pi-translit",
Mlym = "sa-Mlym-translit",
Modi = "sa-Modi-translit",
Mong = "Mong-translit",
["mnc-Mong"] = "mnc-translit",
["xwo-Mong"] = "xal-translit",
Mymr = "pi-translit",
Orya = "sa-Orya-translit",
Sinh = "si-translit",
Thai = "pi-translit",
Tibt = "Tibt-translit",
},
display_text = {
Mong = s["Mong-displaytext"],
Tibt = s["Tibt-displaytext"],
},
entry_name = {
Mong = s["Mong-entryname"],
Tibt = s["Tibt-entryname"],
Thai = {
from = {"ึ", u(0xF700), u(0xF70F)}, -- FIXME: Not clear what's going on with the PUA characters here.
to = {"ิํ", "ฐ", "ญ"}
},
remove_diacritics = c.VS01
},
sort_key = {
Tibt = "Tibt-sortkey",
{ -- FIXME: This needs to be converted into the current standardized format.
from = {"ā", "ī", "ū", "ḍ", "ḷ", "ḹ", "m[" .. c.dotabove .. c.dotbelow .. "]", "ṅ", "ñ", "ṇ", "ṛ", "ṝ", "ś", "ṣ", "ṭ", "([เโไ])([ก-ฮ])", "([ເໂໄ])([ກ-ຮ])", "ᩔ", "ᩕ", "ᩖ", "ᩘ", "([ᨭ-ᨱ])ᩛ", "([ᨷ-ᨾ])ᩛ", "ᩤ", u(0xFE00), u(0x200D)},
to = {"a~", "i~", "u~", "d~", "l~", "l~~", "m~", "n~", "n~~", "n~~~", "r~", "r~~", "s~", "s~~", "t~", "%2%1", "%2%1", "ᩈ᩠ᩈ", "᩠ᩁ", "᩠ᩃ", "ᨦ᩠", "%1᩠ᨮ", "%1᩠ᨻ", "ᩣ"},
},
},
}

m["sc"] = {
"Sardinian",
33976,
"roa",
"Latn",
}

m["sd"] = {
"Sindhi",
33997,
"inc-snd",
"sd-Arab, Deva, Sind, Khoj",
translit = {Sind = "Sind-translit"},
entry_name = {
["sd-Arab"] = {
remove_diacritics = c.kashida .. c.fathatan .. c.dammatan .. c.kasratan .. c.fatha .. c.damma .. c.kasra .. c.shadda .. c.sukun .. c.superalef,
from = {""},
to = {""}
},
},
ancestors = "inc-vra",
}

m["se"] = {
"Northern Sami",
33947,
"smi",
"Latn",
display_text = {
from = {"'"},
to = {"ˈ"}
},
entry_name = {remove_diacritics = c.macron .. c.dotbelow .. "'ˈ"},
sort_key = {
from = {"á", "č", "đ", "ŋ", "š", "ŧ", "ž"},
to = {"a" .. p[1], "c" .. p[1], "d" .. p[1], "n" .. p[1], "s" .. p[1], "t" .. p[1], "z" .. p[1]}
},
standardChars = "AaÁáBbCcČčDdĐđEeFfGgHhIiJjKkLlMmNnŊŋOoPpRrSsŠšTtŦŧUuVvZzŽž" .. c.punc,
}

m["sg"] = {
"Sango",
33954,
"crp",
"Latn",
ancestors = "ngb",
}

m["sh"] = {
"Serbo-Croatian",
9301,
"zls",
"Latn, Cyrl, Glag",
wikimedia_codes = "sh, bs, hr, sr",
entry_name = {
Latn = {
remove_diacritics = c.grave .. c.acute .. c.tilde .. c.macron .. c.dgrave .. c.invbreve,
remove_exceptions = {"Ć", "ć", "Ś", "ś", "Ź", "ź"}
},
Cyrl = {
remove_diacritics = c.grave .. c.acute .. c.tilde .. c.macron .. c.dgrave .. c.invbreve,
remove_exceptions = {"З́", "з́", "С́", "с́"}
},
},
sort_key = {
Latn = {
from = {"č", "ć", "dž", "đ", "lj", "nj", "š", "ś", "ž", "ź"},
to = {"c" .. p[1], "c" .. p[2], "d" .. p[1], "d" .. p[2], "l" .. p[1], "n" .. p[1], "s" .. p[1], "s" .. p[2], "z" .. p[1], "z" .. p[2]}
},
Cyrl = {
from = {"ђ", "з́", "ј", "љ", "њ", "с́", "ћ", "џ"},
to = {"д" .. p[1], "з" .. p[1], "и" .. p[1], "л" .. p[1], "н" .. p[1], "с" .. p[1], "т" .. p[1], "ч" .. p[1]}
},
},
standardChars = {
Latn = "AaBbCcČčĆćDdĐđEeFfGgHhIiJjKkLlMmNnOoPpRrSsŠšTtUuVvZzŽž",
Cyrl = "АаБбВвГгДдЂђЕеЖжЗзИиЈјКкЛлЉљМмНнЊњОоПпРрСсТтЋћУуФфХхЦцЧчЏџШш",
c.punc
},
}

m["si"] = {
"Sinhalese",
13267,
"inc-ins",
"Sinh",
ancestors = "elu-prk",
translit = "si-translit",
override_translit = true,
}

m["sk"] = {
"Slovak",
9058,
"zlw",
"Latn",
sort_key = {remove_diacritics = c.acute .. c.circ .. c.diaer},
standardChars = "AaÁáÄäBbCcČčDdĎďEeFfGgHhIiÍíJjKkLlĹĺĽľMmNnŇňOoÔôPpRrŔŕSsŠšTtŤťUuÚúVvYyÝýZzŽž" .. c.punc,
}

m["sl"] = {
"Slovene",
9063,
"zls",
"Latn",
entry_name = {
remove_diacritics = c.grave .. c.acute .. c.circ .. c.macron .. c.dgrave .. c.invbreve .. c.dotbelow,
from = {"Ə", "ə", "Ł", "ł"},
to = {"E", "e", "L", "l"}
},
sort_key = {
remove_diacritics = c.tilde .. c.dotabove .. c.diaer .. c.ringabove .. c.ringbelow .. c.ogonek,
from = {"č", "š", "ž"},
to = {"c" .. p[1], "s" .. p[1], "z" .. p[1]}
},
standardChars = "AaBbCcČčDdEeFfGgHhIiJjKkLlMmNnOoPpRrSsŠšTtUuVvZzŽž" .. c.punc,
}

m["sm"] = {
"Samoan",
34011,
"poz-pnp",
"Latn",
}

m["sn"] = {
"Shona",
34004,
"bnt-sho",
"Latn",
entry_name = {remove_diacritics = c.acute},
}

m["so"] = {
"Somali",
13275,
"cus-som",
"Latn, Arab, Osma",
entry_name = {Latn = {remove_diacritics = c.grave .. c.acute .. c.circ}},
}

m["sq"] = {
"Albanian",
8748,
"sqj",
"Latn, Grek, Elba",
entry_name = {remove_diacritics = c.acute},
sort_key = {
remove_diacritics = c.circ .. c.tilde,
from = {'ç', 'dh', 'ë', 'gj', 'll', 'nj', 'rr', 'sh', 'th', 'xh', 'zh'},
to = {'c'..p[1], 'd'..p[1], 'e'..p[1], 'g'..p[1], 'l'..p[1], 'n'..p[1], 'r'..p[1], 's'..p[1], 't'..p[1], 'x'..p[1], 'z'..p[1]},
},
standardChars = "AaBbCcÇçDdEeËëFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvXxYyZz" .. c.punc,
}

m["ss"] = {
"Swazi",
34014,
"bnt-ngu",
"Latn",
entry_name = {remove_diacritics = c.grave .. c.acute .. c.circ .. c.macron .. c.caron},
}

m["st"] = {
"Sotho",
34340,
"bnt-sts",
"Latn",
entry_name = {remove_diacritics = c.grave .. c.acute .. c.circ .. c.macron .. c.caron},
}

m["su"] = {
"Sundanese",
34002,
"poz-msa",
"Latn, Sund",
ancestors = "osn",
translit = {Sund = "su-translit"},
}

m["sv"] = {
"Swedish",
9027,
"gmq",
"Latn",
ancestors = "gmq-osw",
standardChars = "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZzÅåÄäÖö" .. c.punc,
}

m["sw"] = {
"Swahili",
7838,
"bnt-swh",
"Latn, Arab",
sort_key = {
Latn = {
from = {"ng'"},
to = {"ng" .. p[1]}
},
},
}

m["ta"] = {
"Tamil",
5885,
"dra",
"Taml",
ancestors = "oty",
translit = "ta-translit",
override_translit = true,
}

m["te"] = {
"Telugu",
8097,
"dra",
"Telu",
ancestors = "dra-ote",
translit = "te-translit",
override_translit = true,
}

m["tg"] = {
"Tajik",
9260,
"ira-swi",
"Cyrl, fa-Arab, Latn",
ancestors = "fa-cls",
translit = {Cyrl = "tg-translit"},
override_translit = true,
entry_name = {remove_diacritics = c.grave .. c.acute},
sort_key = {
Cyrl = {
from = {"ғ", "ё", "ӣ", "қ", "ӯ", "ҳ", "ҷ"},
to = {"г" .. p[1], "е" .. p[1], "и" .. p[1], "к" .. p[1], "у" .. p[1], "х" .. p[1], "ч" .. p[1]}
},
},
}

m["th"] = {
"Thai",
9217,
"tai-swe",
"Thai, Brai",
translit = {Thai = "th-translit"},
sort_key = {Thai = "Thai-sortkey"},
}

m["ti"] = {
"Tigrinya",
34124,
"sem-eth",
"Ethi",
translit = "Ethi-translit",
}

m["tk"] = {
"Turkmen",
9267,
"trk-ogz",
"Latn, Cyrl, Arab",
entry_name = {remove_diacritics = c.macron},
sort_key = {
Latn = {
from = {"ç", "ä", "ž", "ň", "ö", "ş", "ü", "ý"},
to = {"c" .. p[1], "e" .. p[1], "j" .. p[1], "n" .. p[1], "o" .. p[1], "s" .. p[1], "u" .. p[1], "y" .. p[1]}
},
Cyrl = {
from = {"ё", "җ", "ң", "ө", "ү", "ә"},
to = {"е" .. p[1], "ж" .. p[1], "н" .. p[1], "о" .. p[1], "у" .. p[1], "э" .. p[1]}
},
},
}

m["tl"] = {
"Tagalog",
34057,
"phi",
"Latn, Tglg",
translit = {Tglg = "tl-translit"},
override_translit = true,
entry_name = {Latn = {remove_diacritics = c.grave .. c.acute .. c.circ}},
standardChars = {
Latn = "AaBbKkDdEeGgHhIiLlMmNnOoPpRrSsTtUuWwYy",
c.punc
},
sort_key = {
Latn = "tl-sortkey",
},
}

m["tn"] = {
"Tswana",
34137,
"bnt-sts",
"Latn",
}

m["to"] = {
"Tongan",
34094,
"poz-pol",
"Latn",
entry_name = {remove_diacritics = c.acute},
sort_key = {remove_diacritics = c.macron},
}

m["tr"] = {
"Turkish",
256,
"trk-ogz",
"Latn",
ancestors = "ota",
dotted_dotless_i = true,
sort_key = {
from = {
"i", -- Ensure "i" comes after "ı".
"ç", "ğ", "ı", "ö", "ş", "ü"
},
to = {
"i" .. p[1],
"c" .. p[1], "g" .. p[1], "i", "o" .. p[1], "s" .. p[1], "u" .. p[1]
}
},
}

m["ts"] = {
"Tsonga",
34327,
"bnt-tsr",
"Latn",
}

m["tt"] = {
"Tatar",
25285,
"trk-kbu",
"Cyrl, Latn, tt-Arab",
translit = {Cyrl = "tt-translit"},
override_translit = true,
dotted_dotless_i = true,
sort_key = {
Cyrl = {
from = {"ә", "ў", "ғ", "ё", "җ", "қ", "ң", "ө", "ү", "һ"},
to = {"а" .. p[1], "в" .. p[1], "г" .. p[1], "е" .. p[1], "ж" .. p[1], "к" .. p[1], "н" .. p[1], "о" .. p[1], "у" .. p[1], "х" .. p[1]}
},
Latn = {
from = {
"i", -- Ensure "i" comes after "ı".
"ä", "ə", "ç", "ğ", "ı", "ñ", "ŋ", "ö", "ɵ", "ş", "ü"
},
to = {
"i" .. p[1],
"a" .. p[1], "a" .. p[2], "c" .. p[1], "g" .. p[1], "i", "n" .. p[1], "n" .. p[2], "o" .. p[1], "o" .. p[2], "s" .. p[1], "u" .. p[1]
}
},
},
}

-- "tw" IS TREATED AS "ak", SEE WT:LT

m["ty"] = {
"Tahitian",
34128,
"poz-pep",
"Latn",
}

m["ug"] = {
"Uyghur",
13263,
"trk-kar",
"ug-Arab, Latn, Cyrl",
ancestors = "chg",
translit = {
["ug-Arab"] = "ug-translit",
Cyrl = "ug-translit",
},
override_translit = true,
}

m["uk"] = {
"Ukrainian",
8798,
"zle",
"Cyrl",
ancestors = "zle-ouk",
translit = "uk-translit",
entry_name = {remove_diacritics = c.grave .. c.acute},
sort_key = {
from = {
"ї", -- 2 chars
"ґ", "є", "і" -- 1 char
},
to = {
"и" .. p[2],
"г" .. p[1], "е" .. p[1], "и" .. p[1]
}
},
standardChars = "АаБбВвГгДдЕеЄєЖжЗзИиІіЇїЙйКкЛлМмНнОоПпРрСсТтУуФфХхЦцЧчШшЩщЬьЮюЯя" .. c.punc,
}

m["ur"] = {
"Urdu",
1617,
"inc-hnd",
"ur-Arab",
ancestors = "inc-ohi",
entry_name = {
from = {""},
to = {""},
remove_diacritics = c.kashida .. c.fathatan .. c.dammatan .. c.kasratan .. c.fatha .. c.damma .. c.kasra .. c.shadda .. c.sukun .. c.nunghunna .. c.superalef
},
-- put Judeo-Urdu (Hebrew-script Urdu) under the category header
-- U+FB21 HEBREW LETTER WIDE ALEF so that it sorts after Arabic script titles
sort_key = {
from = {"^%f[" .. u(0x5D0) .. "-" .. u(0x5EA) .. "]"},
to = {u(0xFB21)},
},
}

m["uz"] = {
"Uzbek",
9264,
"trk-kar",
"Latn, Cyrl, fa-Arab",
ancestors = "chg",
translit = {Cyrl = "uz-translit"},
sort_key = {
Latn = {
from = {"oʻ", "gʻ", "sh", "ch", "ng"},
to = {"z" .. p[1], "z" .. p[2], "z" .. p[3], "z" .. p[4], "z" .. p[5]}
},
Cyrl = {
from = {"ё", "ў", "қ", "ғ", "ҳ"},
to = {"е" .. p[1], "я" .. p[1], "я" .. p[2], "я" .. p[3], "я" .. p[4]}
},
},
}

m["ve"] = {
"Venda",
32704,
"bnt-bso",
"Latn",
}

m["vi"] = {
"Vietnamese",
9199,
"mkh-vie",
"Latn, Hani",
ancestors = "mkh-mvi",
sort_key = {
Latn = "vi-sortkey",
Hani = "Hani-sortkey",
},
}

m["vo"] = {
"Volapük",
36986,
"art",
"Latn",
}

m["wa"] = {
"Walloon",
34219,
"roa-oil",
"Latn",
ancestors = "fro",
sort_key = s["roa-oil-sortkey"],
}

m["wo"] = {
"Wolof",
34257,
"alv-fwo",
"Latn, Arab",
}

m["xh"] = {
"Xhosa",
13218,
"bnt-ngu",
"Latn",
entry_name = {remove_diacritics = c.grave .. c.acute .. c.circ .. c.macron .. c.caron},
}

m["yi"] = {
"Yiddish",
8641,
"gmw",
"Hebr",
ancestors = "gmh",
translit = "yi-translit",
sort_key = {
from = {"א[ַָ]", "בּ", "ו[ֹּ]", "יִ", "ײַ", "פֿ"},
to = {"א", "ב", "ו", "י", "יי", "פ"}
},
}

m["yo"] = {
"Yoruba",
34311,
"alv-yor",
"Latn, Arab",
entry_name = {Latn = {remove_diacritics = c.grave .. c.acute .. c.macron}},
sort_key = {
Latn = {
from = {"ẹ", "gb", "ọ", "ṣ"},
to = {"e" .. p[1], "g" .. p[1], "o" .. p[1], "s" .. p[1]}
},
},
}

m["za"] = {
"Zhuang",
13216,
"tai",
"Latn, Hani",
sort_key = {
Latn = "za-sortkey",
Hani = "Hani-sortkey",
},
}

m["zh"] = {
"Chinese",
7850,
"zhx",
"Hani, Hant, Hans, Latn, Bopo, Nshu, Brai",
ancestors = "ltc",
generate_forms = "zh-generateforms",
translit = {
Hani = "zh-translit",
Bopo = "zh-translit",
},
sort_key = {Hani = "Hani-sortkey"},
}

m["zu"] = {
"Zulu",
10179,
"bnt-ngu",
"Latn",
entry_name = {remove_diacritics = c.grave .. c.acute .. c.circ .. c.macron .. c.caron},
}

return require("Module:languages").addDefaultTypes(m, true)

Template:W

2026-04-10T07:29:50Z

Jsrs701: 1 revision imported

{{#switch:{{padleft:|1|{{{1|}}}}}|[|{=[[Category:Maintenance:Template W error]]{{color|red|'''Template W: parameter error'''}}|{{#switch:{{{link}}}|no|n|-={{#if:{{{2|}}}|{{{2}}}|{{{1}}}}}|[[{{{3|Wikipedia}}}:{{{1|}}}|{{<includeonly>safesubst:</includeonly>#if: {{{2|}}}|{{{2}}}|{{#if:{{NAMESPACE:{{{1|}}}}}|{{NAMESPACE:{{{1|}}}}}''''':'''''{{PAGENAME:{{{1|{{Projectname|w}}}}}}}|{{#ifeq:{{padleft:|1|{{{1|W}}}}}|{{lc:{{padleft:|1|{{PAGENAME:{{{1|W}}}}}}}}}|{{lcfirst:{{PAGENAME:{{{1|{{Projectname|w}}}}}}}}}|{{PAGENAME:{{{1|{{Projectname|w}}}}}}}}}}}}}]]}}}}<noinclude>
{{documentation}}
</noinclude>

Template:Tracking/headword/pagename spelling mismatch/munj

2026-04-10T07:29:50Z

Jsrs701: 1 revision imported

<noinclude>==Subpages==
{{Special:PrefixIndex/{{FULLPAGENAME}}/|stripprefix=1}}[[Category:Tracking templates]]</noinclude>

Module:Columns

2026-04-10T07:29:50Z

Jsrs701: 1 revision imported

local export = {}

local m_links = require("Module:links")
local m_languages = require("Module:languages")

local function format_list_items(items, lang)
local result = {}

for i, item in ipairs(items) do
if lang and not string.find(item, "<span") then
item = m_links.full_link({lang = lang, term = item})
end

result[i] = '\n* ' .. item
end

return table.concat(result)
end

local collapse_header =
[[<div class="list-switcher" data-toggle-category="{{{toggle_category}}}">]]
local column_header = [[<div class="{{{class}}} term-list ul-column-count" ]]
.. [[data-column-count="{{{column_count}}}" ]]
.. [[style="background-color: {{{background_color}}};">]]
local button = [[<div class="list-switcher-element" ]]
.. [[data-showtext=" show more ▼ " ]]
.. [[data-hidetext=" show less ▲ " style="display: none;"> </div>]]

function export.create_list(args)
-- Fields in args that are used:
-- args.column_count, args.content, args.alphabetize, args.background_color,
-- args.collapse, args.toggle_category, args.class, args.lang
-- Check for required fields?
if type(args) ~= "table" then
error("expected table, got " .. type(args))
end

args.class = args.class or "derivedterms"
args.column_count = args.column_count or 1
args.toggle_category = args.toggle_category or "derived terms"

local output = {}

if args.header then
if args.format_header then
args.header = '<div class="term-list-header">' .. args.header .. "</div>"
end
table.insert(output, args.header)
end
if args.collapse then
table.insert(output, (collapse_header:gsub('{{{(.-)}}}', args)))
end
table.insert(output, (column_header:gsub('{{{(.-)}}}', args)))

if args.alphabetize then
require("Module:collation").sort(args.content, args.lang)
end
table.insert(output, format_list_items(args.content, args.lang))

table.insert(output, '</div>')
if args.collapse then
table.insert(output, button .. '</div>')
end

return table.concat(output)
end

-- This function is for compatibility with earlier version of [[Module:columns]]
-- (now found in [[Module:columns/old]]).
function export.create_table(...)
-- Earlier arguments to create_table:
-- n_columns, content, alphabetize, bg, collapse, class, title, column_width, line_start, lang
local args = {}
args.column_count, args.content, args.alphabetize, args.background_color,
args.collapse, args.class, args.header, args.column_width,
args.line_start, args.lang = ...

args.format_header = true

return export.create_list(args)
end

function export.display(frame)
local iparams = {
["class"] = {},
-- Default for auto-collapse. Overridable by template |collapse= param.
["collapse"] = {type = "boolean"},
-- If specified, this specifies the number of columns, and no columns
-- parameter is available on the template. Otherwise, the columns
-- parameter is the first available numbered param after the language-code
-- parameter.
["columns"] = {type = "number"},
-- If specified, this specifies the language code, and no language-code
-- parameter is available on the template. Otherwise, the language-code
-- parameter can be specified as either |lang= or |1=.
["lang"] = {},
-- Default for auto-sort. Overridable by template |sort= param.
["sort"] = {type = "boolean"},
-- The following is accepted but currently ignored, per an extended discussion in
-- [[Wiktionary:Beer parlour/2018/November#Titles of morphological relations templates]].
["title"] = {default = ""},
["toggle_category"] = {},
}

local frame_args = require("Module:parameters").process(frame.args, iparams)
local parent_args = frame:getParent().args

local compat = frame_args["lang"] or parent_args["lang"]
local lang_param = compat and "lang" or 1
local columns_param = compat and 1 or 2
local first_content_param = columns_param + (frame_args["columns"] and 0 or 1)

local params = {
[lang_param] = not frame_args["lang"] and {required = true, default = "und"} or nil,
[columns_param] = not frame_args["columns"] and {required = true, default = 2} or nil,
[first_content_param] = {list = true},

["title"] = {},
["collapse"] = {type = "boolean"},
["sort"] = {type = "boolean"},
}

local args = require("Module:parameters").process(parent_args, params)

local lang = frame_args["lang"] or args[lang_param]
lang = m_languages.getByCode(lang) or m_languages.err(lang, lang_param)

local sort = frame_args["sort"]
if args["sort"] ~= nil then
sort = args["sort"]
end
local collapse = frame_args["collapse"]
if args["collapse"] ~= nil then
collapse = args["collapse"]
end

return export.create_list { column_count = frame_args["columns"] or args[columns_param],
content = args[first_content_param],
alphabetize = sort,
header = args["title"], background_color = "#F8F8FF",
collapse = collapse,
toggle_category = frame_args["toggle_category"],
class = frame_args["class"], lang = lang, format_header = true }
end

return export

Module:Collation

2026-04-10T07:29:50Z

Jsrs701: 1 revision imported

local export = {}

-- Custom functions for generating a sortkey that will achieve the desired sort
-- order.
-- name of module and name of exported function
local custom_sort_functions = {
egy = { "egy-utilities", "make_sortkey" },
}

local function is_lang_object(lang)
return type(lang) == "table" and type(lang.getCanonicalName) == "function"
end

local function check_lang_object(funcName, argIdx, lang)
if not is_lang_object(lang) then
error("bad argument #" .. argIdx .. " to " .. funcName
.. ": expected language object, got " .. type(lang) .. ".", 2)
end
end

-- UTF-8-encoded characters that do not belong to the Basic Multilingual Plane
-- (that is, with code points greater than U+FFFF) have byte sequences that
-- begin with the bytes 240 to 244.
local function contains_non_BMP(str)
return str:find '[\240-\244]'
end

do
local byte, min = string.byte, math.min
function export.laborious_comp(item1, item2)
local l1, l2 = #item1, #item2
for i = 1, min(l1, l2) do
local char1, char2 = byte(item1, i, i), byte(item2, i, i)
if char1 ~= char2 then
return char1 < char2
end
end
return l1 < l2
end
end

function export.make_sortkey_func(lang)
check_lang_object("make_sortkey_func", 1, lang)

local cache = {}

local custom_sort_function = custom_sort_functions[lang:getCode()]
local makeSortKey =
custom_sort_function and require("Module:" .. custom_sort_function[1])[custom_sort_function[2]]
or function(text)
return lang:makeSortKey(text)
end

local m_links = require("Module:links")

return function (element)
local result = cache[element]

if result then
return result
end

result = m_links.remove_links(element)
result = mw.ustring.gsub(result, "[%p ]", "")
result = makeSortKey(lang:makeEntryName(result))
cache[element] = result

return result
end
end

function export.make_compare_func(lang, non_BMP)
check_lang_object("make_compare_func", 1, lang)

local make_sortkey = export.make_sortkey_func(lang)

-- When comparing two elements with code points outside the BMP, the
-- less-than operator does not work correctly because of a bug in glibc.
-- See [[phab:T193096]].
if non_BMP then
return function (elem1, elem2)
return export.laborious_comp(make_sortkey(elem1), make_sortkey(elem2))
end
else
return function (elem1, elem2)
return make_sortkey(elem1) < make_sortkey(elem2)
end
end
end

function export.sort(elems, lang)
local non_BMP
for _, elem in ipairs(elems) do
if contains_non_BMP(elem) then
non_BMP = true
break
end
end

return table.sort(elems, is_lang_object(lang) and export.make_compare_func(lang, non_BMP) or nil)
end

function export.sort_template(frame)
if not mw.isSubsting() then
error("This template must be substed.")
end

local args
if frame.args.parent then
args = frame:getParent().args
else
args = frame.args
end

local elems = require("Module:table").shallowClone(args)
local m_languages = require("Module:languages")
local lang
if args.lang then
lang = m_languages.getByCode(args.lang) or m_languages.err(args.lang, 'lang')
else
local code = table.remove(elems, 1)
code = code and mw.text.trim(code)
lang = m_languages.getByCode(code) or m_languages.err(code, 1)
end
export.sort(elems, lang)
return table.concat(elems, args.sep or "|")
end

return export