st34an test wiki - Recent changes [en]

Module:Category tree/poscatboiler/data/lang-specific/chak

Jsrs701 — Fri, 10 Apr 2026 07:25:58 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data/lang-specific/chak by file upload (1 revision)

New page

local labels = {}

labels["root modifiers"] = {
description = "{{{langname}}} suffixes that add additional meaning to roots.",
parents = {"suffixes"},
breadcrumb = "root modifiers",
}

labels["terms by root modifier"] = {
description = "{{{langname}}} terms categorized by the modifier added to the root.",
parents = {"terms by etymology", {name = "root modifiers", sort = " "}},
}

return {LABELS = labels}

Module:Table/listToSet

Jsrs701 — Fri, 10 Apr 2026 07:25:58 GMT

Jsrs701 imported Module:Table/listToSet by file upload (1 revision)

New page

--[[
{ "a", "b", "c" } -> { ["a"] = true, ["b"] = true, ["c"] = true }
--]]
return function(t)
-- checkType("listToSet", 1, t, "table")

local set = {}
for _, item in ipairs(t) do
set[item] = true
end
return set
end

Module:Category tree/poscatboiler/data/words by number of syllables

Jsrs701 — Fri, 10 Apr 2026 07:25:58 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data/words by number of syllables by file upload (1 revision)

New page

Module:Category tree/poscatboiler/data/word of the day

Jsrs701 — Fri, 10 Apr 2026 07:25:58 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data/word of the day by file upload (1 revision)

New page

Module:Category tree/poscatboiler/data/unicode

Jsrs701 — Fri, 10 Apr 2026 07:25:57 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data/unicode by file upload (1 revision)

New page

Module:Category tree/poscatboiler/data/transliterations

Jsrs701 — Fri, 10 Apr 2026 07:25:57 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data/transliterations by file upload (1 revision)

New page

local labels = {}
local raw_categories = {}
local handlers = {}
local raw_handlers = {}

-----------------------------------------------------------------------------
-- --
-- LABELS --
-- --
-----------------------------------------------------------------------------

labels["romanizations"] = {
description = "{{{langname}}} terms transliterated into the Latin alphabet.",
parents = {"non-lemma forms"},
umbrella_parents = "Transliterations subcategories by language",
-- Special romanization-specific table-of-contents bars are used on romanization pages
-- (e.g. [[Template:got-rom-categoryTOC]]) because they hold Latin-script terms in a
-- language-specific romanization scheme, rather than terms in the language's normal script.
-- For the same reason, we specify catfix = false to disable script-specific font
-- formatting.
toc_template = {"{{{langcode}}}-rom-categoryTOC", "en-categoryTOC"},
toc_template_full = {"{{{langcode}}}-rom-categoryTOC/full", "{{{langcode}}}-rom-categoryTOC", "en-categoryTOC/full"},
catfix = false,
}

labels["romanizations without a main entry"] = {
description = "{{{langname}}} romanizations where the corresponding entry in the language's normal script does not exist. Automatically added by <code>{{[[Template:romanization of|romanization of]]}}</code> when applicable.",
parents = {"entry maintenance", {name = "romanizations", sort = " "}},
umbrella_parents = "Entry maintenance subcategories by language",
--See 'romanizations' above.
toc_template = {"{{{langcode}}}-rom-categoryTOC", "en-categoryTOC"},
toc_template_full = {"{{{langcode}}}-rom-categoryTOC/full", "{{{langcode}}}-rom-categoryTOC", "en-categoryTOC/full"},
catfix = false,
can_be_empty = true,
hidden = true,
}

labels["terms transliterated from other languages"] = {
description = "{{{langname}}} terms that have been transliterated from other languages.",
parents = {{name = "borrowed terms", sort = " "}},
umbrella_parents = "Transliterations subcategories by language",
}

-----------------------------------------------------------------------------
-- --
-- RAW CATEGORIES --
-- --
-----------------------------------------------------------------------------

raw_categories["Transliterations subcategories by language"] = {
description = "Umbrella categories covering topics related to transliterations.",
additional = "{{{umbrella_meta_msg}}}",
parents = {
"Umbrella metacategories",
{name = "Terms by etymology subcategories by language", sort = " "},
},
}

raw_categories["Terms with manual transliterations different from the automated ones"] = {
intro = "{{also|:Category:Languages with automatic transliteration}}",
description = "Categories with terms with manual transliterations different from the automated ones, by language.",
hidden = true,
parents = "Category:Template tracking",
}

raw_categories["Terms with redundant transliterations"] = {
intro = "{{also|:Category:Languages with automatic transliteration}}",
description = "Categories with terms with redundant transliteration, by language.",
hidden = true,
parents = "Category:Template tracking",
}

-----------------------------------------------------------------------------
-- --
-- HANDLERS --
-- --
-----------------------------------------------------------------------------

table.insert(handlers, function(data)
local source_name = data.label:match("^transliterations of (.+) terms$")
if source_name then
local source = require("Module:languages").getByCanonicalName(source_name, true,
"allow etym langs")
local source_desc = source:makeCategoryLink()
return {
description = "{{{langname}}} terms that have been transliterated from " .. source_desc .. ".",
breadcrumb = source_name,
parents = {
{ name = "terms transliterated from other languages", sort = source_name },
{ name = "terms borrowed from " .. source_name, sort = " "},
},
umbrella = {
no_by_language = true,
parents = {
{ name = "terms borrowed from " .. source_name, is_label = true, sort = " " }
}
},
}
end
end)

-----------------------------------------------------------------------------
-- --
-- RAW HANDLERS --
-- --
-----------------------------------------------------------------------------

table.insert(raw_handlers, function(data)
local langcode = data.category:match("^Terms with manual transliterations different from the automated ones/(.+)$")
if langcode then
return {
description = "{{{langname}}} terms with manual transliterations different from the automated ones.",
lang = langcode,
breadcrumb = "{{{langname}}}",
parents = {
{ name = "Terms with manual transliterations different from the automated ones", sort = langcode },
{ name = "entry maintenance", is_label = true, lang = langcode },
},
-- Set catfix = false because the page will have a mixture of native-language and
-- non-native-language pages, but include the normal native-language table of contents headers
-- because most pages are in the native language.
catfix = false,
toc_template = "{{{langcode}}}-categoryTOC",
toc_template_full = "{{{langcode}}}-categoryTOC/full",
can_be_empty = true,
hidden = true,
}
end
end)

table.insert(raw_handlers, function(data)
local langcode = data.category:match("^Terms with redundant transliterations/(.+)$")
if langcode then
return {
description = "{{{langname}}} terms with redundant transliterations.",
lang = langcode,
breadcrumb = "{{{langname}}}",
parents = {
{ name = "Terms with redundant transliterations", sort = langcode },
{ name = "entry maintenance", is_label = true, lang = langcode },
},
-- Set catfix = false because the page will have a mixture of native-language and
-- non-native-language pages, but include the normal native-language table of contents headers
-- because most pages are in the native language.
catfix = false,
toc_template = "{{{langcode}}}-categoryTOC",
toc_template_full = "{{{langcode}}}-categoryTOC/full",
can_be_empty = true,
hidden = true,
}
end
end)

return {LABELS = labels, RAW_CATEGORIES = raw_categories, HANDLERS = handlers, RAW_HANDLERS = raw_handlers}

Module:Category tree/poscatboiler/data/terms by usage

Jsrs701 — Fri, 10 Apr 2026 07:25:57 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data/terms by usage by file upload (1 revision)

New page

local labels = {}
local raw_categories = {}

-----------------------------------------------------------------------------
-- --
-- LABELS --
-- --
-----------------------------------------------------------------------------

labels["terms by usage"] = {
description = "{{{langname}}} terms categorized by the manner and context in which they are used by speakers.",
umbrella_parents = "Fundamental",
parents = {{name = "{{{langcat}}}", raw = true}},
}

labels["2channel slang"] = {
description = "{{{langname}}} [[Wiktionary:slang|slang]] terms whose usage is typically restricted to users of the website {{w|2channel}}.",
parents = {"internet slang"},
}

labels["4chan slang"] = {
description = "{{{langname}}} [[Wiktionary:slang|slang]] terms whose usage is typically restricted to users of the website {{w|4chan}}.",
parents = {"internet slang"},
}

labels["advertising slang"] = {
description = "{{{langname}}} [[Wiktionary:slang|slang]] terms whose usage is typically restricted to advertisements.",
parents = {"slang"},
}

labels["angry register terms"] = {
description = "{{{langname}}} terms belonging to an angry linguistic register, used only when the speaker is angry.",
parents = {"terms by usage"},
}

labels["archaic forms"] = {
description = "{{{langname}}} forms that are used sometimes to imitate older literature for special effect, and serve as alternative forms of the same terms in recent general use.",
parents = {"archaic terms"},
}

labels["archaic terms"] = {
description = "{{{langname}}} terms that are no longer in general use but still encountered in older literature and still sometimes used for special effect.",
parents = {"terms by usage"},
}

labels["autological terms"] = {
description = "{{{langname}}} terms that possess the property they themselves describe.",
parents = {"terms by usage"},
}

labels["back slang"] = {
description = "{{{langname}}} terms in which the written word is spoken phonemically backwards to form a coded language.",
parents = {"cant"},
}

labels["buzzwords"] = {
description = "{{{langname}}} terms drawn from or imitative of technical jargon, and often rendered meaningless and fashionable through abuse by non-technical persons.",
parents = {"slang"},
}

labels["cant"] = {
description = "{{{langname}}} terms used to form secret languages that are typically restricted to members of a specific group.",
parents = {"slang"},
}

labels["censored spellings"] = {
description = "{{{langname}}} spellings where some characters have been changed in an effort to reduce the shock value of the original lemma.",
parents = {"terms by usage"},
}

labels["childish terms"] = {
description = "{{{langname}}} terms that are typically only used by, or to, children.",
parents = {"terms by usage", "informal terms"},
}

labels["colloquialisms"] = {
description = "{{{langname}}} terms that are likely to be used primarily in casual conversation rather than in more formal written works, speeches, and discourse.",
parents = {"terms by usage"},
}

labels["corporate jargon"] = {
description = "{{{langname}}} terms (typically for non-business-specific concepts) that are used especially in a [[Wiktionary:business|business]] or [[Wiktionary:corporate|corporate]] [[Wiktionary:context|context]].",
additional = "See also [[:Category:Businesses]], [[:Category:Business]] and language-specific categories thereof for terms related to business-specific concepts.",
parents = {"terms by usage"},
}

labels["criminal slang"] = {
description = "{{{langname}}} [[Wiktionary:slang|slang]] terms whose usage is typically restricted to criminals.",
parents = {"slang"},
}

labels["dated forms"] = {
description = "{{{langname}}} forms that are no longer fashionable, thus are anachronistic, and serve as alternative forms of the same terms in recent general use.",
parents = {"dated terms"},
}

labels["dated terms"] = {
description = "{{{langname}}} terms that are no longer fashionable, thus are [[Wiktionary:anachronistic|anachronistic]].",
parents = {"terms by usage"},
}

labels["derogatory terms"] = {
description = "{{{langname}}} terms that are intended to [[Wiktionary:disparage|disparage]], [[Wiktionary:demean|demean]], [[Wiktionary:insult|insult]] or [[Wiktionary:offend|offend]].",
parents = {"terms by usage"},
}

labels["dialectal terms"] = {
description = "{{{langname}}} terms that are not used in standard language but only in dialects.",
parents = {"terms by usage"},
}

labels["ecclesiastical terms"] = {
description = "{{{langname}}} terms used only by religious figures.",
parents = {"terms by usage"},
}

labels["eggcorns"] = {
description = "{{{langname}}} [[Wiktionary:eggcorn|eggcorn]]s, terms which are misconstructed.",
parents = {"misconstructions"},
}

labels["emoticons"] = {
description = "{{{langname}}} characters, or sequences of characters, that imitate expressions and other objects by means of [[Wiktionary:pareidolia|pareidolia]].",
parents = {"internet slang", "text messaging slang"},
}

labels["endearing terms"] = {
description = "{{{langname}}} terms that are used to show affection or endearment to another person. Entries using {{temp|lb|en|endearing}} will be added to this category.",
parents = {"terms by usage"},
}

labels["ethnic slurs"] = {
description = "{{{langname}}} terms that are intended to offend certain ethnic groups.",
parents = {"offensive terms"},
}

labels["eye dialect"] = {
description = "{{{langname}}} nonstandard spellings, which however do not change pronunciation, deliberately used by an author to indicate that the speaker uses a nonstandard or dialectal speech.",
parents = {"nonstandard forms", "terms by orthographic property"},
}

labels["familiar terms"] = {
description = "{{{langname}}} terms whose use is typically to contexts of friendly intimacy.",
parents = {"terms by usage"},
}

labels["fandom slang"] = {
description = "{{{langname}}} [[Wiktionary:slang|slang]] terms whose usage is typically restricted to fans of one or more works of fiction.",
parents = {"slang"},
}

labels["filter-avoidance spellings"] = {
description = "Intentional misspellings of {{{langname}}} terms that are used to avoid [[Wikipedia:Wordfilter|wordfilters]].",
parents = {"intentional misspellings"},
}

labels["folk poetic terms"] = {
description = "{{{langname}}} terms whose usage is typically restricted to works of oral or folk poetry.",
parents = {"terms by usage", "poetic terms"},
}

labels["formal terms"] = {
description = "{{{langname}}} terms whose use is typically restricted to polite, ceremonious, non-casual contexts.",
parents = {"terms by usage"},
}

labels["gay slang"] = {
description = "{{{langname}}} [[Wiktionary:slang|slang]] terms whose usage is typically restricted to homosexual people.",
parents = {"slang", "Category:{{{langcode}}}:LGBT"},
}

labels["gender-critical slang"] = {
description = "{{{langname}}} [[Wiktionary:slang|slang]] terms whose usage is typically restricted to gender-critical feminists.",
parents = {"slang", "Category:{{{langcode}}}:Gender-critical feminism"},
}

labels["gender-neutral terms"] = {
description = "{{{langname}}} terms that are applicable to all people, independent of gender.",
parents = {"terms by usage"},
}

labels["higher register terms"] = {
description = "{{{langname}}} terms belonging to a higher linguistic register, such as literary terms; such terms are somewhat less common or known.",
parents = {"terms by usage"},
}

labels["historical terms"] = {
description = "{{{langname}}} terms that refer to obsolete things or concepts.",
parents = {"terms by usage"},
}

labels["honorific terms"] = {
description = "{{{langname}}} [[Wiktionary:honorific|honorific]] terms, which are used to show deference and respect.",
parents = {"terms by usage"},
}

labels["polite terms"] = {
description = "{{{langname}}} [[Wiktionary:polite|polite]] terms, which are used to show deference and respect.",
parents = {"terms by usage"},
}

labels["hapax legomena"] = {
description = "{{{langname}}} terms that are attested only once in the entire corpus.",
parents = {"terms by usage"},
}

labels["humble terms"] = {
description = "{{{langname}}} [[Wiktionary:humble|humble]] terms, which are used to indicate that the addressee has higher social standing.",
parents = {"honorific terms"},
}

labels["hypercorrections"] = {
description = "{{{langname}}} forms of other terms by misapplications of grammatical or orthographical rules.",
parents = {"nonstandard terms", "nonstandard forms"},
}

labels["hyperforeign terms"] = {
description = "{{{langname}}} terms created by misapplying the perceived grammatical, orthographical or phonetical rules of another language.",
parents = {"hypercorrections"},
}

labels["incel slang"] = {
description = "{{{langname}}} [[Wiktionary:slang|slang]] terms whose usage is typically restricted to incels.",
parents = {"slang", "Category:{{{langcode}}}:Incel community"},
}

labels["imperfective forms"] = {
description = "{{{langname}}} verbs that serve as imperfective variants of perfective verbs, sharing the same base set of meanings.",
parents = {"terms by usage"},
}

labels["informal forms"] = {
description = "{{{langname}}} terms that can be used in casual, non-ceremonious conversations as alternative forms of other terms.",
parents = {"informal terms"},
}

labels["informal terms"] = {
description = "{{{langname}}} terms whose use is typically restricted to casual, non‐ceremonious conversations.",
parents = {"terms by usage"},
}

labels["intentional misspellings"] = {
description = "Intentional misspellings of {{{langname}}} terms.",
parents = {"misspellings"},
}

labels["internet laughter slang"] = {
description = "{{{langname}}} [[Wiktionary:slang|slang]] terms that are used as substitutes for laughter in internet-related contexts.",
additional = "::''Note: The majority of items that <u>could</u> be here do not meet Wiktionary's [[WT:CFI|criteria for inclusion]].''",
parents = {"internet slang"},
}

labels["internet slang"] = {
description = "{{{langname}}} [[Wiktionary:slang|slang]] terms whose usage is typically restricted to internet users.",
parents = {"slang"},
}

labels["humorous terms"] = {
description = "{{{langname}}} terms that are humorous, amusing or joking.",
parents = {"terms by usage"},
}

labels["journalistic terms"] = {
description = "{{{langname}}} terms that are used especially in [[Wiktionary:journalistic|journalistic]] language, i.e. in newspapers and magazines.",
parents = {"terms by usage"},
}

labels["leet"] = {
description = "{{{langname}}} which are used in [[Wiktionary:leetspeak|leetspeak]], a variety of internet slang that focuses on substitution of letters by other characters which are similar in appearance.",
parents = {"internet slang"},
}

labels["literary terms"] = {
description = "{{{langname}}} terms whose usage is typically restricted to works of literature.",
parents = {"higher register terms"},
}

labels["medical slang"] = {
description = "{{{langname}}} [[Wiktionary:slang|slang]] terms whose usage is typically restricted to medical doctors, such as physicians and surgeons.",
parents = {"slang"},
}

labels["military slang"] = {
description = "{{{langname}}} [[Wiktionary:slang|slang]] terms whose usage is typically restricted to military personnel.",
parents = {"slang"},
}

labels["misconstructions"] = {
description = "Terms wrongly built due to a misunderstanding of their parts.",
parents = {"nonstandard forms"},
}

labels["misromanizations"] = {
description = "Common misromanizations of {{{langname}}} terms.",
parents = {"nonstandard forms"},
}

labels["misspellings"] = {
description = "Common accidental misspellings of {{{langname}}} terms and some terms which are deliberate misspellings.",
parents = {"nonstandard forms"},
}

labels["naval slang"] = {
description = "{{{langname}}} [[Wiktionary:slang|slang]] terms whose usage is typically restricted to naval personnel.",
parents = {"military slang"},
}

labels["nonstandard forms"] = {
description = "{{{langname}}} forms of standard terms that are considered improper, incorrect or commonly misused.",
parents = {"nonstandard terms"},
}

labels["nonstandard terms"] = {
description = "{{{langname}}} terms that are considered improper, incorrect or commonly misused.",
parents = {"terms by usage"},
}

labels["numismatic slang"] = {
description = "{{{langname}}} [[Wiktionary:slang|slang]] terms whose usage is typically restricted to numismatists.",
parents = {"slang", "Category:{{{langcode}}}:Currency"},
}

labels["obsolete forms"] = {
description = "{{{langname}}} terms that are found in older texts and are no longer in current use, because they changed in comparison with recent general use.",
parents = {"terms with obsolete senses"},
}

labels["obsolete terms"] = {
description = "{{{langname}}} terms that are no longer in current use, but found in older texts.",
parents = {"terms by usage"},
}

labels["offensive terms"] = {
description = "{{{langname}}} terms that are typically considered to offend people.",
parents = {"terms by usage"},
}

labels["officialese terms"] = {
description = "{{{langname}}} terms that are chiefly used by official sources, and are often bureaucratic-sounding.",
parents = {"terms by usage"},
}

labels["oxymorons"] = {
description = "{{{langname}}} terms that are juxtapositions of opposing ideas.",
parents = {"terms by usage"},
}

labels["perfective forms"] = {
description = "{{{langname}}} verbs that serve as perfective variants of imperfective verbs, sharing the same base set of meanings.",
parents = {"terms by usage"},
}

labels["placeholder terms"] = {
description = "{{{langname}}} terms used to refer to items for which one does not know or cannot recall the name, or is unable to or does not care to specify precisely.",
parents = {"terms by usage"},
}

labels["poetic terms"] = {
description = "{{{langname}}} terms whose usage is typically restricted to works of poetry.",
parents = {"terms by usage", "literary terms"},
}

labels["post-nominal letters"] = {
description = "{{{langname}}} Post-nominal letters - also called post-nominal initials, post-nominal titles or designatory letters are letters placed after the name of a person to indicate that the individual holds a position, educational degree, accreditation, office, military decoration, or honour, or is a member of a religious institute or fraternity.",
parents = {"terms by usage"},
}

labels["prison slang"] = {
description = "{{{langname}}} [[Wiktionary:slang|slang]] terms whose usage is typically restricted to detainees in correctional institutions.",
parents = {"slang"},
}

labels["proscribed terms"] = {
description = "{{{langname}}} terms whose usage is proscribed; thus, they are considered wrong according to prescriptive sources.",
parents = {"terms by usage", "nonstandard terms"},
}

labels["radio slang"] = {
description = "{{{langname}}} [[Wiktionary:slang|slang]] terms whose usage is typically restricted to radio communication.",
parents = {"slang"},
}

labels["rare forms"] = {
description = "{{{langname}}} terms that serve as rarely used forms of other terms.",
parents = {"terms with rare senses"},
}

labels["rare terms"] = {
description = "{{{langname}}} terms that are rare in general use, for whatever reason.",
parents = {"terms by usage"},
}

labels["Reddit slang"] = {
description = "{{{langname}}} [[Wiktionary:slang|slang]] terms whose usage is typically restricted to users of the website {{w|Reddit}}.",
parents = {"internet slang"},
}

labels["religious slurs"] = {
description = "{{{langname}}} terms that are intended to offend members of certain religions.",
parents = {"offensive terms"},
}

labels["reverential terms"] = {
description = "{{{langname}}} terms used when referring to nobles.",
parents = {"honorific terms"},
}

labels["royal terms"] = {
description = "{{{langname}}} terms used only by royalty.",
parents = {"terms by usage"},
}

labels["school slang"] = {
description = "{{{langname}}} [[Wiktionary:slang|slang]] terms whose usage is typically restricted to schools and school pupils.",
parents = {"slang"},
}

labels["self-deprecatory terms"] = {
description = "{{{langname}}} [[Wiktionary:self-deprecatory|self-deprecatory]] terms.",
parents = {"terms by usage"},
}

labels["short forms"] = {
description = "{{{langname}}} terms that are [[Wiktionary:short form|short form]]s of other terms, often used informally.",
parents = {"terms by usage", "shortenings"},
}

labels["slang"] = {
description = "{{{langname}}} [[Wiktionary:colloquial|colloquial]] terms that are typically used to mark membership in a cultural subgroup.",
parents = {"terms by usage"},
}

labels["solemn terms"] = {
description = "{{{langname}}} terms that are used to instill a sense of somberness.",
parents = {"terms by usage"},
}

labels["student slang"] = {
description = "{{{langname}}} [[Wiktionary:slang|slang]] terms whose usage is typically restricted to colleges, universities, and their students.",
parents = {"slang"},
}

labels["superseded forms"] = {
description = "{{{langname}}} forms that have been superseded by other forms due to changes in spelling conventions.",
parents = {"terms by usage", "terms by orthographic property"},
}

labels["swear words"] = {
description = "{{{langname}}} terms that are used to swear, such as to express strong anger or frustration.",
parents = {"vulgarities"},
}

labels["technical terms"] = {
description = "{{{langname}}} terms that are usually or exclusively used in technical/scientific writing.",
parents = {"terms by usage"},
}

labels["terms of address"] = {
description = "{{{langname}}} terms used to refer to another person.",
parents = {"terms by usage"},
}

labels["terms with archaic senses"] = {
description = "{{{langname}}} terms that are no longer in general use but still encountered in older literature and still sometimes used for special effect.",
parents = {"terms by usage"},
}

labels["terms with dated senses"] = {
description = "{{{langname}}} terms that have one or more senses that are occasionally still found in use, but are clearly old-fashioned or typical of older texts",
parents = {"terms by usage"},
}

labels["terms with historical senses"] = {
description = "{{{langname}}} terms with senses that refer to things or concepts mainly known for their historical value.",
parents = {"terms by usage"},
}

labels["terms with obsolete senses"] = {
description = "{{{langname}}} terms that are no longer in current use, but found in older texts.",
parents = {"terms by usage"},
}

labels["terms with rare senses"] = {
description = "{{{langname}}} rarely used terms or terms with rarely used senses.",
parents = {"terms by usage"},
}

labels["terms with transferred senses"] = {
description = "{{{langname}}} terms with [[Appendix:Glossary#transferred senses|transferred senses]].",
parents = {"terms by usage"},
}

labels["terms with uncommon senses"] = {
description = "{{{langname}}} uncommonly used terms or terms with uncommonly used senses.",
parents = {"terms by usage"},
}

labels["terms with uncertain meaning"] = {
description = "{{{langname}}} terms whose meaning is unknown or disputed.",
parents = {"terms by usage"},
}

labels["text messaging slang"] = {
description = "{{{langname}}} terms used for [[Wiktionary:text messaging|text messaging]] on mobile phones or similar devices, usually consisting of heavily abbreviated forms.",
parents = {"slang"},
}

labels["tone indicators"] = {
description = "{{{langname}}} symbols used to denote or clarify the intent of a preceeding message.",
parents = {"internet slang"},
}

labels["trademarks"] = {
description = "{{{langname}}} terms that identify legal entities, their products and services, by means of legal protection — to some extent, in a number of jurisdictions — against unauthorized use of the terms.",
parents = {"terms by usage"},
}

labels["transgender slang"] = {
description = "{{{langname}}} [[Wiktionary:slang|slang]] terms whose usage is typically restricted to transgender people.",
parents = {"slang", "Category:{{{langcode}}}:Transgender"},
}

labels["TV Tropes slang"] = {
description = "{{{langname}}} [[Wiktionary:slang|slang]] terms whose usage is typically restricted to users of the website {{w|TV Tropes}}.",
parents = {"internet slang"},
}

labels["umlautless spellings"] = {
description = "{{{langname}}} terms that are the result of the original terms' [[Wiktionary:umlaut|umlaut]]s being substituted.",
parents = {"nonstandard forms", "terms by orthographic property"},
}

labels["uncommon forms"] = {
description = "{{{langname}}} terms that serve as uncommonly used forms of other terms.",
parents = {"uncommon terms"},
}

labels["uncommon terms"] = {
description = "{{{langname}}} uncommonly used terms.",
parents = {"terms by usage"},
}

labels["Usenet slang"] = {
description = "{{{langname}}} [[Wiktionary:slang|slang]] terms whose usage is typically restricted to users of {{w|Usenet}}.",
parents = {"internet slang"},
}

labels["men's speech terms"] = {
description = "{{{langname}}} terms and forms used in [[Appendix:Glossary#men's speech|men's speech]].",
parents = {"terms by usage"},
}

labels["women's speech terms"] = {
description = "{{{langname}}} terms and forms used in [[Appendix:Glossary#women's speech|women's speech]].",
parents = {"terms by usage"},
}

labels["vulgarities"] = {
description = "{{{langname}}} terms whose tone (rather than the meaning) is offensive to polite company.",
parents = {"terms by usage"},
}

-- Add 'umbrella_parents' key if not already present.
for key, data in pairs(labels) do
if not data.umbrella_parents then
data.umbrella_parents = "Terms by usage subcategories by language"
end
end

-----------------------------------------------------------------------------
-- --
-- RAW CATEGORIES --
-- --
-----------------------------------------------------------------------------

raw_categories["Terms by usage subcategories by language"] = {
description = "Umbrella categories covering topics related to terms categorized by their usage, such as slang, obsolete or archaic forms and vulgarities.",
additional = "{{{umbrella_meta_msg}}}",
parents = {
"Umbrella metacategories",
{name = "terms by usage", is_label = true, sort = " "},
},
}

return {LABELS = labels, RAW_CATEGORIES = raw_categories}

Module:Category tree/poscatboiler/data/terms by semantic function

Jsrs701 — Fri, 10 Apr 2026 07:25:57 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data/terms by semantic function by file upload (1 revision)

New page

Module:Category tree/poscatboiler/data/terms by script

Jsrs701 — Fri, 10 Apr 2026 07:25:56 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data/terms by script by file upload (1 revision)

New page

Module:Category tree/poscatboiler/data/terms by lexical property

Jsrs701 — Fri, 10 Apr 2026 07:25:56 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data/terms by lexical property by file upload (1 revision)

New page

Module:Category tree/poscatboiler/data/terms by grammatical category

Jsrs701 — Fri, 10 Apr 2026 07:25:56 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data/terms by grammatical category by file upload (1 revision)

New page

local labels = {}
local raw_categories = {}
local handlers = {}

-----------------------------------------------------------------------------
-- --
-- LABELS --
-- --
-----------------------------------------------------------------------------

labels["terms by grammatical category"] = {
description = "{{{langname}}} terms categorized by their grammatical category.",
umbrella_parents = "Fundamental",
parents = {{name = "{{{langcat}}}", raw = true}},
}

------- GENDER -------

for _, pos in ipairs { "nouns", "pronouns", "proper nouns", "suffixes" } do
labels[pos .. " by gender"] = {
description = "{{{langname}}} " .. pos .. " organized by the gender they belong to.",
breadcrumb = "by gender",
parents = {{name = pos, sort = "gender"}},
}

labels[pos .. " with irregular gender"] = {
description = "{{{langname}}} " .. pos .. " whose ending is not typical for " .. pos .. " of their gender.",
breadcrumb = "with irregular gender",
parents = {{name = "irregular " .. pos, sort = "irregular gender"}},
}

labels[pos .. " with multiple genders"] = {
description = "{{{langname}}} " .. pos .. " that belong to more than one gender.",
breadcrumb = "with multiple genders",
parents = {{name = pos .. " by gender", sort = "multiple genders"}},
}

labels["common-gender " .. pos] = {
description = "{{{langname}}} " .. pos .. " of [[Appendix:Glossary#common gender|common gender]], i.e. belonging to a gender category that combines the function of [[Appendix:Glossary#masculine|masculine]] and [[Appendix:Glossary#feminine|feminine]] and is opposed to the [[Appendix:Glossary#neuter|neuter]] gender.",
breadcrumb = "common-gender",
parents = {pos .. " by gender"},
}

labels["feminine " .. pos] = {
description = "{{{langname}}} " .. pos .. " of [[Appendix:Glossary#feminine|feminine]] gender, i.e. belonging to a gender category that contains (among other things) female beings.",
breadcrumb = "feminine",
parents = {pos .. " by gender"},
}

labels["masculine " .. pos] = {
description = "{{{langname}}} " .. pos .. " of [[Appendix:Glossary#masculine|masculine]] gender, i.e. belonging to a gender category that contains (among other things) male beings.",
breadcrumb = "masculine",
parents = {pos .. " by gender"},
}

labels["masculine and feminine " .. pos .. " by sense"] = {
description = "{{{langname}}} " .. pos .. " that may be either [[Appendix:Glossary#masculine|masculine]] or [[Appendix:Glossary#feminine|feminine]] depending on whether they refer to male or female beings.",
breadcrumb = "masculine and feminine by sense",
parents = {pos .. " by gender"},
}

labels["neuter " .. pos] = {
description = "{{{langname}}} " .. pos .. " of [[Appendix:Glossary#neuter|neuter]] gender, i.e. belonging to a gender category that does not usually contain male or female beings.",
breadcrumb = "neuter",
parents = {pos .. " by gender"},
}
end

------- CLASSES -------

for _, pos in ipairs { "nouns", "pronouns", "proper nouns", "suffixes", "adjectives", "verbs", "numerals" } do
labels[pos .. " by class"] = {
description = "{{{langname}}} " .. pos .. " organized by the class they belong to.",
breadcrumb = "by class",
parents = {{name = pos, sort = "class"}},
}

labels[pos .. " with irregular class"] = {
description = "{{{langname}}} " .. pos .. " whose ending is not typical for " .. pos .. " of their class.",
breadcrumb = "with irregular class",
parents = {{name = "irregular " .. pos, sort = "irregular class"}},
}

labels[pos .. " with multiple classes"] = {
description = "{{{langname}}} " .. pos .. " that belong to more than one class.",
breadcrumb = "with multiple classes",
parents = {{name = pos .. " by class", sort = "multiple classes"}},
}

end

------- ANIMACY -------

for _, pos in ipairs({"nouns", "pronouns", "proper nouns", "suffixes", "verbs"}) do
labels["animate " .. pos] = {
description = "{{{langname}}} " .. pos .. " that refer to humans or animals.",
breadcrumb = "animate",
parents = {pos},
}

labels["inanimate " .. pos] = {
description = "{{{langname}}} " .. pos .. " that refer to inanimate objects (not humans or animals).",
breadcrumb = "inanimate",
parents = {pos},
}

labels[pos .. " with multiple animacies"] = {
description = "{{{langname}}} " .. pos .. " that belong to more than one animacy.",
breadcrumb = "with multiple animacies",
parents = {{name = pos, sort = "multiple animacies"}},
}
end

for _, pos in ipairs({"nouns", "suffixes"}) do
-- This category should be used particularly in languages that have
-- grammatical distinctions related to animals, such as Ukrainian.
labels["animal " .. pos] = {
description = "{{{langname}}} " .. pos .. " that refer to animals.",
breadcrumb = "animal",
parents = {"animate " .. pos},
}

-- This category should be used particularly in languages that have
-- grammatical distinctions related to men, such as Polish.
labels["nonvirile " .. pos] = {
description = "{{{langname}}} plural " .. pos .. " that refer to a group without male humans.",
breadcrumb = "nonvirile",
parents = {pos, "pluralia tantum"},
}

labels["personal " .. pos] = {
description = "{{{langname}}} " .. pos .. " that refer to humans.",
breadcrumb = "personal",
parents = {"animate " .. pos},
}

-- This category should be used particularly in languages that have
-- grammatical distinctions related to men, such as Polish.
labels["virile " .. pos] = {
description = "{{{langname}}} plural " .. pos .. " that refer to a group with at least one male human.",
breadcrumb = "virile",
parents = {pos, "pluralia tantum"},
}
end

------- INFLECTED PARTS OF SPEECH -------

-- Add "POS by inflection type", "irregular POS" and "POS by tone"
-- categories for (potentially) inflected parts of speech.

local inflected_poses = {
"adjectives",
"adverbs",
"determiners",
"nouns",
"numerals",
"participles",
"pronouns",
"proper nouns",
"suffixes",
"verbs",
}

for _, pos in ipairs(inflected_poses) do
labels[pos .. " by inflection type"] = {
description = "{{{langname}}} " .. pos .. " organized by the type of inflection they follow.",
breadcrumb = "by inflection type",
parents = {{name = pos, sort = "inflection"}},
}

labels["irregular " .. pos] = {
description = "{{{langname}}} " .. pos .. " that follow non-standard patterns of inflection.",
breadcrumb = "irregular",
parents = {pos .. " by inflection type"},
}

labels["defective " .. pos] = {
description = "{{{langname}}} " .. pos .. " that lack one or more forms in their inflections.",
breadcrumb = "defective",
parents = {pos, "irregular " .. pos},
}

labels["suppletive " .. pos] = {
description = "{{{langname}}} " .. pos .. " that have inflected forms from different roots.",
breadcrumb = "suppletive",
parents = {"irregular " .. pos},
}

if pos ~= "verbs" and pos ~= "adverbs" then
labels["indeclinable " .. pos] = {
description = "{{{langname}}} " .. pos .. " that do not display additional grammatical relations by means of declension.",
breadcrumb = "indeclinable",
parents = {pos .. " by inflection type"},
}

labels[pos .. " with multiple declensions"] = {
description = "{{{langname}}} " .. pos .. " that follow more than one type of inflection.",
breadcrumb = "with multiple declensions",
parents = {{name = pos .. " by inflection type", sort = "multiple declensions"}},
}

labels[pos .. " with multiple plurals"] = {
description = "{{{langname}}} " .. pos .. " that have more than one possible plural (sometimes with distinct meanings).",
breadcrumb = "with multiple plurals",
parents = {{name = pos .. " by inflection type", sort = "multiple plurals"}},
}
end

labels[pos .. " by tone"] = {
description = "{{{langname}}} " .. pos .. " organized by the tone they follow.",
breadcrumb = "by tone",
parents = {{name = pos .. " by inflection type", sort = "tone"}},
}

labels[pos .. " by vowel harmony"] = {
description = "{{{langname}}} " .. pos .. " organized by the vowel harmony they follow.",
breadcrumb = "by vowel harmony",
parents = {{name = pos .. " by inflection type", sort = "vowel harmony"}},
}
end

-- FIXME: Only used currently for Arabic; probably should be removed as a general category.
labels["irregular elative adjectives"] = {
description = "{{{langname}}} elative adjectives that follow non-standard patterns of inflection.",
parents = {"adjectives by inflection type"},
}

for _, pos in ipairs { "nouns", "proper nouns", "pronouns" } do
labels[pos .. " with unattested plurals"] = {
description = "{{{langname}}} " .. pos .. " with unattested plurals.",
breadcrumb = "with unattested plurals",
parents = {{name = pos, sort = "unattested plurals"}},
}
labels["definite " .. pos] = {
description = "{{{langname}}} " .. pos .. " that are inherently definite and have definite concord.",
breadcrumb = "definite",
parents = {pos .. " by inflection type"},
}
end

------- GERMANIC VERB CLASSES -------

-- FIXME: Not clear this belongs among the general categories.

labels["strong verbs"] = {
description = "{{{langname}}} verbs that present different stem vowels in their typically regular conjugated forms.",
breadcrumb = "strong",
parents = {"verbs by inflection type"},
}

labels["weak verbs"] = {
description = "{{{langname}}} verbs that display dental suffixes in their past tense conjugated forms.",
breadcrumb = "weak",
parents = {"verbs by inflection type"},
}

labels["preterite-present verbs"] = {
description = "{{{langname}}} verbs that inflect in the present tense like the past tense of strong verbs.",
breadcrumb = "preterite-present",
parents = {"verbs by inflection type"},
}

labels["class 1 strong verbs"] = {
description = "Verbs where the [[Wiktionary:ablaut|ablaut]] vowel was followed by ''-y-'' in Proto-Indo-European.",
breadcrumb = "class 1",
parents = {{name = "strong verbs", sort = "1"}},
}

labels["class 1 weak verbs"] = {
description = "Weak verbs of the first class.",
breadcrumb = "class 1",
parents = {{name = "weak verbs", sort = "1"}},
}

labels["class 2 strong verbs"] = {
description = "Verbs where the [[Wiktionary:ablaut|ablaut]] vowel was followed by ''-w-'' in Proto-Indo-European.",
breadcrumb = "class 2",
parents = {{name = "strong verbs", sort = "2"}},
}

labels["class 2a strong verbs"] = {
description = "Verbs where the [[Wiktionary:ablaut|ablaut]] vowel was *eu in Proto-Germanic.",
breadcrumb = "class 2a",
parents = {{name = "class 2 strong verbs", sort = "1"}},
}

labels["class 2b strong verbs"] = {
description = "Verbs where the [[Wiktionary:ablaut|ablaut]] vowel was *ū in Proto-Germanic.",
breadcrumb = "class 2b",
parents = {{name = "class 2 strong verbs", sort = "2"}},
}

labels["class 2 weak verbs"] = {
description = "Weak verbs of the second class.",
breadcrumb = "class 2",
parents = {{name = "weak verbs", sort = "2"}},
}

labels["class 3 weak verbs"] = {
description = "Weak verbs of the third class.",
breadcrumb = "class 3",
parents = {{name = "weak verbs", sort = "3"}},
}

labels["class 3 strong verbs"] = {
description = "Verbs where the [[Wiktionary:ablaut|ablaut]] vowel was followed by a [[Wiktionary:consonant cluster|consonant cluster]] in Proto-Indo-European.",
breadcrumb = "class 3",
parents = {{name = "strong verbs", sort = "3"}},
}

labels["class 3a strong verbs"] = {
description = "Verbs where the [[Wiktionary:consonant cluster|consonant cluster]] begins with a nasal consonant.",
breadcrumb = "class 3a",
parents = {{name = "class 3 strong verbs", sort = "1"}},
}

labels["class 3b strong verbs"] = {
description = "Verbs where the [[Wiktionary:consonant cluster|consonant cluster]] begins with a lateral consonant or velar fricative.",
breadcrumb = "class 3b",
parents = {{name = "class 3 strong verbs", sort = "2"}},
}

labels["class 3c strong verbs"] = {
description = "Verbs where the [[Wiktionary:consonant cluster|consonant cluster]] begins with a rhotic consonant.",
breadcrumb = "class 3c",
parents = {{name = "class 3 strong verbs", sort = "3"}},
}

labels["class 4 strong verbs"] = {
description = "Verbs where the [[Wiktionary:ablaut|ablaut]] vowel was followed by a [[Wiktionary:sonorant|sonorant]] (''m'', ''n'', ''l'', ''r'') but no other consonant in Proto-Indo-European.",
breadcrumb = "class 4",
parents = {{name = "strong verbs", sort = "4"}},
}

labels["class 4 weak verbs"] = {
description = "Weak verbs of the fourth class.",
breadcrumb = "class 4",
parents = {{name = "weak verbs", sort = "4"}},
}

labels["class 5 strong verbs"] = {
description = "Verbs where the [[Wiktionary:ablaut|ablaut]] vowel was followed by [[Wiktionary:consonant|consonant]] other than a [[Wiktionary:sonorant|sonorant]] in Proto-Indo-European.",
breadcrumb = "class 5",
parents = {{name = "strong verbs", sort = "5"}},
}

labels["class 6 strong verbs"] = {
description = "The Proto-Indo-European origin of this class is not securely known. It contains verbs with the stem vowel ''-a-'', except those where it is followed by a sonorant and another consonant (this combination was considered a diphthong in PIE and therefore belonged to class 7).",
breadcrumb = "class 6",
parents = {{name = "strong verbs", sort = "6"}},
}

labels["class 7 strong verbs"] = {
description = "Verbs that retained their reduplication in the past tense in Proto-Germanic.",
breadcrumb = "class 7",
parents = {{name = "strong verbs", sort = "7"}},
}

labels["class 7a strong verbs"] = {
description = "Class 7 strong verbs where the root vowel was ''*ai'' in Proto-Germanic, analogous to class 1.",
breadcrumb = "class 7a",
parents = {{name = "class 7 strong verbs", sort = "a"}},
}

labels["class 7b strong verbs"] = {
description = "Class 7 strong verbs where the root vowel was ''*au'' in Proto-Germanic, analogous to class 2.",
breadcrumb = "class 7b",
parents = {{name = "class 7 strong verbs", sort = "b"}},
}

labels["class 7c strong verbs"] = {
description = "Class 7 strong verbs where the root vowel was ''*a'' followed by a [[Wiktionary:consonant cluster|consonant cluster]] in Proto-Germanic, analogous to class 3.",
breadcrumb = "class 7c",
parents = {{name = "class 7 strong verbs", sort = "c"}},
}

labels["class 7d strong verbs"] = {
description = "Class 7 strong verbs where the root vowel was ''*ē'' in Proto-Germanic.",
breadcrumb = "class 7d",
parents = {{name = "class 7 strong verbs", sort = "d"}},
}

labels["class 7e strong verbs"] = {
description = "Class 7 strong verbs where the root vowel was ''*ō'' in Proto-Germanic.",
breadcrumb = "class 7e",
parents = {{name = "class 7 strong verbs", sort = "e"}},
}

local labels2 = {}

-- Add 'umbrella_parents' key if not already present.
for key, data in pairs(labels) do
labels2[key] = data
if not data.umbrella_parents then
data.umbrella_parents = "Terms by grammatical category subcategories by language"
end
end

-----------------------------------------------------------------------------
-- --
-- RAW CATEGORIES --
-- --
-----------------------------------------------------------------------------

raw_categories["Terms by grammatical category subcategories by language"] = {
description = "Umbrella categories covering topics related to grammatical categories, such as gender, animacy and noun and verb classes.",
additional = "{{{umbrella_meta_msg}}}",
parents = {
"Umbrella metacategories",
{name = "terms by grammatical category", is_label = true, sort = " "},
},
}

-----------------------------------------------------------------------------
-- --
-- HANDLERS --
-- --
-----------------------------------------------------------------------------

table.insert(handlers, function(data)
local class = data.label:match("^class ([0-9a-z]+) nouns$")
if class then
local classnum, suffix = class:match("^([0-9]+)([a-z]*)$")
return {
description =
"{{{langname}}} nouns that belong to class " .. class .. ".",
breadcrumb = class,
umbrella = false,
parents = {{
name = "nouns by class",
sort = classnum and ("#%02d"):format(classnum) .. suffix or class,
}},
}
end
local class = data.label:match("^class ([0-9a-z]+) verbs$")
if class then
local classnum, suffix = class:match("^([0-9]+)([a-z]*)$")
return {
description =
"{{{langname}}} verbs that belong to class " .. class .. ".",
breadcrumb = class,
umbrella = false,
parents = {{
name = "verbs by class",
sort = classnum and ("#%02d"):format(classnum) .. suffix or class,
}},
}
end
end)

table.insert(handlers, function(data)
local pos, tone = data.label:match("^(.+) with tone ([^ ]+)$")
if pos then
return {
description = "{{{langname}}} " .. pos .. " with tone " .. tone .. ".",
breadcrumb = tone,
-- FIXME, should there be an umbrella category e.g. 'Adjectives with tone H by language'?
umbrella = false,
parents = {{
name = pos .. " by tone",
sort = "" .. tone:len() .. tone,
}},
}
end
end)

table.insert(handlers, function(data)
local vh, pos = data.label:match("^(.+)-harmonic ([^ ]+)$")
if pos then
return {
description = "{{{langname}}} " .. pos .. " with vowel harmony in " .. vh .. ".",
breadcrumb = vh,
umbrella = false,
parents = {{
name = pos .. " by vowel harmony",
sort = "" .. vh:len() .. vh,
}},
}
end
end)

table.insert(handlers, function(data)
local pos, classifier = data.label:match("^(nouns) classified by (.+)$")
if pos then
local linktext
if data.lang then
if data.lang:getCode() == "zh" then
linktext = require("Module:zh/link").link(nil, true, { classifier, tr = "-" }, classifier)
else
linktext = require("Module:links").full_link({ term = classifier, lang = data.lang }, "term")
end
else
linktext = classifier
end
return {
description = "{{{langname}}} " .. pos .. " using " .. linktext .. " as their classifier.",
breadcrumb = classifier,
umbrella = false,
parents = {{
name = pos .. " by classifier",
sort = (data.lang:makeSortKey(classifier)),
}},
}
end
end)

return {LABELS = labels2, RAW_CATEGORIES = raw_categories, HANDLERS = handlers}

Module:Category tree/poscatboiler/data/terms by etymology

Jsrs701 — Fri, 10 Apr 2026 07:25:56 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data/terms by etymology by file upload (1 revision)

Show changes

Module:Category tree/poscatboiler/data/templates

Jsrs701 — Fri, 10 Apr 2026 07:25:55 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data/templates by file upload (1 revision)

New page

Module:Category tree/poscatboiler/data/symbols

Jsrs701 — Fri, 10 Apr 2026 07:25:55 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data/symbols by file upload (1 revision)

New page

Module:Category tree/poscatboiler/data/shortenings

Jsrs701 — Fri, 10 Apr 2026 07:25:55 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data/shortenings by file upload (1 revision)

New page

Module:Category tree/poscatboiler/data/scripts

Jsrs701 — Fri, 10 Apr 2026 07:25:55 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data/scripts by file upload (1 revision)

New page

local raw_categories = {}
local raw_handlers = {}

-- A list of Unicode blocks to which the characters of the script or scripts belong is created by this module
-- and displayed in script category pages.
local blocks_submodule = "Module:category tree/poscatboiler/data/scripts/blocks"

-----------------------------------------------------------------------------
-- --
-- SCRIPT LABELS --
-- --
-----------------------------------------------------------------------------

--[=[
The following values are recognized for each script label:

'description'
A plain English description for the label. Special template substitutions are recognized; see below.
'umbrella_parents'
A table listing one or more parent categories of the umbrella category 'LABELS by script' for this label.
The format is as for regular raw categories (see [[Module:category tree/poscatboiler/data/documentation]]).
'umbrella_breadcrumb'
The breadcrumb to use in the umbrella category 'LABELS by script'. Defaults to "by script".
'catfix'
Same as the 'catfix' parameter for regular raw categories (see [[Module:category tree/poscatboiler/data/documentation]]).
This specifies a language code to use to ensure that pages in the category are displayed in the right font and linked
appropriately. If this is set, the 'catfix_sc' parameter will effectively be set with the script code in question.

Special template-like parameters can be used inside the 'description' field (as well as in the 'root_description', 'root_intro' and
'root_additional' variable values initialized below). These are replaced by the equivalent text.

{{{code}}}: Script code.
{{{codes}}}: A comma-separated list of all the alias codes for this script. This applies especially to Arabic, which has
multiple aliases (e.g. 'tt-Arab', 'ur-Arab', 'ku-Arab', etc.).
{{{codesplural}}}: The value "s" if {{{codes}}} lists more than one code, otherwise an empty string.
{{{scname}}}: The name of the script that the category belongs to.
{{{sccat}}}: The name of the script's main category, which adds "script" to the capitalized regular name.
{{{scdisp}}}: The display form of the script, which adds "script" to the regular name.
{{{scprosename}}}: Same as {{{scdisp}}} for Morse code and flag semaphore, otherwise adds "the" before {{{scdisp}}}.
{{{Wikipedia}}}: The Wikipedia article for the script (if it is present in the language's data file), or else {{{sccat}}}.
]=]

local script_labels = {}

script_labels["characters"] = {
description = "All characters from {{{scprosename}}}, and their possible variations, such as versions with diacritics and combinations recognized as single characters in any language.",
umbrella_parents = {"Fundamental"},
umbrella_breadcrumb = "Characters by script",
catfix = "mul",
}

script_labels["appendices"] = {
description = "Appendices about {{{scprosename}}}.",
umbrella_parents = {"Category:Appendices"},
}

script_labels["languages"] = {
description = "Languages that use {{{scprosename}}}.",
umbrella_parents = {"All languages"},
}

script_labels["templates"] = {
description = "Templates with predefined contents for {{{scprosename}}}.",
umbrella_parents = {"Templates"},
}

script_labels["modules"] = {
description = "Modules with scripts for {{{scprosename}}}.",
umbrella_parents = {"Modules"},
}

-----------------------------------------------------------------------------
-- --
-- RAW CATEGORIES --
-- --
-----------------------------------------------------------------------------

raw_categories["All scripts"] = {
description = "This category contains the categories for every script (writing system) on Wiktionary.",
additional = "See [[Wiktionary:List of scripts]] for a full list.",
parents = {"Fundamental"},
}

-- Types of writing systems listed in [[Module:writing systems/data]].
raw_categories["Scripts by type"] = {
description = "Scripts classified by how they represent words.",
parents = {{ name = "All scripts", sort = " " }},
}

raw_categories["Alphabetic writing systems"] = {
description = "Scripts whose symbols represent individual speech sounds.",
parents = {"Scripts by type"},
}

raw_categories["Abjads"] = {
description = "Scripts whose basic symbols represent consonants. Some of these are impure abjads, which have letters for some vowels.",
parents = {"Scripts by type"},
}

raw_categories["Abugidas"] = {
description = "Scripts whose symbols represent consonant and vowel combinations. Symbols representing the same consonant combined with different vowels are for the most part similar in form.",
parents = {"Scripts by type"},
}

raw_categories["Logographic writing systems"] = {
description = "Scripts whose symbols represent individual words.",
parents = {"Scripts by type"},
}

raw_categories["Pictographic writing systems"] = {
description = "Scripts whose symbols represent individual words by using symbols that resemble the physical objects to which those words refer.",
parents = {"Scripts by type"},
}

raw_categories["Semisyllabaries"] = {
description = "Scripts which are a combination of an alphabet and a syllbary.",
parents = {"Scripts by type"},
}

raw_categories["Syllabaries"] = {
description = "Scripts whose symbols represent consonant and vowel combinations. Symbols representing the same consonant combined with different vowels are for the most part different in form.",
parents = {"Scripts by type"},
}

for script_label, obj in pairs(script_labels) do
raw_categories[mw.getContentLanguage():ucfirst(script_label) .. " by script"] = {
description = "Categories with " .. script_label .. " of various specific scripts.",
breadcrumb = obj.umbrella_breadcrumb or "by script",
parents = obj.umbrella_parents,
}
end

-----------------------------------------------------------------------------
-- --
-- RAW HANDLERS --
-- --
-----------------------------------------------------------------------------

-- Intro text for "root" categories such as [[Category:Arabic script]]. Template substitutions are as described above.
local root_intro = [=[<div style="clear: right; border: solid #aaa 1px; margin: 1 1 1 1; background: #f9f9f9; width: 250px; padding: 5px; text-align: left; float: right">
<div style="text-align: center; margin-bottom: 10px; margin-top: 5px">'''{{{scdisp}}}'''</div>

{| style="font-size: 90%; background: #f9f9f9"
|-
| style="vertical-align: middle; height: 35px;" | [[File:Book notice.png|35px|none|Information]] || {{{scdisp}}} information
|-
| colspan="2" style="padding-left: 50px; border-bottom: 1px solid lightgray;" | '''[[Appendix:{{{sccat}}}]]'''
|-
| style="vertical-align: Middle; height: 35px;" | [[File:Abc box.svg|35px|none|Code]] || {{{scdisp}}} code
|-
| colspan="2" style="padding-left: 50px; border-bottom: 1px solid lightgray;" | '''{{{code}}}'''
|}
</div>]=]

-- Short description for "root" categories such as [[Category:Arabic script]]. Template substitutions are as described above.
local root_description = "This is the main category of '''{{{scprosename}}}'''."

-- Additional description text for "root" categories such as [[Category:Arabic script]]. Template substitutions are as described above.
local root_additional = [=[Information about {{{scprosename}}} may be available at [[Appendix:{{{sccat}}}]].

In various places at Wiktionary, {{{scprosename}}} is represented by the [[Wiktionary:Scripts|code{{{codesplural}}}]] {{{codes}}}.]=]

-- Replace template notation {{{}}} with variables.
local function substitute_template_refs(text, sc)
local displayForm = sc:getDisplayForm()
local scname = sc:getCanonicalName()
local codes = {}

for code, data in pairs(mw.loadData("Module:scripts/data")) do
if data[1] == scname then
table.insert(codes, "'''" .. code .. "'''")
end
end

if codes[2] then
table.sort(
codes,
-- Four-letter codes have length 10, because they are bolded: '''Latn'''.
function(code1, code2)
if #code1 == 10 then
if #code2 == 10 then
return code1 < code2
else
return true
end
else
if #code2 == 10 then
return false -- four-letter codes before other codes
else
return code1 < code2
end
end
end)
end

local content = {
code = sc:getCode(),
codesplural = codes[2] and "s" or "",
codes = table.concat(codes, ", "),
scname = scname,
sccat = sc:getCategoryName(),
scdisp = displayForm,
scprosename = (displayForm:find("code") or displayForm:find("semaphore")) and displayForm or "the " .. displayForm,
Wikipedia = sc:getWikipediaArticle(),
}

text = string.gsub(
text,
"{{{([^}]+)}}}",
function (parameter)
return content[parameter] or error("No value for script category parameter '" .. parameter .. "'.")
end)

return text
end

local function get_root_additional(additional, sc)
local ret = { additional }

local systems = sc:getSystems()
for _, system in ipairs(systems) do
table.insert(ret, "\n\nThe {{{scname}}} script is ")
if mw.ustring.sub(system:getCanonicalName(), 1, 1) == "a" then
table.insert(ret, "an ")
else
table.insert(ret, "a ")
end

local singular = system:getCategoryName()
singular = mw.getContentLanguage():lcfirst(singular)
singular = mw.ustring.gsub(singular, "ies$", "y")
singular = mw.ustring.gsub(singular, "s$", "")

table.insert(ret, singular .. ".")
end

local blocks = require(blocks_submodule)
.print_blocks_by_canonical_name(sc:getCanonicalName())

if blocks then
table.insert(ret, "\n")
table.insert(ret, blocks)
end

return substitute_template_refs(table.concat(ret), sc)
end

local function get_script_obj(script)
local scriptname = script:gsub(" script$", "")
return require("Module:scripts").getByCanonicalName(scriptname) or
-- [[Category:Undetermined script]] vs. name of script = "undetermined"
require("Module:scripts").getByCanonicalName(mw.ustring.lower(scriptname))
end

local scripts_without_script_in_category = {
-- FIXME, consider checking all scripts for names without 'script' in them.
["Morse code"] = true,
["Flag semaphore"] = true,
}

-- Handler for 'SCRIPT script' e.g. [[Category:Arabic script]] as well as [[Category:Morse code]] and
-- [[Category:Flag semaphore]].
table.insert(raw_handlers, function(data)
if not data.category:match("^(.+ script)$") and not scripts_without_script_in_category[data.category] then
return nil
end
local sc = get_script_obj(data.category)
if not sc then
return nil
end

-- Compute parents.
local parents = {}
local systems = sc:getSystems()
for _, system in ipairs(systems) do
table.insert(parents, system:getCategoryName())
end
table.insert(parents, "All scripts")

-- Compute (extra) children.
local children = {}
for script_label, _ in pairs(script_labels) do
table.insert(children, data.category .. " " .. script_label)
end

return {
intro = substitute_template_refs(root_intro, sc),
description = substitute_template_refs(root_description, sc),
additional = get_root_additional(root_additional, sc),
parents = parents,
breadcrumb = sc:getCategoryName(),
extra_children = children,
can_be_empty = true,
}
end)

-- Handler for 'SCRIPT script LABELS' e.g. [[Category:Arabic script templates]] as well as [[Category:Morse code LABELS]] and
-- [[Category:Flag semaphore LABELS]].
table.insert(raw_handlers, function(data)
local script, label
for lab, _ in pairs(script_labels) do
-- FIXME, if we add script labels with a hyphen in them we'll have to escape the hyphen
-- in the following patterns.
script, label = data.category:match("^(.+ script) (" .. lab .. ")$")
if script then
break
end
-- Check for e.g. 'Morse code characters' or 'Flag semaphore templates'.
script, label = data.category:match("^(.+) (" .. lab .. ")$")
if script then
if scripts_without_script_in_category[script] then
break
else
script = nil
end
end
end
if not script then
return nil
end

local sc = get_script_obj(script)
if not sc then
return nil
end

local label_obj = script_labels[label]
-- Compute description.
local desc = substitute_template_refs(label_obj.description, sc)

-- Compute parents.
local parents = {
{name = script, sort = label},
-- umbrella category
mw.getContentLanguage():ucfirst(label) .. " by script",
}

return {
description = substitute_template_refs(label_obj.description, sc),
parents = parents,
breadcrumb = label,
catfix = label_obj.catfix,
catfix_sc = label_obj.catfix and sc:getCode(),
}
end)

return {RAW_CATEGORIES = raw_categories, RAW_HANDLERS = raw_handlers}

Module:Category tree/poscatboiler/data/rhymes

Jsrs701 — Fri, 10 Apr 2026 07:25:54 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data/rhymes by file upload (1 revision)

New page

Module:Category tree/poscatboiler/data/phrases

Jsrs701 — Fri, 10 Apr 2026 07:25:54 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data/phrases by file upload (1 revision)

New page

local labels = {}
local raw_categories = {}

labels["phrases"] = {
description = "{{{langname}}} groups of words elaborated to express ideas, not necessarily [[Wiktionary:phrase|phrase]]s in the grammatical sense.",
umbrella_parents = "Lemmas subcategories by language",
parents = {"lemmas"},
}

labels["adverb-adjective phrases"] = {
description = "{{{langname}}} phrases in which an adverb modifies the adjective that heads the phrase.",
umbrella_parents = {name = "phrases", is_label = true, sort = " "},
parents = {"phrases"},
}

labels["alliterative phrases"] = {
description = "{{{langname}}} phrases composed of two or more words that alliterate.",
umbrella_parents = {name = "phrases", is_label = true, sort = " "},
parents = {"phrases"},
}

labels["rhyming phrases"] = {
description = "{{{langname}}} phrases composed of two or more words that rhyme.",
umbrella_parents = {name = "phrases", is_label = true, sort = " "},
parents = {"phrases"},
}

labels["sentences"] = {
description = "{{{langname}}} [[Wiktionary:sentence|sentence]]s.",
umbrella_parents = "Fundamental",
parents = {{name = "{{{langcat}}}", raw = true}},
}

labels["phrasebook"] = {
description = "{{{langname}}} non-idiomatic phrases that are used in common situations, and may be useful to language learners or travellers.",
parents = {
"phrases",
{name = "Phrasebooks by language", raw = true, sort = "{{{langname}}}"}
},
umbrella = false, -- Umbrella has a nonstandard name so we treat it as a raw category
}

raw_categories["Phrasebooks by language"] = {
description = "Categories with phrasebooks in various specific languages.",
additional = "Phrasebook categories contain non-idiomatic phrases that are used in common situations, and may be useful to language learners or travellers.\n\n" ..
"See [[Wiktionary:Phrasebook]] for more information.\n\n{{{umbrella_msg}}}",
parents = "Fundamental",
}

for _, category in ipairs({
{name = "Basic", topics = {}},
{name = "Communication", topics = {"Communication"}},
{name = "Emergencies", topics = {"Emergency medicine"}},
{name = "Ethnicity", topics = {"Ethnicity"}},
{name = "Family", topics = {"Family"}},
{name = "Farewells", topics = {"Farewells"}},
{name = "Festivities", topics = {}},
{name = "Food and drink", topics = {"Food and drink"}},
{name = "Greetings", topics = {"Greetings"}},
{name = "Health", topics = {"Health"}},
{name = "Love", topics = {"Love"}},
{name = "Money", topics = {"Money"}},
{name = "Needs", topics = {}},
{name = "Quotes", topics = {}},
{name = "Religion", topics = {"Religion"}},
{name = "Sex", topics = {"Sex"}},
{name = "Time", topics = {"Time"}},
{name = "Travel", topics = {"Travel"}},
{name = "Weather", topics = {"Weather"}},
}) do
local parents = {
{name = "phrasebook", sort = category.name},
{name = "Phrasebooks by language/" .. category.name, raw = true, sort = "{{{langname}}}"},
}
for _, topic in ipairs(category.topics) do
table.insert(parents, {module = "topic cat", args = {code = "{{{langcode}}}", label = topic}, sort = " "})
end
labels["phrasebook/" .. category.name] = {
description = "{{{langname}}} common non-idiomatic phrases in the category '" .. category.name .. "'.",
breadcrumb = category.name,
parents = parents,
umbrella = false,
}
raw_categories["Phrasebooks by language/" .. category.name] = {
description = "Categories with common non-idiomatic phrases in the category '" .. category.name .. "', in various specific languages.",
additional = "{{{umbrella_msg}}}",
parents = {{name = "Phrasebooks by language", sort = " "}},
breadcrumb = category.name,
}
end

return {LABELS = labels, RAW_CATEGORIES = raw_categories}

Module:Category tree/poscatboiler/data/non-lemma forms

Jsrs701 — Fri, 10 Apr 2026 07:25:54 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data/non-lemma forms by file upload (1 revision)

New page

local labels = {}
local raw_categories = {}

-----------------------------------------------------------------------------
-- --
-- LABELS --
-- --
-----------------------------------------------------------------------------

labels["non-lemma forms"] = {
description = "{{{langname}}} inflected forms of other [[Wiktionary:Lemmas|lemmas]], categorized by their part of speech.",
umbrella_parents = "Fundamental",
parents = {{name = "{{{langcat}}}", raw = true}},
}

labels["active participle forms"] = {
description = "{{{langname}}} active participles that are inflected to display grammatical relations other than the main form.",
parents = {"participle forms", {name = "active participles", sort = "**"}},
}

labels["active participles"] = {
description = "{{{langname}}} participles that express an agent actively performing an action.",
parents = {"participles"},
}

labels["active adjectival participles"] = {
description = "{{{langname}}} participles that function as adjectives and express an agent actively performing an action.",
parents = {"participles", "adjectives"},
}

labels["adjectival participles"] = {
description = "{{{langname}}} participles that function as adjectives.",
parents = {"participles", "adjectives"},
}

labels["adjective construct forms"] = {
description = "{{{langname}}} adjectives that are inflected to modify a noun in a genitive construction.",
parents = {{name = "adjective forms", sort = "construct"}},
}

labels["adjective definite forms"] = {
description = "{{{langname}}} adjectives that are inflected to give attributes to specific and identifiable nouns.",
parents = {{name = "adjective forms", sort = "definite forms"}},
}

labels["adjective dual forms"] = {
description = "{{{langname}}} adjectives that are inflected to be quantified as two.",
parents = {{name = "adjective forms", sort = "dual forms"}},
}

labels["adjective feminine forms"] = {
description = "{{{langname}}} adjectives that are inflected to give attributes to nouns associated to female beings.",
parents = {{name = "adjective forms", sort = "feminine forms"}},
}

labels["adjective forms"] = {
description = "{{{langname}}} adjectives that are inflected to display grammatical relations other than the main form.",
parents = {"non-lemma forms", {name = "adjectives", sort = "**"}},
}

labels["adjective indefinite forms"] = {
description = "{{{langname}}} adjectives that are inflected to give attributes to unspecified nouns.",
parents = {{name = "adjective forms", sort = "indefinite forms"}},
}

labels["adjective plural forms"] = {
description = "{{{langname}}} adjectives that are inflected to give attributes to nouns quantified as more than one (more than two in some languages with dual number).",
parents = {{name = "adjective forms", sort = "plural forms"}},
}

labels["broken noun plural forms"] = {
description = "{{{langname}}} nouns that are inflected for plural as in Arabic",
parents = {{name = "noun plural forms", sort = "plural forms"}},
}

labels["adverb forms"] = {
description = "{{{langname}}} adverbs that are inflected to display grammatical relations other than the main form.",
parents = {"non-lemma forms", {name = "adverbs", sort = "**"}},
}

labels["adverbial participles"] = {
description = "{{{langname}}} participles that function as adverbs.",
parents = {"participles", "adverbs"},
}

labels["agent participles"] = {
description = "{{{langname}}} participles that express an agent by who something is done.",
parents = {"participles"},
}

labels["anterior adverbial participles"] = {
description = "{{{langname}}} participles that function as adverbs and express an action completed before the one expressed by the primary verb.",
parents = {"participles", "adverbs"},
}

labels["article forms"] = {
description = "{{{langname}}} articles that are inflected to display grammatical relations other than the main form.",
parents = {"determiner forms", {name = "articles", sort = "**"}},
}

labels["circumfix forms"] = {
description = "{{{langname}}} circumfixes that are inflected to express grammatical relations other than the main form.",
parents = {"non-lemma forms", {name = "circumfixes", sort = "**"}},
}

labels["classifier forms"] = {
description = "{{{langname}}} classifiers that are inflected to express grammatical relations other than the main form.",
parents = {"classifiers"},
}

labels["classifier singular forms"] = {
description = "{{{langname}}} classifiers that are inflected for singular number.",
parents = {"classifier forms"},
}

labels["collective plurals"] = {
description = "{{{langname}}} nominal plural forms with specifically collective semantics.",
parents = {"noun forms"},
}

labels["comparative adjective forms"] = {
description = "{{{langname}}} comparative adjectives that are inflected to display grammatical relations other than the main form.",
parents = {"comparative adjectives"},
}

labels["comparative adjectives"] = {
description = "{{{langname}}} adjectives that express attributes in a relatively higher degree, or serve to set apart one thing from another.",
parents = {"adjective forms"},
}

labels["comparative adverb forms"] = {
description = "{{{langname}}} comparative adverbs that are inflected to display grammatical relations other than the main form.",
parents = {"comparative adverbs"},
}

labels["comparative adverbs"] = {
description = "{{{langname}}} adverbs that express attributes in a relatively higher degree, or serve to set apart one thing from another.",
parents = {"adverb forms"},
}

labels["conjunction forms"] = {
description = "{{{langname}}} conjunctions that are inflected to display grammatical relations other than the main form.",
parents = {"non-lemma forms", {name = "conjunctions", sort = "**"}},
}

labels["contemporary adverbial participles"] = {
description = "{{{langname}}} participles that function as adverbs and express an action occuring simultaneously with the one expressed by the primary verb.",
parents = {"participles", "adverbs"},
}

labels["converbs"] = {
description = "{{{langname}}} verb forms that build clauses which function as adverbials.",
parents = {"verb forms"},
}

labels["determiner comparative forms"] = {
description = "{{{langname}}} determiners that are inflected to display relative degrees of given qualities between nouns.",
parents = {{name = "determiner forms", sort = "comparative forms"}},
}

labels["determiner forms"] = {
description = "{{{langname}}} determiners that are inflected to display grammatical relations other than the main form.",
parents = {"non-lemma forms", {name = "determiners", sort = "**"}},
}

labels["diminutive gerunds"] = {
description = "{{{langname}}} diminutives of gerunds.",
parents = {"verb forms"},
}

labels["equative adjective forms"] = {
description = "{{{langname}}} equative adjectives that are inflected to display grammatical relations other than the main form.",
parents = {"equative adjectives"},
}

labels["equative adjectives"] = {
description = "{{{langname}}} adjectives that express similar degrees of given qualities between nouns, i.e. '''A''' is as ''(insert adjective)'' as '''B'''.",
parents = {"adjective forms"},
}

labels["equative adverb forms"] = {
description = "{{{langname}}} equative adverbs that are inflected to display grammatical relations other than the main form.",
parents = {"equative adverbs"},
}

labels["equative adverbs"] = {
description = "{{{langname}}} adverbs that express similar degrees of given qualities between verbs, i.e. '''A''' as ''(insert adverb)'' as '''B'''.",
parents = {"adverb forms"},
}

labels["exaggerated adjective forms"] = {
description = "{{{langname}}} exaggerated adjectives that are inflected to display grammatical relations other than the main form.",
parents = {"exaggerated adjectives"},
}

labels["exaggerated adjectives"] = {
description = "{{{langname}}} adjectives that express attributes in an even more magnified degree than the superlative forms.",
parents = {"adjective forms"},
}

labels["excessive adjective forms"] = {
description = "{{{langname}}} exaggerated adjectives that are inflected to display grammatical relations other than the main form.",
parents = {"excessive adjectives"},
}

labels["excessive adjectives"] = {
description = "{{{langname}}} adjectives that express attributes in an excessive degree.",
parents = {"adjective forms"},
}

labels["excessive adverbs"] = {
description = "{{{langname}}} adverbs that express attributes in an excessive degree.",
parents = {"adverb forms"},
}

labels["extended adjective forms"] = {
parents = {"adjective forms"},
}

labels["future active participles"] = {
description = "{{{langname}}} participles that express an agent actively performing an action in future time.",
parents = {"participles"},
}

labels["future participles"] = {
description = "{{{langname}}} participles that indicate future events.",
parents = {"participles"},
}

labels["future passive participles"] = {
description = "{{{langname}}} participles that express a patient having an action performed on it in future time.",
parents = {"participles"},
}

local function gerund_description(data)
local default_text = "{{{langname}}} verbs that are conjugated to indicate ongoing events at unspecified moments."
if not data.lang then
-- This happens e.g. in [[:Category:Gerunds by language]].
return default_text
else
local langcode = data.lang:getCode()
if langcode == "sq" or langcode == "kmr" or langcode == "liv" or data.lang:inFamily("gem", "itc") then
return "{{{langname}}} forms that generally act as an action noun for the verb that they are formed from."
elseif langcode == "sa" or langcode == "pi" then
return "{{{langname}}} verb forms used in a clause to indicate a prior action by the subject of the sentence."
else
return default_text
end
end
end

labels["gerunds"] = {
description = gerund_description,
additional = "{{small|[Edit function gerund_description() in [[Module:category tree/poscatboiler/data/non-lemma forms]] to change this description.]}}",
parents = {"verb forms"},
}

labels["imperfect participles"] = {
description = "{{{langname}}} participles that express an ongoing or continuous action.",
parents = {"participles"},
}

labels["infinitive forms"] = {
description = "{{{langname}}} infinitives that are conjugated to express grammatical relations other than the main form.",
parents = {"infinitives"},
}

labels["infinitives"] = {
description = "{{{langname}}} non-finite verb forms of various kinds.",
parents = {"verb forms"},
}

labels["intensive adjectives"] = {
description = "{{{langname}}} adjectives that are derived from a base word to express a stronger concept than the base word.",
parents = {"adjective forms"},
}

labels["interjection forms"] = {
description = "{{{langname}}} interjections that are inflected to display grammatical relations other than the main form.",
parents = {"non-lemma forms", {name = "interjections", sort = "**"}},
}

labels["manuscript forms"] = {
description = "{{{langname}}} words as they appear in original manuscripts.",
parents = {"non-lemma forms"},
}

labels["mutated forms"] = {
description = "{{{langname}}} terms whose initial consonant is mutated due to the effect of the preceding word.",
parents = {"non-lemma forms"},
}

local inflected_pos_for_mutation = {
"adjective",
"adverb",
"determiner",
"interjection",
"noun",
"numeral",
"participle",
"particle",
"prefix",
"preposition",
"pronoun",
"proper noun",
"verb",
}

for _, pos in ipairs(inflected_pos_for_mutation) do
local plpos = require("Module:string utilities").pluralize(pos)
labels["mutated " .. plpos] = {
description = "{{{langname}}} " .. plpos .. " whose initial consonant is mutated due to the effect of the preceding word.",
parents = {pos .. " forms", {name = "mutated forms", sort = pos}},
}
end

local mutation_types = {
-- FIXME, we should add these terms to [[Appendix:Glossary]] and link to them.
["eclipsed"] = "[[Appendix:Irish mutations#Eclipsis|eclipsis]]",
["lenited"] = "[[Appendix:Irish mutations#Lenition|lenition]]",
["h-prothesized"] = "[[Wiktionary:h-prothesis|h-prothesis]]",
["t-prothesized"] = "[[Wiktionary:t-prothesis|t-prothesis]]",
["aspirate-mutation"] = "[[Wiktionary:aspirate mutation|aspirate mutation]]",
["hard-mutation"] = "[[Wiktionary:hard mutation|hard mutation]]",
["mixed-mutation"] = "[[Wiktionary:mixed mutation|mixed mutation]]",
["nasal-mutation"] = "[[Wiktionary:nasal mutation|nasal mutation]]",
["soft-mutation"] = "[[Wiktionary:soft mutation|soft mutation]]",
}

for muttype, desc in pairs(mutation_types) do
labels[muttype .. " forms"] = {
description = "{{{langname}}} terms whose initial consonant is mutated through " .. desc .. ", due to the effect of the preceding word.",
parents = {"mutated forms"},
}
end

labels["negative participles"] = {
description = "{{{langname}}} participles that express lack of an action being performed.",
parents = {"participles"},
}

labels["nominal participles"] = {
description = "{{{langname}}} participles that function as nouns.",
parents = {"participles", "nouns"},
}

labels["noun construct forms"] = {
description = "{{{langname}}} nouns that are inflected to modify a noun in a genitive construction.",
parents = {{name = "noun forms", sort = "construct"}},
}

labels["noun definite forms"] = {
description = "{{{langname}}} nouns that are inflected to designate an identified object.",
parents = {{name = "noun forms", sort = "definite"}},
}

labels["noun dual forms"] = {
description = "{{{langname}}} nouns that are inflected to be quantified as two.",
parents = {{name = "noun forms", sort = "dual"}},
}

labels["noun feminine forms"] = {
description = "{{{langname}}} nouns that are inflected to be associated to female beings.",
parents = {{name = "noun forms", sort = "feminine"}},
}

labels["noun forms"] = {
description = "{{{langname}}} nouns that are inflected to display grammatical relations other than the main form.",
parents = {"non-lemma forms", {name = "nouns", sort = "**"}},
}

labels["noun indefinite forms"] = {
description = "{{{langname}}} nouns that are inflected to designate an unidentified object.",
parents = {{name = "noun forms", sort = "indefinite"}},
}

labels["noun masculine forms"] = {
description = "{{{langname}}} nouns that are inflected to be associated to male beings.",
parents = {{name = "noun forms", sort = "masculine"}},
}

labels["noun plural forms"] = {
description = "{{{langname}}} nouns that are inflected to be quantified as more than one (more than two in some languages with dual number).",
parents = {{name = "noun forms", sort = "plural"}},
}

labels["noun paucal forms"] = {
description = "{{{langname}}} nouns that are inflected to be quantified as between two (or three in some languages with dual number) and ten.",
parents = {{name = "noun forms", sort = "paucal"}},
}

labels["noun possessive forms"] = {
description = "{{{langname}}} nouns that are inflected to indicate possession.",
parents = {{name = "noun forms", sort = "possessive"}},
}

labels["numeral forms"] = {
description = "{{{langname}}} numerals that are inflected to display grammatical relations other than the main form.",
parents = {"non-lemma forms", {name = "numerals", sort = "**"}},
}

labels["participle forms"] = {
description = "{{{langname}}} participles that are inflected to display grammatical relations other than the main form.",
parents = {"non-lemma forms", {name = "participles", sort = "**"}},
}

labels["participles"] = {
description = "{{{langname}}} verbs not fully conjugated, usually to be used in compound conjugations.",
parents = {"verb forms"},
}

labels["particle forms"] = {
description = "{{{langname}}} particles that are inflected to display grammatical relations other than the main form.",
parents = {"non-lemma forms", {name = "particles", sort = "**"}},
}

labels["passive participles"] = {
description = "{{{langname}}} participles that express a patient having an action performed on it.",
parents = {"participles"},
}

labels["passive adjectival participles"] = {
description = "{{{langname}}} participles that function as adjectives and express a patient having an action performed on it.",
parents = {"participles", "adjectives"},
}

labels["past active aorist participles"] = {
description = "{{{langname}}} participles that express completed events in past time.",
parents = {"participles"},
}

labels["past active imperfect participles"] = {
description = "{{{langname}}} participles that express ongoing events in past time.",
parents = {"participles"},
}

labels["past active participles"] = {
description = "{{{langname}}} participles that express an agent actively performing an action in past time.",
parents = {"participles"},
}

labels["past adverbial participles"] = {
description = "{{{langname}}} participles that function as adverbs and express actions in past time.",
parents = {"adverbial participles", "adverbs"},
}

labels["past participle forms"] = {
description = "{{{langname}}} past participles that are inflected to display grammatical relations other than the main form.",
parents = {"participle forms", {name = "past participles", sort = "**"}},
}

labels["past participles"] = {
description = "{{{langname}}} participles that express actions in past time.",
parents = {"participles"},
}

labels["past passive participles"] = {
description = "{{{langname}}} participles that express a patient having an action performed on it in past time.",
parents = {"participles"},
}

labels["perfect participles"] = {
description = "{{{langname}}} participles that express having completed or undergone an action.",
parents = {"participles"},
}

labels["prefix forms"] = {
description = "{{{langname}}} prefixes that are inflected to express grammatical relations other than the main form.",
parents = {"non-lemma forms", {name = "prefixes", sort = "**"}},
}

labels["prepositional pronouns"] = {
description = "{{{langname}}} pronouns that are combined with a preposition.",
umbrella_parents = "Lemmas subcategories by language",
parents = {"pronoun forms", {name = "prepositions", sort = "pronouns"}},
}

labels["proper noun forms"] = {
description = "{{{langname}}} proper nouns that are inflected to display grammatical relations other than the main form.",
parents = {"non-lemma forms", {name = "proper nouns", sort = "**"}},
}

labels["postposition forms"] = {
description = "{{{langname}}} postpositions that are inflected to display grammatical relations other than the main form.",
parents = {"non-lemma forms", {name = "postpositions", sort = "**"}},
}

labels["preposition forms"] = {
description = "{{{langname}}} prepositions that are inflected to display grammatical relations other than the main form.",
parents = {"non-lemma forms", {name = "prepositions", sort = "**"}},
}

labels["present active participles"] = {
description = "{{{langname}}} participles that express an agent actively performing an action in present time.",
parents = {"participles"},
}

labels["present adverbial participles"] = {
description = "{{{langname}}} participles that function as adverbs and express actions in present time.",
parents = {"adverbial participles", "adverbs"},
}

labels["present middle participles"] = {
description = "{{{langname}}} participles that express an agent performing an action in present time in middle voice.",
parents = {"participles"},
}

labels["present participle forms"] = {
description = "{{{langname}}} present participles that are inflected to display grammatical relations other than the main form.",
parents = {"participle forms", {name = "present participles", sort = "**"}},
}

labels["present participles"] = {
description = "{{{langname}}} participles that express actions occurring in the present time.",
parents = {"participles"},
}

labels["present passive participles"] = {
description = "{{{langname}}} participles that express a patient having an action performed on it in present time.",
parents = {"participles"},
}

labels["pronoun forms"] = {
description = "{{{langname}}} pronouns that are inflected to display grammatical relations other than the main form.",
parents = {"non-lemma forms", {name = "pronouns", sort = "**"}},
}

labels["pronoun possessive forms"] = {
description = "{{{langname}}} pronouns that are inflected to indicate possession.",
parents = {{name = "pronoun forms", sort = "possessive"}},
}

labels["pronunciation variants"] = {
description = "{{{langname}}} words that have alternative pronunciation-based spellings.",
parents = {"non-lemma forms"},
}

labels["proper noun plural forms"] = {
description = "{{{langname}}} proper nouns that are inflected to be quantified as more than one (more than two in some languages with dual number).",
parents = {{name = "proper noun forms", sort = "plural"}},
}

labels["singulatives"] = {
description = "{{{langname}}} plural nouns that are inflected for singular number.",
parents = {"noun forms"},
}

labels["suffix forms"] = {
description = "{{{langname}}} suffixes that are inflected to express grammatical relations other than the main form.",
parents = {"non-lemma forms", {name = "suffixes", sort = "**"}},
}

for _, pos in ipairs { "adjective", "adverb", "determiner" } do
local plpos = pos .. "s"
labels["superlative " .. pos .. " forms"] = {
description = "{{{langname}}} superlative " .. plpos .. " that are inflected to display grammatical relations other than the main form.",
parents = {"superlative " .. plpos},
}

labels["superlative " .. plpos] = {
description = "{{{langname}}} " .. plpos .. " that express attributes in their highest possible degrees.",
parents = {pos .. " forms"},
}
end

labels["verb causative forms"] = {
description = "{{{langname}}} verbs that are conjugated to express actions caused by external conditions.",
parents = {{name = "verb forms", sort = "causative"}},
}

labels["verb forms"] = {
description = "{{{langname}}} verbs that are conjugated to display grammatical relations other than the main form.",
parents = {"non-lemma forms", {name = "verbs", sort = "**"}},
}

labels["verb irregular forms"] = {
description = "{{{langname}}} verb forms that don't follow standard patterns of conjugation.",
parents = {{name = "verb forms", sort = "irregular"}},
}

labels["verb negative forms"] = {
description = "{{{langname}}} verbs that are conjugated to express negation.",
parents = {{name = "verb forms", sort = "negative"}},
}

labels["verb passive forms"] = {
description = "{{{langname}}} verbs that are conjugated to direct the action to the grammatical subject, by means of passive voice.",
parents = {{name = "verb forms", sort = "passive"}},
}

labels["verb simple past forms"] = {
description = "{{{langname}}} verbs that are conjugated to indicate events before the current moment.",
parents = {{name = "verb forms", sort = "simple past"}},
}

local labels2 = {}

-- Add "reconstructed" subcategories; add 'umbrella_parents' key if not
-- already present.
for key, data in pairs(labels) do
labels2[key] = data
if not data.umbrella_parents then
data.umbrella_parents = "Non-lemma forms subcategories by language"
end
labels2["reconstructed " .. key] = {
description = "{{{langname}}} " .. key .. " that have been linguistically [[Wiktionary:Reconstructed terms|reconstructed]].",
umbrella_parents = "Non-lemma forms subcategories by language",
parents = {key, {name = "reconstructed terms", sort = key}}
}
end

-----------------------------------------------------------------------------
-- --
-- RAW CATEGORIES --
-- --
-----------------------------------------------------------------------------

raw_categories["Non-lemma forms subcategories by language"] = {
description = "Umbrella categories covering topics related to non-lemma forms.",
additional = "{{{umbrella_meta_msg}}}",
parents = {
"Umbrella metacategories",
{name = "non-lemma forms", is_label = true, sort = " "},
},
}

return {LABELS = labels2, RAW_CATEGORIES = raw_categories}

Module:Category tree/poscatboiler/data/names

Jsrs701 — Fri, 10 Apr 2026 07:25:54 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data/names by file upload (1 revision)

New page

local labels = {}
local raw_categories = {}
local handlers = {}

-----------------------------------------------------------------------------
-- --
-- LABELS --
-- --
-----------------------------------------------------------------------------

labels["names"] = {
description = "{{{langname}}} terms that are used to refer to specific individuals or groups. Place names, demonyms and other kinds of names can be found in [[:Category:Names]].",
umbrella_parents = {name = "terms by semantic function", is_label = true, sort = " "},
parents = {"terms by semantic function", "proper nouns"},
}

labels["augmentatives of female given names"] = {
description = "{{{langname}}} augmentative names given to female individuals.",
breadcrumb = "augmentative",
parents = {"female given names", "augmentative nouns"},
}

labels["augmentatives of male given names"] = {
description = "{{{langname}}} augmentative names given to male individuals.",
breadcrumb = "augmentative",
parents = {"male given names", "augmentative nouns"},
}

labels["augmentatives of unisex given names"] = {
description = "{{{langname}}} augmentative names given either to male or to female individuals.",
breadcrumb = "augmentative",
parents = {"unisex given names", "augmentative nouns"},
}

labels["common-gender surnames"] = {
description = "{{{langname}}} names shared by both male and female family members, in languages that distinguish male and female surnames.",
breadcrumb = "common-gender",
parents = {"surnames"},
}

labels["diminutives of female given names"] = {
description = "{{{langname}}} diminutive names given to female individuals.",
breadcrumb = "diminutives",
parents = {"female given names", "diminutive nouns"},
}

labels["diminutives of male given names"] = {
description = "{{{langname}}} diminutive names given to male individuals.",
breadcrumb = "diminutives",
parents = {"male given names", "diminutive nouns"},
}

labels["diminutives of unisex given names"] = {
description = "{{{langname}}} diminutive names given either to male or to female individuals.",
breadcrumb = "diminutives",
parents = {"unisex given names", "diminutive nouns"},
}

labels["female given names"] = {
description = "{{{langname}}} names given to female individuals.",
breadcrumb = "female",
parents = {"given names"},
}

labels["female skin names"] = {
description = "{{{langname}}} skin names given to female individuals.",
breadcrumb = "female",
parents = {"skin names"},
}

labels["female surnames"] = {
description = "{{{langname}}} names shared by female family members.",
breadcrumb = "female",
parents = {"surnames"},
}

labels["given names"] = {
description = "{{{langname}}} names given to individuals.",
parents = {"names"},
}

labels["male given names"] = {
description = "{{{langname}}} names given to male individuals.",
breadcrumb = "male",
parents = {"given names"},
}

labels["male skin names"] = {
description = "{{{langname}}} skin names given to male individuals.",
breadcrumb = "male",
parents = {"skin names"},
}

labels["male surnames"] = {
description = "{{{langname}}} names shared by male family members.",
breadcrumb = "male",
parents = {"surnames"},
}

labels["matronymics"] = {
description = "{{{langname}}} names indicating a person's mother, grandmother or earlier female ancestor.",
parents = {"names"},
}

labels["nomina gentilia"] = {
description = "A Roman [[nomen gentile]] was the \"[[family name]]\" in the [[w:Roman naming convention|convential Roman name]].",
parents = {"names"},
}

labels["patronymics"] = {
description = "{{{langname}}} names indicating a person's father, grandfather or earlier male ancestor.",
parents = {"names"},
}

labels["skin names"] = {
description = "{{{langname}}} terms given at birth that are used to refer to individuals from specific marital classes.",
parents = {"proper nouns", "names"},
}

labels["surnames"] = {
description = "{{{langname}}} names shared by family members.",
parents = {"names"},
}

labels["unisex given names"] = {
description = "{{{langname}}} names given either to male or to female individuals.",
breadcrumb = "unisex",
parents = {"given names"},
}

labels["unisex skin names"] = {
description = "{{{langname}}} skin names given either to male or to female individuals.",
breadcrumb = "unisex",
parents = {"skin names"},
}

labels["exonyms"] = {
description = "{{{langname}}} [[exonym]]s, i.e. terms for toponyms whose name in {{{langname}}} is different from the name in the source language.",
parents = {"names"},
}

labels["renderings of foreign personal names"] = {
description = "{{{langname}}} transliterations, respellings or other renderings of foreign personal names.",
parents = {"names"},
}

-- Add 'umbrella_parents' key if not already present.
for key, data in pairs(labels) do
if not data.umbrella_parents then
data.umbrella_parents = "Names subcategories by language"
end
end

-----------------------------------------------------------------------------
-- --
-- RAW CATEGORIES --
-- --
-----------------------------------------------------------------------------

raw_categories["Names subcategories by language"] = {
description = "Umbrella categories covering topics related to names.",
additional = "{{{umbrella_meta_msg}}}",
parents = {
"Umbrella metacategories",
{name = "names", is_label = true, sort = " "},
},
}

-----------------------------------------------------------------------------
-- --
-- HANDLERS --
-- --
-----------------------------------------------------------------------------

local function source_name_to_source(nametype, source_name)
local special_sources
if nametype:find("given names") then
special_sources = require("Module:table").listToSet {
"surnames", "place names", "coinages", "the Bible", "month names"
}
elseif nametype:find("surnames") then
special_sources = require("Module:table").listToSet {
"given names", "place names", "occupations", "patronymics", "matronymics",
"common nouns", "nicknames", "ethnonyms"
}
else
special_sources = {}
end
if special_sources[source_name] then
return source_name
else
return require("Module:languages").getByCanonicalName(source_name, nil,
"allow etym langs", "allow families")
end
end

local function get_source_text(source)
if type(source) == "table" then
return source:getDisplayForm()
else
return source
end
end

local function get_description(lang, nametype, source)
local origintext, addltext
if source == "surnames" then
origintext = "transferred from surnames"
elseif source == "given names" then
origintext = "transferred from given names"
elseif source == "nicknames" then
origintext = "transferred from nicknames"
elseif source == "place names" then
origintext = "transferred from place names"
addltext = " For place names that are also surnames, see " .. (
lang and "[[:Category:{{{langname}}} " .. nametype .. " from surnames]]" or
"[[:Category:" .. mw.getContentLanguage():ucfirst(nametype) .. " from surnames by language]]"
) .. "."
elseif source == "common nouns" then
origintext = "transferred from common nouns"
elseif source == "month names" then
origintext = "transferred from month names"
elseif source == "coinages" then
origintext = "originating as coinages"
addltext = " These are names of artificial origin, names based on fictional characters, combinations of two words or names or backward spellings. Names of uncertain origin can also be placed here if there is a strong suspicion that they are coinages."
elseif source == "occupations" then
origintext = "originating as occupations"
elseif source == "patronymics" then
origintext = "originating as patronymics"
elseif source == "matronymics" then
origintext = "originating as matronymics"
elseif source == "ethnonyms" then
origintext = "originating as ethnonyms"
elseif source == "the Bible" then
-- Hack esp. for Hawaiian names. We should consider changing them to
-- have the source as Biblical Hebrew and mention the derivation from
-- the Bible some other way.
origintext = "originating from the Bible"
elseif type(source) == "string" then
error("Internal error: Unrecognized string source \"" .. source .. "\", should be special-cased")
else
origintext = "of " .. source:makeCategoryLink() .. " origin"
if lang and source:getCode() == lang:getCode() then
addltext = " These are names derived from common nouns, local mythology, etc."
end
end
local introtext
if lang then
introtext = "{{{langname}}} "
else
introtext = "Categories with "
end
return introtext .. nametype .. " " .. origintext ..
". (This includes names derived at an older stage of the language.)" .. (addltext or "")
end

-- If one of the following families occurs in any of the ancestral families
-- of a given language, use it instead of the three-letter parent
-- (or immediate parent if no three-letter parent).
local high_level_families = require("Module:table").listToSet {
-- Indo-European
"gem", -- Germanic (for gme, gmq, gmw)
"inc", -- Indic (for e.g. pra = Prakrit)
"ine-ana", -- Anatolian (don't keep going to ine)
"ine-toc", -- Tocharian (don't keep going to ine)
"ira", -- Iranian (for e.g. xme = Median, xsc = Scythian)
"sla", -- Slavic (for zle, zls, zlw)
-- Other
"ath", -- Athabaskan (for e.g. apa = Apachean)
"poz", -- Malayo-Polynesian (for e.g. pqe = Eastern Malayo-Polynesian)
"cau-nwc", -- Northwest Caucasian
"cau-nec", -- Northeast Caucasian
}

local function find_high_level_family(lang)
local family = lang:getFamily()
-- (1) If no family, return nil (e.g. for Pictish).
if not family then
return nil
end
-- (2) See if any ancestor family is in `high_level_families`.
-- if so, return it.
local high_level_family = family
while high_level_family do
local high_level_code = high_level_family:getCode()
if high_level_code == "qfa-not" then
-- "not a family"; its own parent, causing an infinite loop.
-- Break rather than return so we get categories like
-- [[Category:English female given names from sign languages]] and
-- [[Category:English female given names from constructed languages]].
break
end
if high_level_families[high_level_code] then
return high_level_family
end
high_level_family = high_level_family:getFamily()
end
-- (3) If the family is of the form 'FOO-BAR', see if 'FOO' is a family.
-- If so, return it.
local basic_family = family:getCode():match("^(.-)%-.*$")
if basic_family then
basic_family = require("Module:families").getByCode(basic_family)
if basic_family then
return basic_family
end
end
-- (4) Fall back to just the family itself.
return family
end

local function match_gendered_nametype(nametype)
local gender, label = nametype:match("^(f?e?male) (given names)$")
if not gender then
gender, label = nametype:match("^(unisex) (given names)$")
end
if gender then
return gender, label
end
end

local function get_parents(lang, nametype, source)
local parents = {}

if lang then
table.insert(parents, {name = nametype, sort = get_source_text(source)})
if type(source) == "table" then
table.insert(parents, {name = "terms derived from " .. source:getDisplayForm(), sort = " "})
-- If the source is a regular language, put it in a parent category for the high-level language family, e.g. for
-- "Russian female given names from German", put it in a parent category "Russian female given names from Germanic languages"
-- (skipping over West Germanic languages).
--
-- If the source is an etymology language, put it in a parent category for the parent full language, e.g. for
-- "French male given names from Gascon", put it in a parent category "French male given names from Occitan".
--
-- If the source is a family, put it in a parent category for the parent family.
if source:hasType("family") then
local parent_family = source:getFamily()
if parent_family and parent_family:getCode() ~= "qfa-not" then
table.insert(parents, {
name = nametype .. " from " .. parent_family:getDisplayForm(),
sort = source:getCanonicalName()
})
end
elseif source:hasType("etymology-only") then
local source_parent = source:getFull()
if source_parent and source_parent:getCode() ~= "und" then
table.insert(parents, {
name = nametype .. " from " .. source_parent:getDisplayForm(),
sort = source:getCanonicalName()
})
end
else
local high_level_family = find_high_level_family(source)
if high_level_family then -- may not exist, e.g. for Pictish
table.insert(parents,
{name = nametype .. " from " .. high_level_family:getDisplayForm(),
sort = source:getCanonicalName()
})
end
end
end

local gender, label = match_gendered_nametype(nametype)
if gender then
table.insert(parents, {name = label .. " from " .. get_source_text(source), sort = gender})
end
else
local gender, label = match_gendered_nametype(nametype)
if gender then
table.insert(parents, {name = label .. " from " .. get_source_text(source), is_label = true, sort = " "})
elseif type(source) == "table" then
-- FIXME! This is duplicated in [[Module:category tree/poscatboiler/data/terms by etymology]] in the
-- handler for umbrella categories 'Terms derived from SOURCE'.
local first_umbrella_parent =
source:hasType("family") and {name = source:getCategoryName(), raw = true, sort = " "} or
source:hasType("etymology-only") and {name = "Category:" .. source:getCategoryName(), sort = nametype} or
{name = source:getCategoryName(), raw = true, sort = nametype}
table.insert(parents, first_umbrella_parent)
end
table.insert(parents, "Names subcategories by language")
end

return parents
end

table.insert(handlers, function(data)
local nametype, source_name = data.label:match("^(.*names) from (.+)$")
if nametype then
local m_table = require("Module:table")
local personal_name_types = m_table.listToSet(require("Module:names").personal_name_types)
if not personal_name_types[nametype] then
return nil
end
local source = source_name_to_source(nametype, source_name)
if not source then
return nil
end
return {
description = get_description(data.lang, nametype, source),
breadcrumb = "from " .. get_source_text(source),
parents = get_parents(data.lang, nametype, source),
umbrella = {
description = get_description(nil, nametype, source),
parents = get_parents(nil, nametype, source),
},
}
end
end)

-- Handler for e.g. 'English renderings of Russian male given names'.
table.insert(handlers, function(data)
local label = data.label:match("^renderings of (.*)$")
if label then
local personal_name_types = require("Module:names").personal_name_types
for _, nametype in ipairs(personal_name_types) do
local sourcename = label:match("^(.+) " .. nametype .. "$")

if sourcename then
local source = require("Module:languages").getByCanonicalName(sourcename, nil, "allow etym")
if source then
return {
description = "Transliterations, respellings or other renderings of " .. source:makeCategoryLink() .. " " .. nametype .. " into {{{langlink}}}.",
lang = data.lang,
breadcrumb = sourcename .. " " .. nametype,
parents = {
{ name = "renderings of foreign personal names", sort = sourcename },
{ name = nametype, lang = source:getCode(), sort = "{{{langname}}}" },
},
umbrella = {
description = "Transliterations, respellings or other renderings of " .. source:makeCategoryLink() .. " " .. nametype .. " into various languages.",
parents = {{name = "renderings of foreign personal names", is_label = true, sort = label}},
},
}
end
end
end
end
end)

return {LABELS = labels, RAW_CATEGORIES = raw_categories, HANDLERS = handlers}

Module:Category tree/poscatboiler/data/modules

Jsrs701 — Fri, 10 Apr 2026 07:25:53 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data/modules by file upload (1 revision)

New page

local labels = {}
local raw_categories = {}
local raw_handlers = {}

-----------------------------------------------------------------------------
-- --
-- LABELS --
-- --
-----------------------------------------------------------------------------

labels["modules"] = {
description = "{{{langname}}} [[Wiktionary:Modules|modules]], which contain Lua code to create and manage entries.",
umbrella = {
parents = {{name = "Modules", sort = " "}},
breadcrumb = "by language",
},
parents = {{name = "{{{langcat}}}", raw = true}},
}

labels["data modules"] = {
description = "{{{langname}}} [[Wiktionary:Modules|modules]] containing data used by other modules.",
umbrella = {
parents = {{name = "Data modules", sort = " "}},
breadcrumb = "by language",
},
parents = {"modules"},
}

labels["inflection modules"] = {
description = "{{{langname}}} [[Wiktionary:inflection|inflection]] [[Wiktionary:Modules|modules]], which contain Lua code for generating conjugation and declension tables.",
umbrella = {
parents = {{name = "Inflection modules", sort = " "}},
breadcrumb = "by language",
},
parents = {"modules"},
}

-----------------------------------------------------------------------------
-- --
-- RAW CATEGORIES --
-- --
-----------------------------------------------------------------------------

raw_categories["Modules"] = {
description = "This is a general holder category for modules.",
additional = "For more information on what modules are and how they work, see [[Wiktionary:Scribunto]]. For a complete list of all modules, see [[Special:PrefixIndex/Module:|here]].",
parents = {"Category:Wiktionary"},
}

raw_categories["Uncategorized modules"] = {
description = "Uncategorized modules.",
additional = "Modules are placed here by [[MediaWiki:Scribunto-doc-page-does-not-exist]]. The default documentation page, [[Template:documentation/preloadModule]], also adds this category.",
parents = { {name = "Modules", sort = " "} },
}

raw_categories["Module unit tests"] = {
description = "Unit tests for modules.",
parents = { {name = "Modules", sort = "1 test modules"} },
}

raw_categories["Appendix modules"] = {
description = "Modules with functions that generate content for or extract information from pages in the Appendix namespace.",
parents = { "Modules" },
}

raw_categories["Bot support modules"] = {
description = "Modules for supporting individual bot accounts.",
parents = { "Modules" },
}

raw_categories["Category modules"] = {
intro = "{{also|:Category:Category templates}}",
description = "Modules for adding categories to pages or generating the description and subcategories of category pages.",
parents = { "Modules" },
}

raw_categories["Data modules"] = {
description = "Modules that do not contain functions, but only export a table of data that is used by other modules. Modules that are in this category should be imported using <code>mw.loadData</code> rather than <code>require</code>.",
parents = { "Modules" },
}

raw_categories["Character insertion data modules"] = {
description = "Modules containing data for use by {{temp|chars}}.",
parents = { "Data modules" },
breadcrumb = "character insertion",
}

raw_categories["Debugging modules"] = {
description = "Modules used for debugging.",
additional = "Some should only be used in sandbox modules or when using the [[mw:Extension:TemplateSandbox|{{MediaWiki:Templatesandbox-editform-legend}}]] button in the edit page of modules and templates.",
parents = { "Lua metamodules", "Modules" },
}

raw_categories["Definition modules"] = {
description = "Modules that fuel templates that are used in [[Wiktionary:Glossary#definition line|definition lines]] of entries.",
parents = { "Modules" },
}

raw_categories["Deprecated modules"] = {
description = "Modules that should not be used, as their functions are performed by newer modules.",
parents = { "Modules", "Category:Wiktionary maintenance" },
}

raw_categories["Discussion modules"] = {
description = "Modules concerning discussion pages.",
parents = { "Modules" },
}

raw_categories["Display text-generating modules"] = {
description = "Modules that are used to generate display text.",
additional = "Display text determines what is shown to the reader. In some languages it must be normalized, due to common errors caused by confusable characters, or so as to ensure a consistent display format.",
parents = { "Modules" },
}

raw_categories["Documentation modules"] = {
description = "Modules for generating documentation pages.",
parents = { "Modules" },
}

raw_categories["Entry-generating modules"] = {
description = "Modules with functions that are used to generate new entries.",
parents = { "Modules" },
}

raw_categories["Entry name-generating modules"] = {
description = "Modules that are used to generate entry names.",
additional = "Entry names determine the page at which an entry is created, accounting for the removal of language-specified diacritics.",
parents = { "Modules" },
}

raw_categories["Etymology modules"] = {
description = "Modules that fuel templates that define the etymology of entries.",
parents = { "Modules" },
}

raw_categories["Form-of modules"] = {
description = "Modules that generate the definition line of non-lemma forms, e.g. verb forms and noun forms.",
parents = { "Definition modules", "Modules" },
}

raw_categories["General utility modules"] = {
description = "Modules that serve some sort of utility purpose in various entries but are used by multiple languages. Modules only used by one language should be at [[:Category:Utility modules]].",
parents = { "Modules" },
}

raw_categories["Headword-line modules"] = {
description = "Modules that support [[:Category:Headword-line templates by language|headword-line templates]] for a specific language.",
additional = "See also [[:Category:Headword-line templates]].",
parents = { "Modules" },
}

raw_categories["Inflection modules"] = {
description = "Modules used to support [[:Category:Inflection-table templates by language|inflection templates]] for a specific language.",
parents = { "Modules" },
}

raw_categories["Internal link modules"] = {
description = "Modules that are used in [[:Category:Internal link templates|internal link templates]].",
parents = { "General utility modules", "Modules" },
}

raw_categories["JSON-generating modules"] = {
description = "Modules with functions that generate data in JSON format.",
parents = { "Modules" },
}

raw_categories["Language and script modules"] = {
description = "Modules that process language and script codes and return data on them.",
parents = { "Modules" },
}

raw_categories["List modules"] = {
description = "Modules that generate lists and tables of entries.",
parents = { "Modules" },
}

raw_categories["Lua metamodules"] = {
description = "Modules that have exported functions that are only used by other modules: that is, cannot be called using {{temp|#invoke:}}.",
parents = { "Modules" },
}

raw_categories["Maintenance modules"] = {
description = "Modules that fuel templates used for maintaining entries, such as cleanup templates (e.g. {{temp|attention}}), deletion templates (e.g. {{temp|rfd}}) and verification templates (e.g. {{temp|rfv}}).",
parents = { "Modules" },
}

raw_categories["Pronunciation modules"] = {
description = "Modules that fuel templates that are used to create the language-specific pronunciation of entries.",
parents = { "Modules" },
}

raw_categories["Quotation and usage example modules"] = {
description = "Modules that fuel templates that are used to format quotations and usage examples.",
parents = { "Definition modules", "Modules" },
breadcrumb = "quotation and usage example",
}

raw_categories["Reference modules"] = {
description = "Modules that are used for [[:Category:Reference templates|reference templates]].",
parents = { "Modules" },
}

raw_categories["Sandbox modules"] = {
description = "Test versions of modules intended for production use.",
parents = { "Modules" },
}

raw_categories["Sortkey-generating modules"] = {
description = "Modules that are used to generate sortkeys.",
additional = "Sortkeys determine the order of entry names in categories.",
parents = { "Modules" },
}

raw_categories["Swadesh modules"] = {
description = "Modules containing [[Wiktionary:Swadesh list|Swadesh list]]s.",
parents = { "Modules" },
}

raw_categories["Template interface modules"] = {
description = "Modules whose purpose is to provide an interface between templates and the functions of a module.",
additional = "They are usually named <code>.../templates</code>, and the functions present within them usually all have only a \"frame\" parameter.",
parents = { "Modules" },
}

raw_categories["Tracking modules"] = {
description = "Modules that add tracking templates.",
parents = { "Modules" },
}

raw_categories["Transliteration modules"] = {
description = "Modules that automatically convert text in one script to another.",
additional = "Most of them convert non-Latin scripts to Latin (romanisation/romanization), and are used by templates or modules to generate transliteration of text that is tagged with a particular language. Each language's transliteration module is specified in its data table (for which, see the category {{catlink|Language data modules}}).",
parents = { "Modules" },
}

raw_categories["Unused modules"] = {
description = "Unused modules.",
parents = { "Modules" },
}

raw_categories["User sandbox modules"] = {
description = "Modules that are for personal use and testing by individual editors.",
additional = "These should all begin with <code>User:</code> followed by the user's name. If several sandbox modules are needed by a single user, subpages can be created. These modules should not be used in real Wiktionary content pages, as all content on those pages should be editable by anyone and, if necessary, edit protected.",
parents = { "Sandbox modules", "Modules" },
}

raw_categories["Utility modules"] = {
description = "Modules that deal with several utilities needed by a certain language.",
additional = "Usually their names end with -utilities or -common (preceded by the language code), although more specific utility modules that one language uses may reside here as well. If a utility is used by many languages, it should be in [[:Category:General utility modules]].",
parents = { "Modules" },
}

raw_categories["Vote modules"] = {
description = "Modules used to manage Wiktionary votes.",
parents = { "Modules" },
}

raw_categories["Wikitext parsing modules"] = {
description = "Modules that contain functions that grab the wikitext of a page and get information from it by performing string operations on it.",
parents = { "Modules" },
}

-----------------------------------------------------------------------------
-- --
-- RAW HANDLERS --
-- --
-----------------------------------------------------------------------------

for _, mod_type in ipairs { "Entry name-generating", "Sortkey-generating", "Transliteration" } do
table.insert(raw_handlers, function(data)
local count, languages = data.category:match(("^%s modules used by ([0-9]+) (languages?)$"):format(
-- need to escape the hyphen in 'Entry name-generating' and 'Sortkey-generating'
require("Module:pattern utilities").pattern_escape(mod_type)))
if count then
return {
description = data.category .. ".",
breadcrumb = "used by " .. count .. " " .. languages,
parents = {
{ name = mod_type .. " modules", sort = count },
},
}
end
end)
end

return {LABELS = labels, RAW_CATEGORIES = raw_categories, RAW_HANDLERS = raw_handlers}

Module:Category tree/poscatboiler/data/miscellaneous

Jsrs701 — Fri, 10 Apr 2026 07:25:53 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data/miscellaneous by file upload (1 revision)

New page

Module:Category tree/poscatboiler/data/lemmas

Jsrs701 — Fri, 10 Apr 2026 07:25:53 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data/lemmas by file upload (1 revision)

Show changes

Module:Category tree/poscatboiler/data/languages

Jsrs701 — Fri, 10 Apr 2026 07:25:52 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data/languages by file upload (1 revision)

New page

local raw_categories = {}
local raw_handlers = {}

local m_languages = require("Module:languages")
local m_sc_getByCode = require("Module:scripts").getByCode
local m_table = require("Module:table")

local Hang = m_sc_getByCode("Hang")
local Hani = m_sc_getByCode("Hani")
local Hira = m_sc_getByCode("Hira")
local Hrkt = m_sc_getByCode("Hrkt")
local Kana = m_sc_getByCode("Kana")

-- This handles language categories of the form e.g. [[Category:French language]] and
-- [[:Category:British Sign Language]] and regional variant categories of the form
-- e.g. [[Category:Regional French]].

-----------------------------------------------------------------------------
-- --
-- RAW CATEGORIES --
-- --
-----------------------------------------------------------------------------

raw_categories["Regionalisms"] = {
description = "Categories that group terms in regional varieties of various languages.",
additional = "{{{umbrella_msg}}}",
parents = {
"Fundamental",
},
}

raw_categories["All languages"] = {
intro = "{{sisterlinks|Category:Languages}}\n[[File:Languages world map-transparent background.svg|thumb|right|250px|Rough world map of language families]]",
description = "This category contains the categories for every language on Wiktionary.",
additional = "Not all languages that Wiktionary recognises may have a category here yet. There are many that have " ..
"not yet received any attention from editors, mainly because not all Wiktionary users know about every single " ..
"language. See [[Wiktionary:List of languages]] for a full list.",
parents = {
"Fundamental",
},
}

raw_categories["All extinct languages"] = {
description = "This category contains the categories for every {{wt|extinct language}} on Wiktionary.",
additional = "Do not confuse this category with [[:Category:Extinct languages]] which is for the names of extinct languages.",
parents = {
"All languages",
},
}

-----------------------------------------------------------------------------
-- --
-- RAW HANDLERS --
-- --
-----------------------------------------------------------------------------

local function makeCategoryLink(object)
return "[[:Category:" .. object:getCategoryName() .. "|" .. object:getCanonicalName() .. "]]"
end

local function ucfirst(text)
return mw.getContentLanguage():ucfirst(text)
end

local function linkbox(lang, setwiki, setwikt, setsister, entryname)
local wiktionarylinks = "''None.''"

local canonicalName = lang:getCanonicalName()
local wikimediaLanguages = lang:getWikimediaLanguages()
local nameWithLanguage = lang:getCategoryName("nocap")
local categoryName = lang:getCategoryName()
local wikipediaArticle = setwiki or lang:getWikipediaArticle()
setsister = setsister and ucfirst(setsister) or nil

if setwikt then
require "Module:debug".track "langcatboiler/setwikt"
if setwikt == "-" then
require "Module:debug".track "langcatboiler/setwikt/hyphen"
end
end

if setwikt ~= "-" and wikimediaLanguages and wikimediaLanguages[1] then
wiktionarylinks = {}

for _, wikimedialang in ipairs(wikimediaLanguages) do
table.insert(wiktionarylinks,
(wikimedialang:getCanonicalName() ~= canonicalName and "(''" .. wikimedialang:getCanonicalName() .. "'') " or "") ..
"'''[[:" .. wikimedialang:getCode() .. ":|" .. wikimedialang:getCode() .. ".wiktionary.org]]'''")
end

wiktionarylinks = table.concat(wiktionarylinks, "<br/>")
end

local plural = wikimediaLanguages[2] and "s" or ""

return table.concat{
[=[<div style="clear: right; border: solid #aaa 1px; margin: 1 1 1 1; background: #f9f9f9; width: 270px; padding: 5px; margin: 5px; text-align: left; float: right">
<div style="text-align: center; margin-bottom: 10px; margin-top: 5px">''']=], nameWithLanguage, [=['''</div>

{| style="font-size: 90%; background: #f9f9f9;"
|-
| style="vertical-align: middle; height: 35px" | [[File:Wikipedia-logo.png|35px|none|Wikipedia]]
|| ''Article about ]=], nameWithLanguage, [=[''
|-
| colspan="2" style="padding-left: 10px; border-bottom: 1px solid lightgray;" | ]=], (setwiki == "-" and "''None.''" or "'''[[" .. wikipediaArticle .. "]]'''"), [=[

|-
| style="vertical-align: middle; height: 35px" | [[File:Open book nae 02.svg|35px|none|Entry]]
|| ]=], nameWithLanguage, [=[ entry
|-
| colspan="2" style="padding-left: 10px;" | ''']=], require("Module:links").full_link({lang = m_languages.getByCode("en"), term = entryname or canonicalName}), [=['''
|}
</div>]=]
}
end

local function edit_link(title, text)
return '<span class="plainlinks">['
.. tostring(mw.uri.fullUrl(title, { action = "edit" }))
.. ' ' .. text .. ']</span>'
end

-- Should perhaps use wiki syntax.
local function infobox(lang)
local ret = {}

table.insert(ret, '<table class="wikitable language-category-info"')

if type(lang.getRawData) == "function" then
local raw_data = lang:getRawData()
if raw_data then
local replacements = {
[1] = "canonical-name",
[2] = "wikidata-item",
[3] = "family",
}
local function replacer(letter1, letter2)
return letter1:lower() .. "-" .. letter2:lower()
end
-- For each key in the language data modules, returns a descriptive
-- kebab-case version (containing ASCII lowercase words separated
-- by hyphens).
local function kebab_case(key)
key = replacements[key] or key
key = key:gsub("(%l)(%u)", replacer):gsub("(%l)_(%l)", replacer)
return key
end
local function html_attribute_encode(str)
str = mw.text.jsonEncode(str)
:gsub('"', """)
-- & in attributes is automatically escaped.
-- :gsub("&", "&")
:gsub("<", "<")
:gsub(">", ">")
return str
end
pcall(function ()
table.insert(ret, ' data-code="' .. lang:getCode() .. '"')
for k, v in m_table.sortedPairs(lang:getRawData()) do
table.insert(ret, " data-" .. kebab_case(k)
.. '="'
.. html_attribute_encode(v)
.. '"')
end
end)
end
end
table.insert(ret, '>\n')
table.insert(ret, '<tr class="language-category-data">\n<th colspan="2">'
.. edit_link("Module:" .. m_languages.getDataModuleName(lang:getCode()),
"Edit language data")
.. "</th>\n</tr>\n")
table.insert(ret, "<tr>\n<th>Canonical name</th><td>" .. lang:getCanonicalName() .. "</td>\n</tr>\n")

local otherNames = lang:getOtherNames(true)
if otherNames then
local names = {}

for _, name in ipairs(otherNames) do
table.insert(names, "<li>" .. name .. "</li>")
end

if #names > 0 then
table.insert(ret, "<tr>\n<th>Other names</th><td><ul>" .. table.concat(names, "\n") .. "</ul></td>\n</tr>\n")
end
end

local aliases = lang:getAliases()
if aliases then
local names = {}

for _, name in ipairs(aliases) do
table.insert(names, "<li>" .. name .. "</li>")
end

if #names > 0 then
table.insert(ret, "<tr>\n<th>Aliases</th><td><ul>" .. table.concat(names, "\n") .. "</ul></td>\n</tr>\n")
end
end

local varieties = lang:getVarieties()
if varieties then
local names = {}

for _, name in ipairs(varieties) do
if type(name) == "string" then
table.insert(names, "<li>" .. name .. "</li>")
else
assert(type(name) == "table")
local first_var
local subvars = {}
for i, var in ipairs(name) do
if i == 1 then
first_var = var
else
table.insert(subvars, "<li>" .. var .. "</li>")
end
end
if #subvars > 0 then
table.insert(names, "<li><dl><dt>" .. first_var .. "</dt>\n<dd><ul>" .. table.concat(subvars, "\n") .. "</ul></dd></dl></li>")
elseif first_var then
table.insert(names, "<li>" .. first_var .. "</li>")
end
end
end

if #names > 0 then
table.insert(ret, "<tr>\n<th>Varieties</th><td><ul>" .. table.concat(names, "\n") .. "</ul></td>\n</tr>\n")
end
end

table.insert(ret, "<tr>\n<th>[[Wiktionary:Languages|Language code]]</th><td><code>" .. lang:getCode() .. "</code></td>\n</tr>\n")
table.insert(ret, "<tr>\n<th>[[Wiktionary:Families|Language family]]</th>\n")

local fam = lang:getFamily()
local famCode = fam and fam:getCode()

if not fam then
table.insert(ret, "<td>unclassified</td>")
elseif famCode == "qfa-iso" then
table.insert(ret, "<td>[[:Category:Language isolates|language isolate]]</td>")
elseif famCode == "qfa-mix" then
table.insert(ret, "<td>[[:Category:Mixed languages|mixed language]]</td>")
elseif famCode == "sgn" then
table.insert(ret, "<td>[[:Category:Sign languages|sign language]]</td>")
elseif famCode == "crp" then
table.insert(ret, "<td>[[:Category:Creole or pidgin languages|creole or pidgin]]</td>")
elseif famCode == "art" then
table.insert(ret, "<td>[[:Category:Constructed languages|constructed language]]</td>")
else
table.insert(ret, "<td>" .. makeCategoryLink(fam) .. "</td>")
end

table.insert(ret, "\n</tr>\n<tr>\n<th>Ancestors</th>\n")

local ancestors, ancestorChain = lang:getAncestors(), lang:getAncestorChain()
if ancestors[2] then
local ancestorList = {}

for i, anc in ipairs(ancestors) do
ancestorList[i] = "<li>" .. makeCategoryLink(anc) .. "</li>"
end

table.insert(ret, "<td><ul>\n" .. table.concat(ancestorList, "\n") .. "</ul></td>\n")
elseif ancestorChain[1] then
table.insert(ret, "<td><ul>\n")

local chain = {}

for i, anc in ipairs(ancestorChain) do
chain[i] = "<li>" .. makeCategoryLink(anc) .. "</li>"
end

table.insert(ret, table.concat(chain, "\n<ul>\n"))

for _, _ in ipairs(chain) do
table.insert(ret, "</ul>")
end

table.insert(ret, "</td>\n")
else
table.insert(ret, "<td>unknown</td>\n")
end

table.insert(ret, "</tr>\n")

local scripts = lang:getScripts()

if scripts[1] then
local script_text = {}

local function makeScriptLine(sc)
local code = sc:getCode()
local url = tostring(mw.uri.fullUrl('Special:Search', {
search = 'contentmodel:css insource:"' .. code
.. '" insource:/\\.' .. code .. '/',
ns8 = '1'
}))
return makeCategoryLink(sc)
.. ' (<span class="plainlinks" title="Search for stylesheets referencing this script">[' .. url .. ' <code>' .. code .. '</code>]</span>)'
end

local function add_Hrkt(text)
table.insert(text, "<li>" .. makeScriptLine(Hrkt))
table.insert(text, "<ul>")
table.insert(text, "<li>" .. makeScriptLine(Hira) .. "</li>")
table.insert(text, "<li>" .. makeScriptLine(Kana) .. "</li>")
table.insert(text, "</ul>")
table.insert(text, "</li>")
end

for _, sc in ipairs(scripts) do
local text = {}
local code = sc:getCode()

if code == "Hrkt" then
add_Hrkt(text)
else
table.insert(text, "<li>" .. makeScriptLine(sc))
if code == "Jpan" then
table.insert(text, "<ul>")
table.insert(text, "<li>" .. makeScriptLine(Hani) .. "</li>")
add_Hrkt(text)
table.insert(text, "</ul>")
elseif code == "Kore" then
table.insert(text, "<ul>")
table.insert(text, "<li>" .. makeScriptLine(Hang) .. "</li>")
table.insert(text, "<li>" .. makeScriptLine(Hani) .. "</li>")
table.insert(text, "</ul>")
end
table.insert(text, "</li>")
end

table.insert(script_text, table.concat(text, "\n"))
end

table.insert(ret, "<tr>\n<th>[[Wiktionary:Scripts|Scripts]]</th>\n<td><ul>\n" .. table.concat(script_text, "\n") .. "</ul></td>\n</tr>\n")
else
table.insert(ret, "<tr>\n<th>[[Wiktionary:Scripts|Scripts]]</th>\n<td>not specified</td>\n</tr>\n")
end

local function add_module_info(raw_data, heading)
if raw_data then
local scripts = lang:getScriptCodes()
local module_info, n, add = {}, 0, false
if type(raw_data) == "string" then
table.insert(module_info,
("[[Module:%s]]"):format(raw_data))
add = true
elseif type(raw_data) == "table" and m_table.size(scripts) == 1 and type(raw_data[scripts[1]]) == "string" then
table.insert(module_info,
("[[Module:%s]]"):format(raw_data[scripts[1]]))
add = true
elseif type(raw_data) == "table" then
table.insert(module_info, "<ul>")
for script, data in m_table.sortedPairs(raw_data) do
local script_info
if m_sc_getByCode(script) then
if type(data) == "string" then
script_info = ("[[Module:%s]]</li>"):format(data)
else
n = n + 1
script_info = "(none)\n"
end
table.insert(module_info, ("<li><code>%s</code>: %s"):format(script, script_info))
end
end
table.insert(module_info, "</ul>")
if m_table.size(module_info) > 2 and n < (m_table.size(module_info) - 2) then add = true end
end

if add then
table.insert(ret, [=[
<tr>
<th>]=] .. heading .. [=[</th>
<td>]=] .. table.concat(module_info) .. [=[</td>
</tr>
]=])
end
end
end

add_module_info(lang._rawData.generate_forms, "Form-generating<br>module")
add_module_info(lang._rawData.translit, "[[Wiktionary:Transliteration and romanization|Transliteration<br>module]]")
add_module_info(lang._rawData.display_text, "Display text<br>module")
add_module_info(lang._rawData.entry_name, "Entry name<br>module")
add_module_info(lang._rawData.sort_key, "[[Wiktionary:sortkey|Sortkey]]<br>module")

local wikidataItem = lang:getWikidataItem()
if lang:getWikidataItem() and mw.wikibase then
local URL = mw.wikibase.getEntityUrl(wikidataItem)
local link
if URL then
link = '[' .. URL .. ' ' .. wikidataItem .. ']'
else
link = '<span class="error">Invalid Wikidata item: <code>' .. wikidataItem .. '</code></span>'
end
table.insert(ret, "<tr><th>Wikidata</th><td>" .. link .. "</td></tr>")
end

table.insert(ret, "</table>")

return table.concat(ret)
end

local function NavFrame(content, title)
return '<div class="NavFrame"><div class="NavHead">'
.. (title or '{{{title}}}') .. '</div>'
.. '<div class="NavContent" style="text-align: left;">'
.. content
.. '</div></div>'
end

local function get_description_intro_additional(lang, countries, extinct, setwiki, setwikt, setsister, entryname)
local nameWithLanguage = lang:getCategoryName("nocap")
if lang:getCode() == "und" then
local description =
"This is the main category of the '''" .. nameWithLanguage .. "''', represented in Wiktionary by the [[Wiktionary:Languages|code]] '''" .. lang:getCode() .. "'''. " ..
"This language contains terms in historical writing, whose meaning has not yet been determined by scholars."
return description, nil, nil
end

local canonicalName = lang:getCanonicalName()

local intro = linkbox(lang, setwiki, setwikt, setsister, entryname)

local the_prefix
if canonicalName:find(" Language$") then
the_prefix = ""
else
the_prefix = "the "
end
local description = "This is the main category of " .. the_prefix .. "'''" .. nameWithLanguage .. "'''."

local country_links = {}
for _, country in ipairs(countries) do
if country ~= "UNKNOWN" then
local country_without_the = country:match("^the (.*)$")
if country_without_the then
table.insert(country_links, "the [[" .. country_without_the .. "]]")
else
table.insert(country_links, "[[" .. country .. "]]")
end
end
end
local country_desc
if #country_links > 0 then
local country_link_text = m_table.serialCommaJoin(country_links)
if extinct then
country_desc = "It is an {{wt|extinct language}} that was formerly spoken in " .. country_link_text .. ".\n\n"
else
country_desc = "It is spoken in " .. country_link_text .. ".\n\n"
end
elseif extinct then
country_desc = "It is an {{wt|extinct language}}."
else
country_desc = ""
end

local add = country_desc .. "Information about " .. canonicalName .. ":\n\n" .. infobox(lang)

if lang:hasType("reconstructed") then
add = add .. "\n\n" ..
ucfirst(canonicalName) .. " is a reconstructed language. Its words and roots are not directly attested in any written works, but have been reconstructed through the ''comparative method'', " ..
"which finds regular similarities between languages that cannot be explained by coincidence or word-borrowing, and extrapolates ancient forms from these similarities.\n\n" ..
"According to our [[Wiktionary:Criteria for inclusion|criteria for inclusion]], terms in " .. canonicalName ..
" should '''not''' be present in entries in the main namespace, but may be added to the Reconstruction: namespace."
elseif lang:hasType("appendix-constructed") then
add = add .. "\n\n" ..
ucfirst(canonicalName) .. " is a constructed language that is only in sporadic use. " ..
"According to our [[Wiktionary:Criteria for inclusion|criteria for inclusion]], terms in " .. canonicalName ..
" should '''not''' be present in entries in the main namespace, but may be added to the Appendix: namespace. " ..
"All terms in this language may be available at [[Appendix:" .. ucfirst(canonicalName) .. "]]."
end

local about = mw.title.new("Wiktionary:About " .. canonicalName)

if about.exists then
add = add .. "\n\n" ..
"Please see '''[[Wiktionary:About " .. canonicalName .. "]]''' for information and special considerations for creating " .. nameWithLanguage .. " entries."
end

local ok, tree_of_descendants = pcall(
require("Module:family tree").print_children,
lang:getCode(), {
protolanguage_under_family = true,
must_have_descendants = true
})

if ok then
if tree_of_descendants then
add = add .. NavFrame(
tree_of_descendants,
"Family tree")
else
add = add .. "\n\n" .. ucfirst(lang:getCanonicalName())
.. " has no descendants or varieties listed in Wiktionary's language data modules."
end
else
mw.log("error while generating tree: " .. tostring(tree_of_descendants))
end

return description, intro, add
end

local function get_parents(lang, countries, extinct)
local canonicalName = lang:getCanonicalName()

local ret = {{name = "All languages", sort = canonicalName}}

local fam = lang:getFamily()
local famCode = fam and fam:getCode()

-- FIXME: Some of the following categories should be added to this module.
if not fam then
table.insert(ret, {name = "Category:Unclassified languages", sort = canonicalName})
elseif famCode == "qfa-iso" then
table.insert(ret, {name = "Category:Language isolates", sort = canonicalName})
elseif famCode == "qfa-mix" then
table.insert(ret, {name = "Category:Mixed languages", sort = canonicalName})
elseif famCode == "sgn" then
table.insert(ret, {name = "Category:All sign languages", sort = canonicalName})
elseif famCode == "crp" then
table.insert(ret, {name = "Category:Creole or pidgin languages", sort = canonicalName})
for _, anc in ipairs(lang:getAncestors()) do
-- Avoid Haitian Creole being categorised in [[:Category:Haitian Creole-based creole or pidgin languages]], as one of its ancestors is an etymology-only variety of it.
-- Use that ancestor's ancestors instead.
if anc:getNonEtymologicalCode() == lang:getCode() then
for _, anc_extra in ipairs(anc:getAncestors()) do
table.insert(ret, {name = "Category:" .. ucfirst(anc_extra:getNonEtymologicalName()) .. "-based creole or pidgin languages", sort = canonicalName})
end
else
table.insert(ret, {name = "Category:" .. ucfirst(anc:getNonEtymologicalName()) .. "-based creole or pidgin languages", sort = canonicalName})
end
end
elseif famCode == "art" then
if lang:hasType("appendix-constructed") then
table.insert(ret, {name = "Category:Appendix-only constructed languages", sort = canonicalName})
else
table.insert(ret, {name = "Category:Constructed languages", sort = canonicalName})
end
for _, anc in ipairs(lang:getAncestors()) do
if anc:getNonEtymologicalCode() == lang:getCode() then
for _, anc_extra in ipairs(anc:getAncestors()) do
table.insert(ret, {name = "Category:" .. ucfirst(anc_extra:getNonEtymologicalName()) .. "-based constructed languages", sort = canonicalName})
end
else
table.insert(ret, {name = "Category:" .. ucfirst(anc:getNonEtymologicalName()) .. "-based constructed languages", sort = canonicalName})
end
end
else
table.insert(ret, {name = "Category:" .. fam:getCategoryName(), sort = canonicalName})
if lang:hasType("reconstructed") then
table.insert(ret, {name = "Category:Reconstructed languages", sort = (mw.ustring.gsub(canonicalName, "^Proto%-", ""))})
end
end

local function add_sc_cat(sc)
table.insert(ret, {name = "Category:" .. sc:getCategoryName() .. " languages", sort = canonicalName})
end

local function add_Hrkt()
add_sc_cat(Hrkt)
add_sc_cat(Hira)
add_sc_cat(Kana)
end

for _, sc in ipairs(lang:getScripts()) do
if sc:getCode() == "Hrkt" then
add_Hrkt()
else
add_sc_cat(sc)
if sc:getCode() == "Jpan" then
add_sc_cat(Hani)
add_Hrkt()
elseif sc:getCode() == "Kore" then
add_sc_cat(Hang)
add_sc_cat(Hani)
end
end
end

if lang:hasTranslit() then
table.insert(ret, {name = "Category:Languages with automatic transliteration", sort = canonicalName})
end

local saw_country = false
for _, country in ipairs(countries) do
if country ~= "UNKNOWN" then
table.insert(ret, {name = "Category:Languages of " .. country, sort = canonicalName})
saw_country = true
end
end

if extinct then
table.insert(ret, {name = "Category:All extinct languages", sort = canonicalName})
end

if not saw_country then
table.insert(ret, {name = "Category:Languages not sorted into a country category", sort = canonicalName})
end

return ret
end

local function get_children(lang)
local ret = {}

-- FIXME: We should work on the children mechanism so it isn't necessary to manually specify these.
for _, label in ipairs({"appendices", "entry maintenance", "lemmas", "names", "phrases", "rhymes", "symbols", "templates", "terms by etymology", "terms by usage"}) do
table.insert(ret, {name = label, is_label = true})
end

table.insert(ret, {name = "terms derived from {{{langname}}}", is_label = true, lang = false})
table.insert(ret, {module = "topic cat", args = {code = "{{{langcode}}}", label = "all topics"}, sort = "all topics"})
table.insert(ret, {name = "Regional {{{langname}}}"})
table.insert(ret, {name = "Requests concerning {{{langname}}}"})
table.insert(ret, {name = "Category:Rhymes:{{{langname}}}", description = "Lists of {{{langname}}} words by their rhymes."})
table.insert(ret, {name = "Category:User {{{langcode}}}", description = "Wiktionary users categorized by fluency levels in {{{langname}}}."})
return ret
end

-- Handle language categories of the form e.g. [[:Category:French language]] and
-- [[:Category:British Sign Language]].
table.insert(raw_handlers, function(data)
local lang
local langname = data.category:match("^(.*) language$")
if langname then
lang = m_languages.getByCanonicalName(langname)
elseif data.category:find(" Language$") then
lang = m_languages.getByCanonicalName(data.category)
end
if not lang then
return nil
end
local params = {
[4] = {list = true},
["setwiki"] = {},
["setwikt"] = {},
["setsister"] = {},
["entryname"] = {},
["extinct"] = {type = "boolean"},
}
local args = require("Module:parameters").process(data.args, params)
-- If called from inside, don't require any arguments, as they can't be known
-- in general and aren't needed just to generate the first parent (used for
-- breadcrumbs).
-- if #args[4] == 0 and not data.called_from_inside then
-- At least one country must be specified unless the language is constructed (e.g. Esperanto) or reconstructed (e.g. Proto-Indo-European).
-- local fam = lang:getFamily()
-- if not (lang:hasType("reconstructed") or (fam and fam:getCode() == "art")) then
-- error("At least one country (param 1=) must be specified for language '" .. lang:getCanonicalName() .. "' (code '" .. lang:getCode() .. "'). " ..
-- "Use the value UNKNOWN if the language's location is truly unknown.")
-- end
-- end
local description, intro, additional = "", "", ""
-- If called from inside the category tree system, it's called when generating
-- parents or children, and we don't need to generate the description or additional
-- text (which is very expensive in terms of memory because it calls [[Module:family tree]],
-- which calls [[Module:languages/data/all]]).
if not data.called_from_inside then
description, intro, additional = get_description_intro_additional(
lang, args[4], args.extinct, args.setwiki, args.setwikt, args.setsister, args.entryname
)
end
return {
description = description,
lang = lang:getCode(),
intro = intro,
additional = additional,
breadcrumb = lang:getCanonicalName(),
parents = get_parents(lang, args[4], args.extinct),
extra_children = get_children(lang),
umbrella = false,
can_be_empty = true,
}, true
end)

-- Handle categories such as [[:Category:Regional French]] and [[:Category:Regional Ancient Greek]].
table.insert(raw_handlers, function(data)
local langname = data.category:match("^Regional (.*)$")
if langname then
local lang = require("Module:languages").getByCanonicalName(langname)
if lang then
return {
lang = lang:getCode(),
description = "Categories containing terms in regional varieties of " .. lang:makeCategoryLink() .. ".",
additional = "This category may also directly contain terms that are uncategorized regionalisms. Such terms should usually be recategorized by the particular regional variety they belong to.",
parents = {
"{{{langcat}}}",
{name = "Regionalisms", sort = langname},
},
breadcrumb = "Regional",
}
end
end
end)

-- Handle categories such as [[:Category:English-based creole or pidgin languages]].
table.insert(raw_handlers, function(data)
local langname = data.category:match("(.*)%-based creole or pidgin languages$")
if langname then
local lang = require("Module:languages").getByCanonicalName(langname)
if lang then
return {
lang = lang:getCode(),
description = "Languages which developed as a {{wt|creole}} or {{wt|pidgin}} from " .. lang:makeCategoryLink() .. ".",
parents = {{name = "Creole or pidgin languages", sort = "*" .. langname}},
breadcrumb = lang:getCanonicalName() .. "-based",
}
end
end
end)

-- Handle categories such as [[:Category:English-based constructed languages]].
table.insert(raw_handlers, function(data)
local langname = data.category:match("(.*)%-based constructed languages$")
if langname then
local lang = require("Module:languages").getByCanonicalName(langname)
if lang then
return {
lang = lang:getCode(),
description = "Constructed languages which are based on " .. lang:makeCategoryLink() .. ".",
parents = {{name = "Constructed languages", sort = "*" .. langname}},
breadcrumb = lang:getCanonicalName() .. "-based",
}
end
end
end)

return {RAW_CATEGORIES = raw_categories, RAW_HANDLERS = raw_handlers}

Module:Category tree/poscatboiler/data/lang-specific

Jsrs701 — Fri, 10 Apr 2026 07:25:52 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data/lang-specific by file upload (1 revision)

New page

-- This module contains a list of languages with lang-specific modules.

local langs_with_modules = {
["acw"] = true,
["afb"] = true,
["ajp"] = true,
["ams"] = true,
["ang"] = true,
["apc"] = true,
["ar"] = true,
["ary"] = true,
["arz"] = true,
["asta"] = true,
["az"] = true,
["be"] = true,
["bg"] = true,
["cast"] = true,
["ceb"] = true,
["chak"] = true,
["cs"] = true,
["cu"] = true,
["de"] = true,
["doth"] = true,
["el"] = true,
["en"] = true,
["enm"] = true,
["es"] = true,
["eu"] = true,
["fa"] = true,
["fax"] = true,
["fi"] = true,
["fjer"] = true,
["goh"] = true,
["gvun"] = true,
["grk-pro"] = true,
["he"] = true,
["hi"] = true,
["hil"] = true,
["henl"] = true,
["hval"] = true,
["ilo"] = true,
["ira-pro"] = true,
["it"] = true,
["ja"] = true,
["kzg"] = true,
["la"] = true,
["lhaz"] = true,
["lo"] = true,
["meer"] = true,
["meni"] = true,
["mk"] = true,
["mt"] = true,
["mvi"] = true,
["ne"] = true,
["ngda"] = true,
["nl"] = true,
["nn"] = true,
["ojp"] = true,
["okn"] = true,
["orv"] = true,
["pi"] = true,
["pt"] = true,
["ro"] = true,
["ru"] = true,
["ryn"] = true,
["rys"] = true,
["ryu"] = true,
["sa"] = true,
["sc"] = true,
["sei"] = true,
["th"] = true,
["tkn"] = true,
["tl"] = true,
["trig"] = true,
["uk"] = true,
["vzaa"] = true,
["xug"] = true,
["yoi"] = true,
["yox"] = true,
["zh"] = true,
["zlw-ocs"] = true,
}

return langs_with_modules

Module:Category tree/poscatboiler/data/figures of speech

Jsrs701 — Fri, 10 Apr 2026 07:25:52 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data/figures of speech by file upload (1 revision)

New page

Module:Category tree/poscatboiler/data/families

Jsrs701 — Fri, 10 Apr 2026 07:25:52 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data/families by file upload (1 revision)

New page

local raw_categories = {}
local raw_handlers = {}

-----------------------------------------------------------------------------
-- --
-- RAW CATEGORIES --
-- --
-----------------------------------------------------------------------------

raw_categories["All language families"] = {
intro = "{{sisterlinks|Category:Languages by family}}\n{{wikipedia|Language family|Language family|mul=List of language families|mullabel=List of language families}}",
description = "This category lists all [[Wiktionary:language family|language families]].",
parents = {"Fundamental"},
}

raw_categories["Languages by family"] = {
intro = "{{sisterlinks|Category:Languages by family}}\n{{wikipedia|Language family|Language family|mul=List of language families|mullabel=List of language families}}",
description = "This category contains all languages categorized hierarchically according to the [[Wiktionary:language family|language family]] they belong to.",
additional = "Only top-level language families are shown here. For a full list of all language families, see [[:Category:All language families]] or [[Wiktionary:List of families]].",
parents = {
{name = "All languages", sort = " "},
{name = "All language families", sort = " "},
},
}

-----------------------------------------------------------------------------
-- --
-- RAW HANDLERS --
-- --
-----------------------------------------------------------------------------

local function family_is_not_a_family(fam)
local famcode = fam:getCode()
if famcode == "paa" then
return false -- Papuan languages are not a family but have a category
elseif famcode == "qfa-iso" or famcode == "qfa-not" then
return true
else
local parfam = fam:getFamily()
if parfam and parfam:getCode() == "qfa-not" then
-- Constructed languages, sign languages, etc.; no category for them
return true
end
end
return false
end

local function infobox(fam)
local ret = {}

table.insert(ret, "<table class=\"wikitable\">\n")
table.insert(ret, "<tr>\n<th colspan=\"2\" class=\"plainlinks\">[//en.wiktionary.org/w/index.php?title=Module:families/data&action=edit Edit family data]</th>\n</tr>\n")
table.insert(ret, "<tr>\n<th>Canonical name</th><td>" .. fam:getCanonicalName() .. "</td>\n</tr>\n")

local otherNames = fam:getOtherNames(true)
if otherNames then
local names = {}

for _, name in ipairs(otherNames) do
table.insert(names, "<li>" .. name .. "</li>")
end

if #names > 0 then
table.insert(ret, "<tr>\n<th>Other names</th><td><ul>" .. table.concat(names, "\n") .. "</ul></td>\n</tr>\n")
end
end

local aliases = fam:getAliases()
if aliases then
local names = {}

for _, name in ipairs(aliases) do
table.insert(names, "<li>" .. name .. "</li>")
end

if #names > 0 then
table.insert(ret, "<tr>\n<th>Aliases</th><td><ul>" .. table.concat(names, "\n") .. "</ul></td>\n</tr>\n")
end
end

local varieties = fam:getVarieties()
if varieties then
local names = {}

for _, name in ipairs(varieties) do
if type(name) == "string" then
table.insert(names, "<li>" .. name .. "</li>")
else
assert(type(name) == "table")
local first_var
local subvars = {}
for i, var in ipairs(name) do
if i == 1 then
first_var = var
else
table.insert(subvars, "<li>" .. var .. "</li>")
end
end
if #subvars > 0 then
table.insert(names, "<li><dl><dt>" .. first_var .. "</dt>\n<dd><ul>" .. table.concat(subvars, "\n") .. "</ul></dd></dl></li>")
elseif first_var then
table.insert(names, "<li>" .. first_var .. "</li>")
end
end
end

if #names > 0 then
table.insert(ret, "<tr>\n<th>Varieties</th><td><ul>" .. table.concat(names, "\n") .. "</ul></td>\n</tr>\n")
end
end

table.insert(ret, "<tr>\n<th>[[Wiktionary:Families|Family code]]</th><td><code>" .. fam:getCode() .. "</code></td>\n</tr>\n")
table.insert(ret, "<tr>\n<th>[[Wikipedia:Proto-language|Common ancestor]]</th><td>")

local protoLanguage = fam:getProtoLanguage()

if protoLanguage then
table.insert(ret, "[[:Category:" .. protoLanguage:getCategoryName() .. "|" .. protoLanguage:getCanonicalName() .. "]]")
else
table.insert(ret, "none")
end

table.insert(ret, "</td>\n")
table.insert(ret, "\n</tr>\n")

local parent = fam:getFamily()

if not parent then
table.insert(ret, "<tr>\n<th>[[Wiktionary:Families|Parent family]]</th>\n<td>")
table.insert(ret, "unclassified")
elseif parent:getCode() == "qfa-not" then
table.insert(ret, "<tr>\n<th>[[Wiktionary:Families|Parent family]]</th>\n<td>")
table.insert(ret, "not a family")
else
local chain = {}
while parent do
if family_is_not_a_family(parent) then
break
end
table.insert(chain, "[[:Category:" .. parent:getCategoryName() .. "|" .. parent:getCanonicalName() .. "]]")
parent = parent:getFamily()
end
if #chain == 0 then
table.insert(ret, "<tr>\n<th>[[Wiktionary:Families|Parent family]]</th>\n<td>")
table.insert(ret, "no parents")
else
table.insert(ret, "<tr>\n<th>[[Wiktionary:Families|Parent famil"
.. (#chain == 1 and "y" or "ies") .. "]]</th>\n<td>")

for i = #chain, 1, -1 do
table.insert(ret, "<ul><li>" .. chain[i])
end
table.insert(ret, string.rep("</li></ul>", #chain))
end
end

table.insert(ret, "</td>\n</tr>\n")

if fam:getWikidataItem() and mw.wikibase then
local link = '[' .. mw.wikibase.getEntityUrl(fam:getWikidataItem()) .. ' ' .. fam:getWikidataItem() .. ']'
table.insert(ret, "<tr><th>Wikidata</th><td>" .. link .. "</td></tr>")
end

table.insert(ret, "</table>")

return table.concat(ret)
end

table.insert(raw_handlers, function(data)
local family_name = data.category:match("^(.+) languages$")
if not family_name then
family_name = data.category:match("^(.+ Languages)$")
end
if not family_name then
return nil
end
local family = require("Module:families").getByCanonicalName(family_name) or
require("Module:families").getByCanonicalName(mw.ustring.lower(family_name))
if not family then
return nil
end

local parent_fam = family:getFamily()
local first_parent

if not parent_fam or family_is_not_a_family(parent_fam) then
first_parent = "Languages by family"
else
first_parent = parent_fam:getCategoryName()
end

local intro, description, additional = "", "", ""
if not data.called_from_inside then
local wikipedia_art = family:getWikipediaArticle()
intro = ""
description = "This is the main category of the '''" .. family:getDisplayForm() .. "'''."
additional = "Information about " .. family:getCanonicalName() .. ":\n\n" .. infobox(family)
end

return {
intro = intro,
description = description,
additional = additional,
parents = {
first_parent,
"All language families",
},
breadcrumb = family:getCanonicalName(),
can_be_empty = true,
}
end)

return {RAW_CATEGORIES = raw_categories, RAW_HANDLERS = raw_handlers}

Module:Category tree/poscatboiler/data/entry maintenance

Jsrs701 — Fri, 10 Apr 2026 07:25:51 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data/entry maintenance by file upload (1 revision)

Show changes

Module:Category tree/poscatboiler/data/characters

Jsrs701 — Fri, 10 Apr 2026 07:25:51 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data/characters by file upload (1 revision)

New page

local raw_categories = {}
local handlers = {}

local ulen = mw.ustring.len
local uupper = mw.ustring.upper
local ulower = mw.ustring.lower
local rfind = mw.ustring.find

local function track(page)
require("Module:debug/track")("poscatboiler-characters/" .. page)
return true
end

-----------------------------------------------------------------------------
-- --
-- RAW CATEGORIES --
-- --
-----------------------------------------------------------------------------

raw_categories["Terms by their individual characters subcategories by language"] = {
description = "Umbrella categories covering terms categorized by unusual characters contained in them.",
additional = "{{{umbrella_meta_msg}}}",
parents = {
"Umbrella metacategories",
{name = "terms by their individual characters", is_label = true, sort = " "},
},
}

-----------------------------------------------------------------------------
-- --
-- HANDLERS --
-- --
-----------------------------------------------------------------------------

-- If char is a combining character, returns a version with a dotted circle before it.
function add_dotted_circle(char, combining)
return combining and "◌" .. char or char
end

table.insert(handlers, function(data)
-- NOTE: The "character" in the title may actually be a description such as
-- "gershayim". In that case, char= is specified as a parameter indicating the
-- actual character.
local titlechar = data.label:match("^terms spelled with (.+)$")
if not titlechar then
return nil
end
local ja_ryu = data.lang and (data.lang:getFamilyCode() == "jpx" or data.lang:getFamilyCode() == "jpx-ryu")
-- If Japanese or Ryukyuan, only fire on a single kanji character.
if ja_ryu and (titlechar:find("[A-Za-z]") or ulen(titlechar) > 1) then
return nil
end
local params = {
["char"] = {},
["sort"] = {},
-- Not sure what used to be done with the following parameters.
["context"] = {},
["context2"] = {},
}
local args = require("Module:parameters").process(data.args, params)
if args.context or args.context2 then
track("terms-spelled-with-context")
end

if titlechar == "numbers" then
local sortkey = args.sort or "#"
return {
description = "{{{langname}}} terms spelled with one or more numeric digits.",
parents = {{name = "terms by their individual characters", sort = sortkey }},
breadcrumb = "numbers",
umbrella = {
breadcrumb = "numbers",
parents = {{name = "Terms by their individual characters subcategories by language", sort = " " .. sortkey }}
},
}, true
end

local char = args.char or titlechar
local titlechar_is_desc = args.char and args.char ~= titlechar
if titlechar_is_desc then
track("titlechar_is_desc")
end

local lang = data.lang or require("Module:languages").getByCode("mul")
local combining = ulen(char) == 1 and require("Module:Unicode_data").is_combining(mw.ustring.codepoint(char))

local specials = {["ß"] = "ẞ", ["ͅ"] = "ͅ"}
local upper = mw.ustring.toNFD(char)
:gsub("[%z\1-\127\194-\244][\128-\191]*", function(m)
return specials[m] or mw.ustring.upper(m)
end)
upper = mw.ustring.toNFC(upper)

if char ~= upper and ulen(char) == 1 then
-- We want uppercase characters; but unless we're careful, we run into an issue with
-- [[Category:English terms spelled with ı]] due to the weird behavior of this character,
-- which has standard I as its uppercase equivalent.
local standard_chars = lang:getStandardCharacters()
if data.lang and standard_chars then
local function err()
error("Category titles should use uppercase characters: '" .. data.label .. "'", 2)
end
if data.lang:getCode() ~= "lo" then
if not rfind(standard_chars, upper) then
err()
end
elseif not rfind(upper, "[" .. standard_chars .. "]") then
err()
end
end
end

-- Compute description.

-- If the letter has a lowercase form, show it.
local character = require("Module:links").full_link(
{
term = char,
alt = combining and add_dotted_circle(char, true) or nil,
lang = lang,
tr = combining and "-" or nil,
},
"term"
)

if ulower(char) ~= char then
character = "upper case " .. character .. " or lower case " ..
require("Module:links").full_link(
{
term = ulower(char),
lang = lang
},
"term"
)
end

if titlechar_is_desc then
character = character .. " (" .. titlechar .. ")"
end

local description = "{{{langname}}} terms spelled with " .. character .. "."

-- Set tagged character for displaytitle and breadcrumb.
local tagged_titlechar = not titlechar_is_desc and
require("Module:script utilities").tag_text(titlechar, lang, nil, "term") or nil
local tagged_char = titlechar_is_desc and titlechar or
require("Module:script utilities").tag_text(add_dotted_circle(char, combining), lang, nil, "term")

-- Compute sort key.

local sortkey =
args.sort or
(lang:makeSortKey(char))
if sortkey == "" then
sortkey = char
end

return {
description = description,
additional = "Note that categories of the form '''''LANG terms spelled with CHAR''''' are intended for characters not "
.. "part of the standard repertoire of a language (e.g. Cyrillic characters in English or Latin characters in Russian).",
displaytitle = not titlechar_is_desc and "{{{langname}}} terms spelled with " .. tagged_titlechar or nil,
parents = {{name = "terms by their individual characters", sort = sortkey }},
breadcrumb = tagged_char,
umbrella = not ja_ryu and {
displaytitle = not titlechar_is_desc and "Terms spelled with " .. tagged_titlechar .. " by language" or nil,
breadcrumb = tagged_char,
parents = {{name = "Terms by their individual characters subcategories by language", sort = " " .. sortkey }}
} or false,
}, true
end)

return {RAW_CATEGORIES = raw_categories, HANDLERS = handlers}

Module:Category tree/poscatboiler/data

Jsrs701 — Fri, 10 Apr 2026 07:25:51 GMT

Jsrs701 imported Module:Category tree/poscatboiler/data by file upload (1 revision)

New page

local labels = {}
local raw_categories = {}
local handlers = {}
local raw_handlers = {}

local subpages = {
"characters",
"entry maintenance",
"families",
"figures of speech",
"languages",
"lemmas",
"miscellaneous",
"modules",
"names",
"non-lemma forms",
"phrases",
"rhymes",
"scripts",
"shortenings",
"symbols",
"templates",
"terms by etymology",
"terms by grammatical category",
"terms by lexical property",
"terms by semantic function",
"terms by script",
"terms by usage",
"transliterations",
"unicode",
"word of the day",
"words by number of syllables",
}

-- Import subpages
for _, subpage in ipairs(subpages) do
local datamodule = "Module:category tree/poscatboiler/data/" .. subpage
local retval = require(datamodule)
if retval["LABELS"] then
for label, data in pairs(retval["LABELS"]) do
if labels[label] and not retval["IGNOREDUP"] then
error("Label " .. label .. " defined in both [["
.. datamodule .. "]] and [[" .. labels[label].module .. "]].")
end
data.module = datamodule
labels[label] = data
end
end
if retval["RAW_CATEGORIES"] then
for category, data in pairs(retval["RAW_CATEGORIES"]) do
if raw_categories[category] and not retval["IGNOREDUP"] then
error("Raw category " .. category .. " defined in both [["
.. datamodule .. "]] and [[" .. raw_categories[category].module .. "]].")
end
data.module = datamodule
raw_categories[category] = data
end
end
if retval["HANDLERS"] then
for _, handler in ipairs(retval["HANDLERS"]) do
table.insert(handlers, { module = datamodule, handler = handler })
end
end
if retval["RAW_HANDLERS"] then
for _, handler in ipairs(retval["RAW_HANDLERS"]) do
table.insert(raw_handlers, { module = datamodule, handler = handler })
end
end
end

-- Add child categories to their parents
local function add_children_to_parents(hierarchy, raw)
for key, data in pairs(hierarchy) do
local parents = data.parents
if parents then
if type(parents) ~= "table" then
parents = {parents}
end
if parents.name or parents.module then
parents = {parents}
end
for _, parent in ipairs(parents) do
if type(parent) ~= "table" or not parent.name and not parent.module then
parent = {name = parent}
end
if parent.name and not parent.module and type(parent.name) == "string" and not parent.name:find("^Category:") then
local parent_is_raw
if raw then
parent_is_raw = not parent.is_label
else
parent_is_raw = parent.raw
end
-- Don't do anything if the child is raw and the parent is lang-specific,
-- otherwise e.g. "Lemmas subcategories by language" will be listed as a
-- child of every "LANG lemmas" category.
-- FIXME: We need to rethink this mechanism.
if not raw or parent_is_raw then
local child_hierarchy = parent_is_raw and raw_categories or labels
if child_hierarchy[parent.name] then
local child = {name = key, sort = parent.sort, raw = raw}
if child_hierarchy[parent.name].children then
table.insert(child_hierarchy[parent.name].children, child)
else
child_hierarchy[parent.name].children = {child}
end
end
end
end
end
end
end
end

add_children_to_parents(labels)
add_children_to_parents(raw_categories, true)

return {
LABELS = labels, RAW_CATEGORIES = raw_categories,
HANDLERS = handlers, RAW_HANDLERS = raw_handlers
}

Module:Category tree/poscatboiler

Jsrs701 — Fri, 10 Apr 2026 07:25:51 GMT

Jsrs701 imported Module:Category tree/poscatboiler by file upload (1 revision)

New page

local export = {}

local lang_independent_data = require("Module:category tree/poscatboiler/data")
local lang_specific_module = "Module:category tree/poscatboiler/data/lang-specific"
local lang_specific_module_prefix = lang_specific_module .. "/"

-- Category object

local Category = {}
Category.__index = Category

function Category.new_main(frame)
local self = setmetatable({}, Category)

local params = {
[1] = {},
[2] = {required = true},
[3] = {},
["raw"] = {type = "boolean"},
}

local args, remaining_args = require("Module:parameters").process(frame:getParent().args, params, true, "category tree/poscatboiler")
self._info = {code = args[1], label = args[2], sc = args[3], raw = args.raw, args = remaining_args}

self:initCommon()

if not self._data then
return nil
end

return self
end

function Category:get_originating_info()
local originating_info = ""
if self._info.originating_label then
originating_info = " (originating from label \"" .. self._info.originating_label .. "\" in module [[" .. self._info.originating_module .. "]])"
end
return originating_info
end

function Category.new(info)
for key, val in pairs(info) do
if not (key == "code" or key == "label" or key == "sc" or key == "raw" or key == "args"
or key == "called_from_inside" or key == "originating_label" or key == "originating_module") then
error("The parameter \"" .. key .. "\" was not recognized.")
end
end

local self = setmetatable({}, Category)
self._info = info

if not self._info.label then
error("No label was specified.")
end

self:initCommon()

if not self._data then
error("The " .. (self._info.raw and "raw " or "") .. "label \"" .. self._info.label .. "\" does not exist" .. self:get_originating_info() .. ".")
end

return self
end

export.new = Category.new
export.new_main = Category.new_main

function Category:initCommon()
local args_handled = false
if self._info.raw then
-- Check if the category exists
local raw_categories = lang_independent_data["RAW_CATEGORIES"]
self._data = raw_categories[self._info.label]

if self._data then
if self._data.lang then
self._lang = require("Module:languages").getByCode(self._data.lang, true, nil, nil, true)
self._info.code = self._lang:getCode()
end
if self._data.sc then
self._sc = require("Module:scripts").getByCode(self._data.sc, true, nil, true)
self._info.sc = self._sc:getCode()
end
else
-- Go through raw handlers
local data = {
category = self._info.label,
args = self._info.args or {},
called_from_inside = self._info.called_from_inside,
}
for _, handler in ipairs(lang_independent_data["RAW_HANDLERS"]) do
self._data, args_handled = handler.handler(data)
if self._data then
self._data.module = self._data.module or handler.module
break
end
end
if self._data then
if self._data.lang then
if type(self._data.lang) ~= "string" then
error("Received non-string value " .. mw.dumpObject(self._data.lang) .. " for self._data.lang, label \"" .. self._info.label .. "\"" .. self:get_originating_info() .. ".")
end
self._lang = require("Module:languages").getByCode(self._data.lang, true, nil, nil, true)
self._info.code = self._lang:getCode()
end
if self._data.sc then
if type(self._data.sc) ~= "string" then
error("Received non-string value " .. mw.dumpObject(self._data.sc) .. " for self._data.sc, label \"" .. self._info.label .. "\"" .. self:get_originating_info() .. ".")
end
self._sc = require("Module:scripts").getByCode(self._data.sc, true, nil, true)
self._info.sc = self._sc:getCode()
end
end
end
else
-- Already parsed into language + label
if self._info.code then
self._lang = require("Module:languages").getByCode(self._info.code, 1, nil, nil, true)
else
self._lang = nil
end

if self._info.sc then
self._sc = require("Module:scripts").getByCode(self._info.sc, true, nil, true) or error("The script code \"" .. self._info.sc .. "\" is not valid.")
else
self._sc = nil
end

-- First, check lang-specific labels and handlers if this is not an umbrella category.
if self._lang then
local langcode = self._lang:getCode()
local langs_with_modules = mw.loadData(lang_specific_module)
if langs_with_modules[langcode] then
local module = lang_specific_module_prefix .. self._lang:getCode()
local labels_and_handlers = require(module)
if labels_and_handlers.LABELS then
self._data = labels_and_handlers.LABELS[self._info.label]
if self._data then
if self._data.umbrella == nil and self._data.umbrella_parents == nil then
self._data.umbrella = false
end
self._data.module = self._data.module or module
end
end
if not self._data and labels_and_handlers.HANDLERS then
for _, handler in ipairs(labels_and_handlers.HANDLERS) do
local data = {
label = self._info.label,
lang = self._lang,
sc = self._sc,
args = self._info.args or {},
called_from_inside = self._info.called_from_inside,
}
self._data, args_handled = handler(data)
if self._data then
if self._data.umbrella == nil and self._data.umbrella_parents == nil then
self._data.umbrella = false
end
self._data.module = self._data.module or module
break
end
end
end
end
end

-- Then check lang-independent labels.
if not self._data then
local labels = lang_independent_data["LABELS"]
self._data = labels[self._info.label]
end

-- Then check lang-independent handlers.
if not self._data then
local data = {
label = self._info.label,
lang = self._lang,
sc = self._sc,
args = self._info.args or {},
called_from_inside = self._info.called_from_inside,
}
for _, handler in ipairs(lang_independent_data["HANDLERS"]) do
self._data, args_handled = handler.handler(data)
if self._data then
self._data.module = self._data.module or handler.module
break
end
end
end
end

if not args_handled and self._data and self._info.args and next(self._info.args) then
local module_text = " (handled in [[" .. (self._data.module or "UNKNOWN").. "]])"
local args_text = {}
for k, v in pairs(self._info.args) do
table.insert(args_text, k .. "=" .. ((type(v) == "string" or type(v) == "number") and v or mw.dumpObject(v)))
end
error("poscatboiler label '" .. self._info.label .. "' " .. module_text .. " doesn't accept extra args " ..
table.concat(args_text, ", "))
end

if self._sc and not self._lang then
error("Umbrella categories cannot have a script specified.")
end
end

function Category:convert_spec_to_string(desc)
if not desc then
return desc
end
if type(desc) == "number" then
desc = tostring(desc)
end
if type(desc) == "function" then
local data = {
lang = self._lang,
sc = self._sc,
label = self._info.label,
raw = self._info.raw,
}
desc = desc(data)
end
return desc
end

function Category:substitute_template_specs(desc)
if not desc then
return desc
end
-- This may end up happening twice but that's OK as the function is idempotent.
desc = self:convert_spec_to_string(desc)

desc = desc:gsub("{{PAGENAME}}", mw.title.getCurrentTitle().text)
desc = desc:gsub("{{{umbrella_msg}}}", "This is an umbrella category. It contains no dictionary entries, but only other, language-specific categories, which in turn contain relevant terms in a given language.")
desc = desc:gsub("{{{umbrella_meta_msg}}}", 'This is an umbrella metacategory, covering a general area such as "lemmas", "names" or "terms by etymology". It contains no dictionary entries, but holds only umbrella ("by language") categories covering specific subtopics, which in turn contain language-specific categories holding terms in a given language for that same topic.')
if self._lang then
desc = desc:gsub("{{{langname}}}", self._lang:getCanonicalName())
desc = desc:gsub("{{{langcode}}}", self._lang:getCode())
desc = desc:gsub("{{{langcat}}}", self._lang:getCategoryName())
desc = desc:gsub("{{{langlink}}}", self._lang:makeCategoryLink())
end
if self._sc then
desc = desc:gsub("{{{scname}}}", self._sc:getCanonicalName())
desc = desc:gsub("{{{sccode}}}", self._sc:getCode())
desc = desc:gsub("{{{sccat}}}", self._sc:getCategoryName())
desc = desc:gsub("{{{scdisp}}}", self._sc:getDisplayForm())
desc = desc:gsub("{{{sclink}}}", self._sc:makeCategoryLink())
end
if desc:find("{") then
desc = mw.getCurrentFrame():preprocess(desc)
end
return desc
end

function Category:substitute_template_specs_in_args(args)
if not args then
return args
end
local pinfo = {}
for k, v in pairs(args) do
k = self:substitute_template_specs(k)
v = self:substitute_template_specs(v)
pinfo[k] = v
end
return pinfo
end

function Category:make_new(info)
info.originating_label = self._info.label
info.originating_module = self._data.module
info.called_from_inside = true
return Category.new(info)
end

function Category:getBreadcrumbName()
local ret

if self._lang or self._info.raw then
ret = self._data.breadcrumb
else
ret = self._data.umbrella and self._data.umbrella.breadcrumb
end
if not ret then
ret = self._info.label
end

if type(ret) ~= "table" then
ret = {name = ret}
end

local name = self:substitute_template_specs(ret.name)
local nocap = ret.nocap

if self._sc then
name = name .. " in " .. self._sc:getDisplayForm()
end

return name, nocap
end

function Category:getTOC(toc_type)
local ret

-- type "none" means everything fits on a single page; fall back to normal behavior (display nothing)
if toc_type == "none" then
return true
end

-- Return the textual expansion of the first existing template among the given templates, first performing
-- substitutions on the template name such as replacing {{{langcode}}} with the current language's code (if any).
-- If no templates exist after expansion, or if nil is passed in, return nil. If a single string is passed in,
-- treat it like a one-element list consisting of that string.
local function get_template_text(templates)
if templates == nil then
return nil
end
if type(templates) ~= "table" then
templates = {templates}
end
for _, template in ipairs(templates) do
if template == false then
return false
end
template = self:substitute_template_specs(template)
local template_obj = mw.title.new("Template:" .. template)
if template_obj.exists then
return mw.getCurrentFrame():expandTemplate{title = template_obj.text, args = {}}
end
end
return nil
end

local templates, fallback_templates

-- If TOC type is "full" (more than 2500 entries), do the following, in order:
-- 1. look up and expand the `toc_template_full` templates (normal or umbrella, depending on whether there is
-- a current language);
-- 2. look up and expand the `toc_template` templates (normal or umbrella, as above);
-- 3. do the default behavior, which is as follows:
-- 3a. look up a language-specific "full" template according to the current language (using English if there
-- is no current language);
-- 3b. look up a language-specific "normal" template according to the current language (using English if there
-- is no current language);
-- 3c. display nothing.
--
-- If TOC type is "normal" (between 200 and 2500 entries), do the following, in order:
-- 1. look up and expand the `toc_template` templates (normal or umbrella, depending on whether there is
-- a current language);
-- 2. do the default behavior, which is as follows:
-- 2a. look up a language-specific "normal" template according to the current language (using English if there
-- is no current language);
-- 2b. display nothing.

local data_source
if self._lang or self._info.raw then
data_source = self._data
else
data_source = self._data.umbrella
end

if data_source then
if toc_type == "full" then
templates = data_source.toc_template_full
fallback_templates = data_source.toc_template
else
templates = data_source.toc_template
end
end

local text = get_template_text(templates)
if text then
return text
end
if text == false then
return nil
end
text = get_template_text(fallback_templates)
if text then
return text
end
if text == false then
return nil
end
return true
end

function Category:getInfo()
return self._info
end

function Category:getDataModule()
return self._data.module
end

function Category:canBeEmpty()
if self._lang or self._info.raw then
return self._data.can_be_empty
else
return self._data.umbrella and self._data.umbrella.can_be_empty
end
end

function Category:isHidden()
if self._lang or self._info.raw then
return self._data.hidden
else
return self._data.umbrella and self._data.umbrella.hidden
end
end

function Category:getCategoryName()
if self._info.raw then
return self._info.label
elseif self._lang then
local ret = self._lang:getCanonicalName() .. " " .. self._info.label

if self._sc then
ret = ret .. " in " .. self._sc:getDisplayForm()
end

return mw.getContentLanguage():ucfirst(ret)
else
local ret = mw.getContentLanguage():ucfirst(self._info.label)
if not (self._data.umbrella and self._data.umbrella.no_by_language) then
ret = ret .. " by language"
end
return ret
end
end

function Category:getIntro()
if self._lang or self._info.raw then
return self:substitute_template_specs(self._data.intro)
else
return self._data.umbrella and self:substitute_template_specs(self._data.umbrella.intro)
end
end

local function remove_lang_params(desc)
desc = desc:gsub("{{{langname}}} ", "")
desc = desc:gsub("{{{langcode}}} ", "")
desc = desc:gsub("{{{langcat}}} ", "")
return desc
end

function Category:getDescription(isChild)
-- Allows different text in the list of a category's children
local isChild = isChild == "child"

local function display_title(displaytitle, lang)
if type(displaytitle) == "string" then
displaytitle = self:substitute_template_specs(displaytitle)
else
displaytitle = displaytitle(self:getCategoryName(), lang)
end
mw.getCurrentFrame():callParserFunction("DISPLAYTITLE", "Category:" .. displaytitle)
end

if self._lang or self._info.raw then
if not isChild and self._data.displaytitle then
display_title(self._data.displaytitle, self._lang)
end

if self._sc then
return self:getCategoryName() .. "."
else
local desc = self:convert_spec_to_string(self._data.description)

if not isChild and desc and self._data.additional then
desc = desc .. "\n\n" .. self._data.additional
end

return self:substitute_template_specs(desc)
end
else
if not isChild and self._data.umbrella and self._data.umbrella.displaytitle then
display_title(self._data.umbrella.displaytitle, nil)
end

local desc = self:convert_spec_to_string(self._data.umbrella and self._data.umbrella.description)
local has_umbrella_desc = not not desc
if not desc then
desc = self:convert_spec_to_string(self._data.description)
if desc then
desc = remove_lang_params(desc)
desc = mw.getContentLanguage():lcfirst(desc)
desc = desc:gsub("%.$", "")
desc = "Categories with " .. desc .. "."
end
end
if not desc then
desc = "Categories with " .. self._info.label .. " in various specific languages."
end
if not isChild then
local additional = self:convert_spec_to_string(
self._data.umbrella and self._data.umbrella.additional or not has_umbrella_desc and self._data.additional
)
if additional then
desc = desc .. "\n\n" .. remove_lang_params(additional)
end
desc = desc .. "\n\n{{{umbrella_msg}}}"
end
desc = self:substitute_template_specs(desc)
return desc
end
end

function Category:canonicalize_parents_children(cats, is_children)
if not cats then
return nil
end
if type(cats) ~= "table" then
cats = {cats}
end
if cats.name or cats.module then
cats = {cats}
end
if #cats == 0 then
return nil
end

local ret = {}

for _, cat in ipairs(cats) do
if type(cat) ~= "table" or not cat.name and not cat.module then
cat = {name = cat}
end
table.insert(ret, cat)
end

local is_umbrella = not self._lang and not self._info.raw
local table_type = is_children and "extra_children" or "parents"

for i, cat in ipairs(ret) do
local sort_key = self:substitute_template_specs(cat.sort)

local name = cat.name

if cat.module then
-- A reference to a category using another category tree module.
if not cat.args then
error("Missing .args in '" .. table_type .. "' table with module=\"" .. cat.module .. "\" for '" ..
self._info.label .. "' category entry in module '" .. (self._data.module or "unknown") .. "'")
end
name = require("Module:category tree/" .. cat.module).new(self:substitute_template_specs_in_args(cat.args))
else
if not name then
error("Missing .name in " .. (is_umbrella and "umbrella " or "") .. "'" .. table_type .. "' table for '" ..
self._info.label .. "' category entry in module '" .. (self._data.module or "unknown") .. "'")
end
if type(name) ~= "string" then
-- assume it's a category object and use it directly
else
name = self:substitute_template_specs(name)
if name:find("^Category:") then
-- It's a non-poscatboiler category name.
sort_key = sort_key or is_children and name:gsub("^Category:", "") or self:getCategoryName()
else
-- It's a label.
local raw
if self._info.raw or is_umbrella then
raw = not cat.is_label
else
raw = cat.raw
end
local cat_code
if cat.lang == false then
cat_code = nil
elseif cat.lang then
cat_code = self:substitute_template_specs(cat.lang)
elseif not raw then
cat_code = self._info.code
end
sort_key = sort_key or is_children and name or self._info.label
name = self:make_new({
label = name, code = cat_code, sc = self:substitute_template_specs(cat.sc),
raw = raw, args = self:substitute_template_specs_in_args(cat.args)
})
end
end
end

sort_key = mw.ustring.upper(sort_key or is_children and " " or self._info.label)
local description = is_children and self:substitute_template_specs(cat.description) or nil
ret[i] = {name = name, description = description, sort = sort_key}
end

return ret
end

function Category:getParents()
local is_umbrella = not self._lang and not self._info.raw
local retval
if self._sc then
local parent1 = self:make_new({code = self._info.code, label = "terms in " .. self._sc:getCanonicalName() .. " script"})
local parent2 = self:make_new({code = self._info.code, label = self._info.label, raw = self._info.raw, args = self._info.args})

retval = {
{name = parent1, sort = self._sc:getCanonicalName()},
{name = parent2, sort = self._sc:getCanonicalName()},
}
else
local parents
if is_umbrella then
parents = self._data.umbrella and self._data.umbrella.parents or self._data.umbrella_parents
else
parents = self._data.parents
end

retval = self:canonicalize_parents_children(parents)
end

if not retval then
return nil
end

local self_cat = self:getCategoryName()
for _, parent in ipairs(retval) do
local parent_cat = parent.name.getCategoryName and parent.name:getCategoryName()
if self_cat == parent_cat then
error(("Internal error: Infinite loop would occur, as parent category '%s' is the same as the child category"):
format(self_cat))
end
end

return retval
end

function Category:getTopicParents()
if self._data["topic_parents"] then
local topic_parents = {}
for _, topic_parent in ipairs(self._data["topic_parents"]) do
if self._lang then
table.insert(topic_parents, self._lang:getCode() .. ":" .. topic_parent)
else
table.insert(topic_parents, topic_parent)
end
end
return topic_parents
end
return nil
end

function Category:getChildren()
local is_umbrella = not self._lang and not self._info.raw
local children = self._data.children

local ret = {}

if not is_umbrella and children then
for _, child in ipairs(children) do
child = mw.clone(child)

if type(child) ~= "table" then
child = {name = child}
end

if not child.sort then
child.sort = child.name
end

-- FIXME, is preserving the script correct?
child.name = self:make_new({code = self._info.code, label = child.name, raw = child.raw, sc = self._info.sc})

table.insert(ret, child)
end
end

local extra_children
if is_umbrella then
extra_children = self._data.umbrella and self._data.umbrella.extra_children
else
extra_children = self._data.extra_children
end

extra_children = self:canonicalize_parents_children(extra_children, "children")
if extra_children then
for _, child in ipairs(extra_children) do
table.insert(ret, child)
end
end

if #ret == 0 then
return nil
end
return ret
end

function Category:getUmbrella()
if self._info.raw or not self._lang or self._sc or self._data.umbrella == false then
return nil
end

return self:make_new({label = self._info.label})
end

function Category:getAppendix()
-- FIXME, this should be customizable.
if not self._info.raw and self._info.label and self._lang then
local appendixName = "Appendix:" .. self._lang:getCanonicalName() .. " " .. self._info.label
local appendix = mw.title.new(appendixName).exists
if appendix then
return appendixName
else
return nil
end
else
return nil
end
end

function Category:getCatfixInfo()
if self._lang or self._info.raw then
if self._data.catfix == false then
return nil
end
local lang, sc
if self._data.catfix then
lang = require("Module:languages").getByCode(self:substitute_template_specs(self._data.catfix), true, nil, nil, true)
else
lang = self._lang
end
if self._data.catfix_sc then
sc = require("Module:scripts").getByCode(self:substitute_template_specs(self._data.catfix_sc), true, nil, true)
else
sc = self._sc
end
return lang, sc
else -- umbrella
if not self._data.umbrella or not self._data.umbrella.catfix then
return nil
end
local lang = require("Module:languages").getByCode(self:substitute_template_specs(self._data.umbrella.catfix), true, nil, nil, true)
local sc = self:substitute_template_specs(self._data.umbrella.catfix_sc)
if sc then
sc = require("Module:scripts").getByCode(sc, true, nil, true)
end
return lang, sc
end
end

function Category:getTOCTemplateName()
local lang, sc = self:getCatfixInfo()
local code = lang and lang:getCode() or "en"
return "Template:" .. code .. "-" .. (self._data.toctemplateprefix or "") .. "categoryTOC"
end

function Category:getDisplay()
if self._data["display"] then
if self._lang then
return self._lang:getCanonicalName() .. " " .. self._data["display"]
else
return mw.getContentLanguage():ucfirst(self._data["display"]) .. " by language"
end
end
return nil
end

function Category:getDisplay2()
if self._data["display"] then
if self._lang then
return mw.getContentLanguage():ucfirst(self._data["display"])
else
return mw.getContentLanguage():ucfirst(self._data["display"]) .. " by language"
end
end
return nil
end

function Category:getSort()
return self._data["sort"]
end

return export

Module:Category tree/data