Unimage Wiki - 最近更改 [zh-hans]

模块:Quote

WikiAdmin — Mon, 31 Aug 2026 12:55:07 GMT

将 Fandom Dev 模块依赖切换到本地副本

←上一版本		2026年8月31日 (一) 20:55的版本
第3行：		第3行：
	-- The Fandom Developer's Wiki hosts Global Lua Modules that can be imported and locally overridden.		-- The Fandom Developer's Wiki hosts Global Lua Modules that can be imported and locally overridden.
	-- The next line imports the Quote module from the [[w:c:dev:Global Lua Modules]].		-- The next line imports the Quote module from the [[w:c:dev:Global Lua Modules]].
	local Quote = require('Dev:Quote')		local Quote = require('Module:Dev/Quote')
	-- See more details about this module at [[w:c:dev:Global_Lua_Modules/Quote]]		-- See more details about this module at [[w:c:dev:Global_Lua_Modules/Quote]]

	-- The last line produces the output for the template		-- The last line produces the output for the template
	return Quote		return Quote

模块:Navbox

WikiAdmin — Mon, 31 Aug 2026 12:55:05 GMT

将 Fandom Dev 模块依赖切换到本地副本

←上一版本		2026年8月31日 (一) 20:55的版本
第3行：		第3行：
	-- The Fandom Developer's Wiki hosts Global Lua Modules that can be imported and locally overridden.		-- The Fandom Developer's Wiki hosts Global Lua Modules that can be imported and locally overridden.
	-- The next line imports the Navbox module from the [[w:c:dev:Global Lua Modules]].		-- The next line imports the Navbox module from the [[w:c:dev:Global Lua Modules]].
	local N = require('Dev:Navbox')		local N = require('Module:Dev/Navbox')
	-- See more details about this module at [[w:c:dev:Global_Lua_Modules/Navbox]]		-- See more details about this module at [[w:c:dev:Global_Lua_Modules/Navbox]]

	-- The last line produces the output for the template		-- The last line produces the output for the template
	return N		return N

模块:Namespace detect/config

WikiAdmin — Mon, 31 Aug 2026 12:55:04 GMT

将 Fandom Dev 模块依赖切换到本地副本

←上一版本		2026年8月31日 (一) 20:55的版本
第3行：		第3行：
	-- The Fandom Developer's Wiki hosts Global Lua Modules that can be imported and locally overridden.		-- The Fandom Developer's Wiki hosts Global Lua Modules that can be imported and locally overridden.
	-- The next line imports from the [[w:c:dev:Global Lua Modules]].		-- The next line imports from the [[w:c:dev:Global Lua Modules]].
	local nsConfiguration = require('Dev:Namespace_detect/config')		local nsConfiguration = require('Module:Dev/Namespace_detect/config')
	-- See more details about this module at [[w:c:dev:Global_Lua_Modules/Namespace_detect]]		-- See more details about this module at [[w:c:dev:Global_Lua_Modules/Namespace_detect]]

模块:Namespace detect

WikiAdmin — Mon, 31 Aug 2026 12:55:03 GMT

将 Fandom Dev 模块依赖切换到本地副本

←上一版本		2026年8月31日 (一) 20:55的版本
第3行：		第3行：
	-- The Fandom Developer's Wiki hosts Global Lua Modules that can be imported and locally overridden.		-- The Fandom Developer's Wiki hosts Global Lua Modules that can be imported and locally overridden.
	-- The next line imports the Namespace_detect module from the [[w:c:dev:Global Lua Modules]].		-- The next line imports the Namespace_detect module from the [[w:c:dev:Global Lua Modules]].
	local NS = require('Dev:Namespace_detect')		local NS = require('Module:Dev/Namespace_detect')
	-- Local configuration can be modified in		-- Local configuration can be modified in
	-- [[Module:Namespace detect/data]] and		-- [[Module:Namespace detect/data]] and

模块:Mbox

WikiAdmin — Mon, 31 Aug 2026 12:55:01 GMT

将 Fandom Dev 模块依赖切换到本地副本

←上一版本		2026年8月31日 (一) 20:55的版本
第3行：		第3行：
	-- The Fandom Developer's Wiki hosts Global Lua Modules that can be imported and locally overridden.		-- The Fandom Developer's Wiki hosts Global Lua Modules that can be imported and locally overridden.
	-- The next line imports the Mbox module from the [[w:c:dev:Global Lua Modules]].		-- The next line imports the Mbox module from the [[w:c:dev:Global Lua Modules]].
	local Mbox = require('Dev:Mbox')		local Mbox = require('Module:Dev/Mbox')
	-- See more details about this module at [[w:c:dev:Global_Lua_Modules/Mbox]]		-- See more details about this module at [[w:c:dev:Global_Lua_Modules/Mbox]]

第18行：		第18行：
	--		--

	local getArgs = require('Dev:Arguments').getArgs		local getArgs = require('Module:Dev/Arguments').getArgs
	local localCSS = mw.loadData('Module:Mbox/data').localStyle		local localCSS = mw.loadData('Module:Mbox/data').localStyle

模块:I18n

WikiAdmin — Mon, 31 Aug 2026 12:55:00 GMT

将 Fandom Dev 模块依赖切换到本地副本

←上一版本		2026年8月31日 (一) 20:55的版本
第3行：		第3行：
	-- The Fandom Developer's Wiki hosts Global Lua Modules that can be imported and locally overridden.		-- The Fandom Developer's Wiki hosts Global Lua Modules that can be imported and locally overridden.
	-- The next line imports the I18n module from the [[w:c:dev:Global Lua Modules]].		-- The next line imports the I18n module from the [[w:c:dev:Global Lua Modules]].
	local i18n = require('Dev:I18n')		local i18n = require('Module:Dev/I18n')
	-- See more details about this module at [[w:c:dev:Global_Lua_Modules/I18n]]		-- See more details about this module at [[w:c:dev:Global_Lua_Modules/I18n]]

	-- The last line produces the output for the template		-- The last line produces the output for the template
	return i18n		return i18n

模块:Hatnote/i18n

WikiAdmin — Mon, 31 Aug 2026 12:54:59 GMT

将 Fandom Dev 模块依赖切换到本地副本

←上一版本		2026年8月31日 (一) 20:54的版本
第3行：		第3行：
	-- The Fandom Developer's Wiki hosts Global Lua Modules that can be imported and locally overridden.		-- The Fandom Developer's Wiki hosts Global Lua Modules that can be imported and locally overridden.
	-- The next line imports the Hatnote module from the [[w:c:dev:Global Lua Modules]].		-- The next line imports the Hatnote module from the [[w:c:dev:Global Lua Modules]].
	local Hi18n = require('Dev:Hatnote/i18n')		local Hi18n = require('Module:Dev/Hatnote/i18n')
	-- See more details about this module at [[w:c:dev:Global_Lua_Modules/Hatnote]]		-- See more details about this module at [[w:c:dev:Global_Lua_Modules/Hatnote]]

	-- The last line produces the output for the template		-- The last line produces the output for the template
	return Hi18n		return Hi18n

模块:Hatnote

WikiAdmin — Mon, 31 Aug 2026 12:54:58 GMT

将 Fandom Dev 模块依赖切换到本地副本

←上一版本		2026年8月31日 (一) 20:54的版本
第3行：		第3行：
	-- The Fandom Developer's Wiki hosts Global Lua Modules that can be imported and locally overridden.		-- The Fandom Developer's Wiki hosts Global Lua Modules that can be imported and locally overridden.
	-- The next line imports the Hatnote module from the [[w:c:dev:Global Lua Modules]].		-- The next line imports the Hatnote module from the [[w:c:dev:Global Lua Modules]].
	local H = require('Dev:Hatnote')		local H = require('Module:Dev/Hatnote')
	-- See more details about this module at [[w:c:dev:Global_Lua_Modules/Hatnote]]		-- See more details about this module at [[w:c:dev:Global_Lua_Modules/Hatnote]]

	-- The last line produces the output for the template		-- The last line produces the output for the template
	return H		return H

模块:Dialogue

WikiAdmin — Mon, 31 Aug 2026 12:54:57 GMT

将 Fandom Dev 模块依赖切换到本地副本

←上一版本		2026年8月31日 (一) 20:54的版本
第3行：		第3行：
	-- The Fandom Developer's Wiki hosts Global Lua Modules that can be imported and locally overridden.		-- The Fandom Developer's Wiki hosts Global Lua Modules that can be imported and locally overridden.
	-- The next line imports the Dialogue module from the [[w:c:dev:Global Lua Modules]].		-- The next line imports the Dialogue module from the [[w:c:dev:Global Lua Modules]].
	local Dialogue = require('Dev:Dialogue')		local Dialogue = require('Module:Dev/Dialogue')
	-- See more details about this module at [[w:c:dev:Global_Lua_Modules/Dialogue]]		-- See more details about this module at [[w:c:dev:Global_Lua_Modules/Dialogue]]

	-- The last line produces the output for the template		-- The last line produces the output for the template
	return Dialogue		return Dialogue

模块:Dev/Yesno

WikiAdmin — Mon, 31 Aug 2026 12:54:56 GMT

从 Fandom Developer Wiki 本地化全局模块，源修订 198227

新页面

-- 来源：https://dev.fandom.com/wiki/Module%3AYesno
-- 许可：CC BY-SA，作者与修订记录见来源页面
-- <nowiki>
--- Yesno module for processing of boolean-like wikitext input.
--
-- It works similarly to the [[wikipedia:Template:Yesno|Yesno Wikipedia
-- template]]. This module is a consistent Lua interface for wikitext
-- input from templates.
--
-- Wikitext markup used by MediaWiki templates only permit
-- string parameters like `"0"`, `"yes"`, `"no"` etc. As Lua
-- has a boolean primitive type, Yesno converts this
-- wikitext into boolean output for Lua to process.
--
-- @script yesno
-- @release stable
-- @author [[User:Dessamator|Dessamator]]
-- @attribution [[wikipedia:User:ATDT|ATDT]]
-- @attribution [[wikipedia:User:Mr. Stradivarius|Mr. Stradivarius]]
-- @attribution [[wikipedia:Special:PageHistory/Module:Yesno|Other Wikipedia contributors]]
-- @see [[wikipedia:Module:Yesno|Original module on
-- Wikipedia]]
-- @see [[Module:Yesno/testcases|Test cases for this
-- module]]
-- @param {?boolean|string} value Wikitext boolean-style
-- or Lua boolean input.
-- * Truthy wikitext input (`'yes'`, `'y'`, `'1'`,
-- `'t'` or `'on'`) produces `true` as output.
-- * The string representations of Lua's true
-- boolean value (`'true'`) also produces `true`.
-- * Falsy wikitext input (`'no'`, `'n'`, `'0'`,
-- `'f'` or `'off'`) produces `false` as output.
-- * The string representation of Lua's false
-- boolean value (`'false'`) also produces `false`.
-- * Localised text meaning `'yes'` or `'no'` also
-- evaluate to `true` or `false` respectively.
-- @param[opt] {?boolean|string} default Output to return if
-- the Yesno `value` input is unrecognised.
-- @return {?boolean} Boolean output corresponding to
-- `val`:
-- * The strings documented above produce a
-- boolean value.
-- * A `nil` value produces an output of `nil`.
-- As this is falsy, additional logic may be needed
-- to treat missing template parameters as truthy.
-- * Unrecognised values return the `default`
-- parameter. Blank strings are a key example
-- of Yesno's unrecognised values and can evaluate
-- to `true` if there is a default value.
local lower = mw.ustring.lower
local msg = mw.message.new

local yes = lower(msg('htmlform-yes'):plain())
local no = lower(msg('htmlform-no'):plain())
local en_yes = lower(msg('htmlform-yes'):inLanguage('en'):plain())
local en_no = lower(msg('htmlform-no'):inLanguage('en'):plain())

return function(value, default)
value = type(value) == 'string' and lower(value) or value

if value == nil then
return nil

elseif value == true
or value == yes
or value == en_yes
or value == 'y'
or value == 'true'
or value == 't'
or value == 'on'
or value == 'enable'
or tonumber(value) == 1
then
return true

elseif value == false
or value == no
or value == en_no
or value == 'n'
or value == 'false'
or value == 'f'
or value == 'off'
or value == 'disable'
or tonumber(value) == 0
then
return false

else
return default
end
end
-- </nowiki>

模块:Dev/TableTools

WikiAdmin — Mon, 31 Aug 2026 12:54:54 GMT

从 Fandom Developer Wiki 本地化全局模块，源修订 183115

新页面

-- 来源：https://dev.fandom.com/wiki/Module%3ATableTools
-- 许可：CC BY-SA，作者与修订记录见来源页面
-- <nowiki>
--------------------------------------------------------------------------------
-- This module includes a number of functions for dealing with Lua tables.
--
-- @script TableTools
-- @alias p
-- @release stable
-- @require [[mw:Extension:Scribunto/Lua_reference_manual#libraryUtil|libraryUtil]]
-- @attribution [[wikipedia:Module:TableTools|Module:TableTools]] (Wikipedia)
-- @see [[Wikipedia:Module:TableTools]] for a similar module.
--------------------------------------------------------------------------------
local p = {}
local libraryUtil = require('libraryUtil')

-- Define often-used variables and functions.
local floor = math.floor
local infinity = math.huge
local checkType = libraryUtil.checkType

--------------------------------------------------------------------------------
-- Returns a new table with all parameters stored into keys 1, 2, etc. and with
-- a field `n` with the total number of parameters. Note that the resulting
-- table may not be a sequence.
--
-- @function p.pack
-- @param[opt] ...
-- @return {table}
-- @see <http://www.lua.org/manual/5.2/manual.html#pdf-table.pack>
--------------------------------------------------------------------------------
function p.pack(...)
return {n = select('#', ...), ...}
end

--------------------------------------------------------------------------------
-- Returns the first `n` arguments in `...`. If `n` is negative, arguments are
-- counted from the end of the table.
--
-- @function p.selectFirst
-- @param {number} n
-- @param[opt] ...
-- @see [[Lua reference manual/Standard libraries#select]]
-- @see <http://lua-users.org/wiki/VarargTheSecondClassCitizen>
--------------------------------------------------------------------------------
function p.selectFirst(n, ...)
checkType('Module:Dev/TableTools.selectFirst', 1, n, 'number')

local function err()
error('bad argument #1 to \'Module:Dev/TableTools.selectFirst\' ' ..
'(index out of range)')
end

local function recurse(index, next, ...)
if index == 0 then
return
end

return next, recurse(index - 1, ...)
end

n = math.modf(n)

local count = select("#", ...)

if -count > n then
err()
elseif -1 > n and n >= -count then
return recurse(count + 1 + n, ...)
elseif n == -1 then
return ...
elseif n == 0 then
err()
elseif n == 1 then
return (...)
elseif 1 < n and n <= count then
return recurse(n, ...)
elseif count < n then
return ...
end
end

--------------------------------------------------------------------------------
-- Returns `true` if a given table is a sequence.
--
-- @function p.isSequence
-- @param {table} t
-- @return {boolean}
-- @see <http://stackoverflow.com/a/6080274>
--------------------------------------------------------------------------------
function p.isSequence(t)
checkType('Module:Dev/TableTools.isSequence', 1, t, 'table')

local i = 1

for _ in pairs(t) do
if t[i] == nil then
return false
end

i = i + 1
end

return true
end

--------------------------------------------------------------------------------
-- Returns the number of elements in a table, even if it is not a sequence.
--
-- @function p.size
-- @param {table} t
-- @return {number}
-- @see <http://stackoverflow.com/a/2705804>
--------------------------------------------------------------------------------
function p.size(t)
checkType('Module:Dev/TableTools.size', 1, t, 'table')

local i = 0

for _ in pairs(t) do
i = i + 1
end

return i
end

--------------------------------------------------------------------------------
-- Returns `true` if a given table contains a certain element.
--
-- @function p.includes
-- @param {table} t
-- @param elm
-- @return {boolean}
-- @see <http://stackoverflow.com/q/2282444>
--------------------------------------------------------------------------------
function p.includes(t, elm)
checkType('Module:Dev/TableTools.includes', 1, t, 'table')

for _, v in pairs(t) do
if v == elm then
return true
end
end

return false
end

--------------------------------------------------------------------------------
-- Merges the content of the second table with the content in the first one.
--
-- @function p.merge
-- @param {table} dest
-- @param {table} source
-- @return {table}
-- @see <http://wiki.garrysmod.com/page/table/Merge>
--------------------------------------------------------------------------------
function p.merge(dest, source)
checkType('Module:Dev/TableTools.merge', 1, dest, 'table')
checkType('Module:Dev/TableTools.merge', 2, source, 'table')

for k, v in pairs(source) do
if type(v) == 'table' and type(dest[k]) == 'table' then
-- Don't overwrite one table with another; instead merge them
-- recurisvely.
p.merge(dest[k], v)
else
dest[k] = v
end
end

return dest
end

------------------------------------------------------------------------------------
-- This function returns true if the given value is a positive integer, and false
-- if not. Although it doesn't operate on tables, it is included here as it is
-- useful for determining whether a given table key is in the array part or the
-- hash part of a table.
--
-- @function p.isPositiveInteger
-- @param v
-- @return {boolean}
------------------------------------------------------------------------------------
function p.isPositiveInteger(v)
if type(v) == 'number' and v >= 1 and floor(v) == v and v < infinity then
return true
else
return false
end
end

------------------------------------------------------------------------------------
-- This function returns true if the given number is a NaN value, and false
-- if not. Although it doesn't operate on tables, it is included here as it is
-- useful for determining whether a value can be a valid table key. Lua will
-- generate an error if a NaN is used as a table key.
--
-- @function p.isNan
-- @param v
-- @return {boolean}
------------------------------------------------------------------------------------
function p.isNan(v)
if type(v) == 'number' and tostring(v) == '-nan' then
return true
else
return false
end
end

------------------------------------------------------------------------------------
-- This returns a clone of a table. The value returned is a new table, but all
-- subtables and functions are shared. Metamethods are respected, but the returned
-- table will have no metatable of its own.
--
-- @function p.shallowClone
-- @param {table} t
-- @return {table}
------------------------------------------------------------------------------------
function p.shallowClone(t)
local ret = {}
for k, v in pairs(t) do
ret[k] = v
end
return ret
end

------------------------------------------------------------------------------------
-- This removes duplicate values from an array. Non-positive-integer keys are
-- ignored. The earliest value is kept, and all subsequent duplicate values are
-- removed, but otherwise the array order is unchanged.
--
-- @function p.removeDuplicates
-- @param {table} t
-- @return {table}
------------------------------------------------------------------------------------
function p.removeDuplicates(t)
checkType('removeDuplicates', 1, t, 'table')
local isNan = p.isNan
local ret, exists = {}, {}
for i, v in ipairs(t) do
if isNan(v) then
-- NaNs can't be table keys, and they are also unique, so we don't need to check existence.
ret[#ret + 1] = v
else
if not exists[v] then
ret[#ret + 1] = v
exists[v] = true
end
end
end
return ret
end

------------------------------------------------------------------------------------
-- This takes a table and returns an array containing the numbers of any numerical
-- keys that have non-nil values, sorted in numerical order.
--
-- @function p.numKeys
-- @param {table} t
-- @return {table}
------------------------------------------------------------------------------------
function p.numKeys(t)
checkType('numKeys', 1, t, 'table')
local isPositiveInteger = p.isPositiveInteger
local nums = {}
for k, v in pairs(t) do
if isPositiveInteger(k) then
nums[#nums + 1] = k
end
end
table.sort(nums)
return nums
end

------------------------------------------------------------------------------------
-- This takes a table and returns an array containing the numbers of keys with the
-- specified prefix and suffix. For example, for the table
-- {a1 = 'foo', a3 = 'bar', a6 = 'baz'} and the prefix "a", affixNums will
-- return {1, 3, 6}.
--
-- @function p.affixNums
-- @param {table} t
-- @param[opt] {boolean} prefix
-- @param[opt] {boolean} suffix
-- @return {table}
------------------------------------------------------------------------------------
function p.affixNums(t, prefix, suffix)
checkType('affixNums', 1, t, 'table')
checkType('affixNums', 2, prefix, 'string', true)
checkType('affixNums', 3, suffix, 'string', true)

local function cleanPattern(s)
-- Cleans a pattern so that the magic characters ()%.[]*+-?^$ are interpreted literally.
s = s:gsub('([%(%)%%%.%[%]%*%+%-%?%^%$])', '%%%1')
return s
end

prefix = prefix or ''
suffix = suffix or ''
prefix = cleanPattern(prefix)
suffix = cleanPattern(suffix)
local pattern = '^' .. prefix .. '([1-9]%d*)' .. suffix .. '$'

local nums = {}
for k, v in pairs(t) do
if type(k) == 'string' then
local num = mw.ustring.match(k, pattern)
if num then
nums[#nums + 1] = tonumber(num)
end
end
end
table.sort(nums)
return nums
end

------------------------------------------------------------------------------------
-- Given a table with keys like ("foo1", "bar1", "foo2", "baz2"), returns a table
-- of subtables in the format
-- { [1] = {foo = 'text', bar = 'text'}, [2] = {foo = 'text', baz = 'text'} }
-- Keys that don't end with an integer are stored in a subtable named "other".
-- The compress option compresses the table so that it can be iterated over with
-- ipairs.
--
-- @function p.numData
-- @param {table} t
-- @param[opt] {boolean} compress
-- @return {table}
------------------------------------------------------------------------------------
function p.numData(t, compress)
checkType('numData', 1, t, 'table')
checkType('numData', 2, compress, 'boolean', true)
local ret = {}
for k, v in pairs(t) do
local prefix, num = mw.ustring.match(tostring(k), '^([^0-9]*)([1-9][0-9]*)$')
if num then
num = tonumber(num)
local subtable = ret[num] or {}
if prefix == '' then
-- Positional parameters match the blank string; put them at the start of the subtable instead.
prefix = 1
end
subtable[prefix] = v
ret[num] = subtable
else
local subtable = ret.other or {}
subtable[k] = v
ret.other = subtable
end
end
if compress then
local other = ret.other
ret = p.compressSparseArray(ret)
ret.other = other
end
return ret
end

------------------------------------------------------------------------------------
-- This takes an array with one or more nil values, and removes the nil values
-- while preserving the order, so that the array can be safely traversed with
-- ipairs.
--
-- @function p.compressSparseArray
-- @param {table} t
-- @return {table}
------------------------------------------------------------------------------------
function p.compressSparseArray(t)
checkType('compressSparseArray', 1, t, 'table')
local ret = {}
local nums = p.numKeys(t)
for _, num in ipairs(nums) do
ret[#ret + 1] = t[num]
end
return ret
end

------------------------------------------------------------------------------------
-- This is an iterator for sparse arrays. It can be used like ipairs, but can
-- handle nil values.
--
-- @function p.sparseIpairs
-- @param {table} t
-- @return {function}
------------------------------------------------------------------------------------
function p.sparseIpairs(t)
checkType('sparseIpairs', 1, t, 'table')
local nums = p.numKeys(t)
local i = 0
local lim = #nums
return function ()
i = i + 1
if i <= lim then
local key = nums[i]
return key, t[key]
else
return nil, nil
end
end
end

------------------------------------------------------------------------------------
-- This returns the length of a table, or the first integer key n counting from
-- 1 such that t[n + 1] is nil. It is similar to the operator #, but may return
-- a different value when there are gaps in the array portion of the table.
-- Intended to be used on data loaded with mw.loadData. For other tables, use #.
-- Note: #frame.args in frame object always be set to 0, regardless of
-- the number of unnamed template parameters, so use this function for
-- frame.args.
--
-- @function p.length
-- @param {table} t
-- @return {number}
------------------------------------------------------------------------------------
function p.length(t)
local i = 1
while t[i] ~= nil do
i = i + 1
end
return i - 1
end

return p

-- </nowiki>
-- (Add categories here.)

模块:Dev/Quote/i18n

WikiAdmin — Mon, 31 Aug 2026 12:54:54 GMT

从 Fandom Developer Wiki 本地化全局模块，源修订 205803

新页面

-- 来源：https://dev.fandom.com/wiki/Module%3AQuote/i18n
-- 许可：CC BY-SA，作者与修订记录见来源页面
-- <nowiki>
return {
["_metadata"] = {
["order"] = {
"align",
"class",
"context",
"person",
"personquoted",
"quote",
"quotesource",
"quotetext",
"quotewidth",
"source",
"speaker",
"style",
"text",
"width"
}
},
["en"] = {
["align"] = "align",
["class"] = "class",
["context"] = "context",
["person"] = "person",
["personquoted"] = "personquoted",
["quote"] = "quote",
["quotesource"] = "quotesource",
["quotetext"] = "quotetext",
["quotewidth"] = "quotewidth",
["source"] = "source",
["speaker"] = "speaker",
["style"] = "style",
["text"] = "text",
["width"] = "width"
},
["de"] = {
["align"] = "textausrichtung",
["class"] = "klasse",
["context"] = "kontext",
["person"] = "person",
["personquoted"] = "zitierte person",
["quote"] = "zitat",
["quotesource"] = "zitatquelle",
["quotetext"] = "zitattext",
["quotewidth"] = "zitatbreite",
["source"] = "quelle",
["speaker"] = "sprecher",
["style"] = "style",
["text"] = "text",
["width"] = "breite"
},
["et"] = {
["align"] = "joondus",
["class"] = "klass",
["context"] = "kontekst",
["person"] = "isik",
["personquoted"] = "tsiteeritudisik",
["quote"] = "tsitaat",
["quotesource"] = "tsitaadiallikas",
["quotetext"] = "tsitaaditekst",
["quotewidth"] = "tsitaadilaius",
["source"] = "alikas",
["speaker"] = "kõneleja",
["style"] = "stiil",
["text"] = "tekst",
["width"] = "laius"
},
["hi"] = {
["align"] = "संरेखण",
["class"] = "क्लास",
["context"] = "प्रसंग",
["person"] = "व्यक्ति",
["personquoted"] = "personquoted",
["quote"] = "उद्धरण",
["quotesource"] = "quotesource",
["quotetext"] = "quotetext",
["quotewidth"] = "quotewidth",
["source"] = "स्रोत",
["speaker"] = "वक्ता",
["style"] = "स्टाइल",
["text"] = "टेक्स्ट",
["width"] = "चौड़ाई"
},
["pl"] = {
["align"] = "wyrównanie",
["class"] = "klasa",
["context"] = "kontekst",
["person"] = "osoba",
["personquoted"] = "cytowana osoba",
["quote"] = "cytat",
["quotesource"] = "źródło cytatu",
["quotetext"] = "tekst cytatu",
["quotewidth"] = "szerokość cytatu",
["source"] = "źródło",
["speaker"] = "mówca",
["style"] = "style",
["text"] = "tekst",
["width"] = "szerokość"
},
["pt-br"] = {
["align"] = "alinhar",
["class"] = "class",
["context"] = "contexto",
["person"] = "pessoa",
["personquoted"] = "citado por pessoa",
["quote"] = "citação",
["quotesource"] = "fonte da citação",
["quotetext"] = "textp da citação",
["quotewidth"] = "largura da citação",
["source"] = "fonte",
["speaker"] = "orador",
["style"] = "estilo",
["text"] = "texto",
["width"] = "largura"
},
["ru"] = {
["align"] = "align",
["class"] = "class",
["context"] = "context",
["person"] = "person",
["personquoted"] = "personquoted",
["quote"] = "цитата",
["quotesource"] = "quotesource",
["quotetext"] = "quotetext",
["quotewidth"] = "quotewidth",
["source"] = "источник",
["speaker"] = "автор",
["style"] = "style",
["text"] = "text",
["width"] = "width"
},
["th"] = {
["context"] = "ข้อมูล",
["person"] = "บุคคล",
["style"] = "ลักษณะ",
["width"] = "กว้าง"
},
["tl"] = {
["align"] = "paghahanay",
["class"] = "klase",
["context"] = "konteksto",
["person"] = "tao",
["personquoted"] = "",
["quote"] = "quote",
["quotesource"] = "pinagmulanngquote",
["quotetext"] = "tekstongquote",
["quotewidth"] = "lapadngquote",
["source"] = "pinagkukunan",
["speaker"] = "tagapagsalita",
["style"] = "istilo",
["text"] = "teksto",
["width"] = "haba"
},
["tr"] = {
["align"] = "hizalama",
["class"] = "sınıf",
["context"] = "bağlam",
["person"] = "kişi",
["personquoted"] = "kişitırnağı",
["quote"] = "ksöz",
["quotesource"] = "tırnakkaynağı",
["quotetext"] = "tırnakmetni",
["quotewidth"] = "tırnakgenişliği",
["source"] = "kaynak",
["speaker"] = "sözcü",
["style"] = "stil",
["text"] = "metin",
["width"] = "genişlik"
},
["vi"] = {
["align"] = "căn",
["class"] = "lớp",
["context"] = "nội dung",
["person"] = "người",
["personquoted"] = "người nói",
["quote"] = "trích dẫn",
["quotesource"] = "nguồn trích dẫn",
["quotetext"] = "văn bản trích dẫn",
["quotewidth"] = "chiều dài trích dẫn",
["source"] = "nguồn",
["speaker"] = "diễn giả",
["style"] = "kiểu dáng",
["text"] = "văn bản",
["width"] = "chiều dài"
}
}
-- </nowiki>

模块:Dev/Quote

WikiAdmin — Mon, 31 Aug 2026 12:54:53 GMT

从 Fandom Developer Wiki 本地化全局模块，源修订 214339

新页面

-- 来源：https://dev.fandom.com/wiki/Module%3AQuote
-- 许可：CC BY-SA，作者与修订记录见来源页面
-- <nowiki>
local Quote = {}
local getArgs = require('Module:Dev/Arguments').getArgs
local i18n = require('Module:Dev/I18n').loadMessages('Quote')

local function build(quote_contents, quote_source, options)
local quote_container = mw.html.create('blockquote')
:addClass('pull-quote')
:addClass(options.align)
:addClass(options.extraclasses)
:css(options.styles)
:cssText(options.extrastyles)
:node(quote_contents)

if quote_source then
quote_container:tag('div')
:addClass('pull-quote__source')
:tag('cite')
:wikitext(quote_source)
:done()
:done()
end

return quote_container
end

local function options(args)
local options = {}

options.styles = {}
options.extraclasses = i18n:parameter('class', args)
options.extrastyles = i18n:parameter('style', args)
options.align = ''
local align = i18n:parameter('align', args)
if align then
options.align = 'pull-quote--' .. align
options.styles['width'] = i18n:parameter('width', args) or
i18n:parameter('quotewidth', args) or
'300px'
end

return options
end

-- let MediaWiki parser auto-generate <p> tags
local function paragraph(quotetext)
return '\n' .. quotetext .. '\n'
end

function Quote.quote(frame)
local args = getArgs(frame)

local options = options(args)

local quotetext = args[1] or
i18n:parameter('quotetext', args) or
i18n:parameter('quote', args) or
i18n:parameter('text', args) or ''

local person = args[2] or
i18n:parameter('person', args) or
i18n:parameter('speaker', args) or
i18n:parameter('personquoted', args) or nil

local source = args[3] or
i18n:parameter('source', args) or
i18n:parameter('quote_source', args) or nil

local quote_contents = mw.html.create('div')
:addClass('pull-quote__text')
:wikitext(paragraph(quotetext))

local quote_source = person

if person and source then
quote_source = person .. ', ' .. source
elseif source then
quote_source = source
end

return build(quote_contents, quote_source, options)
end

function Quote.dialogue(frame)
local args = getArgs(frame)

local options = options(args)

local quote_contents = mw.html.create('div')
:addClass('pull-quote__text')

local quote_source

for i, v in ipairs(args) do
local next_param = i + 1

if i % 2 ~= 0 then
quote_contents:tag('div')
:addClass('pull-quote__line')
:tag('strong')
:addClass('pull-quote__speaker')
:wikitext(v .. ':')
:done()
:wikitext(' ' .. paragraph(args[next_param]))
:done()
end
end

local context = i18n:parameter('context', args)
local source = i18n:parameter('source', args)
if context and source then
quote_source = context .. ', ' .. source
elseif context and not source then
quote_source = context
elseif source and not context then
quote_source = source
end

return build(quote_contents, quote_source, options)

end

return Quote
-- </nowiki>

模块:Dev/Navbox/i18n

WikiAdmin — Mon, 31 Aug 2026 12:54:52 GMT

从 Fandom Developer Wiki 本地化全局模块，源修订 209224

新页面

-- 来源：https://dev.fandom.com/wiki/Module%3ANavbox/i18n
-- 许可：CC BY-SA，作者与修订记录见来源页面
-- <nowiki>
return {
["_metadata"] = {
["order"] = {
"hide",
"show"
}
},
["en"] = {
["hide"] = "Hide",
["show"] = "Show"
},
["qqq"] = {
["hide"] = "\"Hide\" button (i.e. collapse the navbox).",
["show"] = "\"Show\" button (i.e. expand the navbox)."
},
["de"] = {
["hide"] = "Einklappen",
["show"] = "Ausklappen"
},
["es"] = {
["hide"] = "Ocultar",
["show"] = "Mostrar"
},
["fr"] = {
["hide"] = "Réduire",
["show"] = "Développer"
},
["hi"] = {
["hide"] = "छिपाएँ",
["show"] = "दिखाएँ"
},
["ja"] = {
["hide"] = "隠す",
["show"] = "表示"
},
["pt-br"] = {
["hide"] = "Ocultar",
["show"] = "Mostrar"
},
["ru"] = {
["hide"] = "Скрыть",
["show"] = "Показать"
},
["vi"] = {
["hide"] = "Ẩn",
["show"] = "Hiện"
},
["zh-hans"] = {
["hide"] = "隐藏",
["show"] = "显示"
},
["zh-hant"] = {
["hide"] = "隱藏",
["show"] = "顯示"
},
["zh-hk"] = {
["hide"] = "隱藏",
["show"] = "顯示"
}
}
-- </nowiki>

模块:Dev/Navbox

WikiAdmin — Mon, 31 Aug 2026 12:54:51 GMT

从 Fandom Developer Wiki 本地化全局模块，源修订 210054

新页面

-- 来源：https://dev.fandom.com/wiki/Module%3ANavbox
-- 许可：CC BY-SA，作者与修订记录见来源页面
--------------------------------------------------------------------
--<pre> Navbox Module
--
-- * Fully CSS styled (inline styles possible but not default)
-- * Supports unlimited rows
-- * Automatic striping alternation, including for child navbox subsections
--
-- Original module by User:Tjcool007 from layton.fandom.com
--------------------------------------------------------------------

local p = {}

local i18n = require('Module:Dev/i18n').loadMessages('Navbox')

local showText, hideText = i18n:useLanguageConversionType('userLanguage'):msg('show'), i18n:useLanguageConversionType('userLanguage'):msg('hide')

local showText_zh_hans, hideText_zh_hans = i18n:inLang('zh-hans'):msg('show'), i18n:inLang('zh-hans'):msg('hide')
local showText_zh_hant, hideText_zh_hant = i18n:inLang('zh-hant'):msg('show'), i18n:inLang('zh-hant'):msg('hide')
local showText_zh_hant_hk, hideText_zh_hant_hk = i18n:inLang('zh-hk'):msg('show'), i18n:inLang('zh-hk'):msg('hide')

local cfg = {
marker = {
oddeven = '\127_ODDEVEN_\127',
contains_subgroup = '\127_ODDEVEN0_\127',
restart_header = '\127_ODDEVEN1_\127',
regex_changer = '\127_ODDEVEN([01]?)_\127',
odd = '\127_ODD_\127',
even = '\127_EVEN_\127',
oddeven_sep = '\127_ODDEVEN2_\127',
oddeven_end = '\127_ODDEVEN3_\127',
regex_oddeven_sep = '\127_ODDEVEN[23]_\127',
regex_odd = '(\127_ODD_\127[^\127]*)\127_ODDEVEN2_\127([^\127]*)\127_ODDEVEN2_\127[^\127]*\127_ODDEVEN3_\127',
regex_even = '(\127_EVEN_\127[^\127]*)\127_ODDEVEN2_\127[^\127]*\127_ODDEVEN2_\127([^\127]*)\127_ODDEVEN3_\127'
},
pattern = {
hlist = 'hlist',
plainlist = 'plainlist',
},

category = {
error = '[[Category:Navboxes with internal errors]]',
orphan = '[[Category:Navbox orphans]]'
}
}

------------------------------------------------
-- ARGUMENTS PREPROCESSOR
-- * Extracts arguments from frame and stores them in args table
-- * At the same time, checks for valid row numbers
------------------------------------------------

--- Preprocessor for the arguments.
-- Will fill up the args table with the parameters from the frame grouped by their type.
--
-- @param frame The frame passed to the Module.
local function preProcessArgs(frame)
local tmp, args, rownums, skiprows = {}, {}, {}, {}

if frame == mw.getCurrentFrame() then
tmp = frame:getParent().args
else
tmp = frame
end

-- Storage tables
local nums, subnums = {}, {}

-- Loop over all the args
for k, v in pairs(tmp) do
-- Skip empty args, which are useless
if v ~= '' then
local str = tostring(k)
local cat, num, subnum = str:match('^(%a+)([1-9]%d*)%.([1-9][%d%.]*)$')
if subnum then
nums[num] = true
if type(subnums[num]) ~= "table" then
subnums[num] = {}
end
subnums[num][cat..subnum] = v
else
cat, num = str:match('^(%a+)([1-9]%d*)$')
if cat == 'header' or cat == 'list' then
nums[num] = true
end
args[k] = v -- Simple copy
end
end
end

-- Generate child navboxes
for k, v in pairs(subnums) do
for _, arg in ipairs({'showall', 'alternaterows', 'titlestyle', 'titleclass', 'abovestyle', 'aboveclass', 'rowclass', 'altrowclass', 'groupstyle', 'groupclass', 'altgroupstyle', 'altgroupclass', 'liststyle', 'listclass', 'altliststyle', 'altlistclass', 'belowstyle', 'belowclass', 'defaultstate', 'defaultcollapsetext', 'defaultexpandtext'}) do
v[arg] = args[arg]
end
v.border = 'child'
args['list'..k] = p.main(v)
end

for k, v in pairs(nums) do
rownums[#rownums+1] = tonumber(k)
end

table.sort(rownums)

-- Calculate skip rows
local cSection, cSkip
local showall = args.showall
for i=1,#rownums do
local num = rownums[i]
if args['header'..num] then
cSection = true
cSkip = false
local showme = args['show'..num]
if showme == 'no' then
cSkip = true
elseif showme == 'auto' or (showme ~= 'yes' and showall ~= 'yes') then
if not args['list'..num] then
local nextNum = rownums[i+1]
cSkip = not nextNum or args['header'..nextNum] -- If next has a header -> skip
end
end
end
if cSection and cSkip then
skiprows[num] = true
end
end

-- Insert markers into class and style parameters where needed
for i, v in ipairs({'groupclass', 'groupstyle', 'listclass', 'liststyle'}) do
if args['alt' .. v] then
args[v] = cfg.marker.oddeven_sep .. (args[v] or '') .. cfg.marker.oddeven_sep .. args['alt' .. v] .. cfg.marker.oddeven_end
end
end

return args, rownums, skiprows
end

------------------------------------------------
-- MAIN FUNCTIONS
------------------------------------------------

--- Processes the arguments to create the navbox.
--
-- @return A string with HTML that is the navbox.
local function _navbox(args, rownums, skiprows)
local navbox -- Actual navbox
local navbox_zh_hans, navbox_zh_hant, navbox_zh_hant_hk

local hasrows, hasData, hasTitle, hasChild = false, false, false, false
local activeSection, sections, cimage, cimageleft

local border = args.border or mw.text.trim(args[1] or '') or ''
if border == 'child' then border = 'subgroup' end
local isChild = (border == 'subgroup')

local colspan = args.image and 3 or 2
if args.imageleft then colspan = colspan + 1 end
local rowspan = 0

-- Language converter support
local useZhConverter = false
if mw.language.getContentLanguage():toBcp47Code() == 'zh' then
useZhConverter = true
end

--- Wraps text in newlines if it begins with a list or table
local function processItem(item)
if item:sub(1, 2) == '{|' then
return '\n' .. item ..'\n'
end
if item:match('^[*:;#]') then
return '\n' .. item ..'\n'
end
return item
end

--- Returns navbox contents with markers replaced for odd/even striping
local function striped(wikitext, border)
-- Child (subgroup) navboxes are flagged with a category that is removed
-- by parent navboxes. The result is that the category shows all pages
-- where a child navbox is not contained in a parent navbox.
local orphanCat = cfg.category.orphan
if border == 'subgroup' and args.orphan ~= 'yes' then
-- No change; striping occurs in outermost navbox.
return wikitext .. orphanCat
end
local altrowclass = args.altrowclass or 'alt'
altrowclass = ' ' .. altrowclass
local first, second = '', altrowclass
if args.alternaterows then
if args.alternaterows == 'swap' then
first, second = second, first
elseif args.alternaterows == 'no' or args.alternaterows == 'odd' then
second = ''
elseif args.alternaterows == 'even' then
first = altrowclass
else
first = args.alternaterows
second = first
end
end
local changer
if first == second then
changer = cfg.marker.odd
else
local index = 0
changer = function (code)
if code == '0' then
-- Subgroup encountered.
-- Return a marker without incrementing the index.
return index % 2 == 0 and cfg.marker.odd or cfg.marker.even
elseif code == '1' then
-- Title or header encountered.
-- Restart the index and remove the marker.
-- The next occurrence will use the initial class.
index = 0
return ''
end
index = index + 1
return index % 2 == 1 and cfg.marker.odd or cfg.marker.even
end
end
local regex = orphanCat:gsub('([%[%]])', '%%%1')
wikitext = wikitext:gsub(regex, ''):gsub(cfg.marker.regex_changer, changer)
local prevWikitext, hasNoMoreOddevenMarkers
repeat
prevWikitext = wikitext
wikitext = wikitext:gsub(cfg.marker.regex_odd, '%1%2'):gsub(cfg.marker.regex_even, '%1%2')
hasNoMoreOddevenMarkers = wikitext:match(cfg.marker.regex_oddeven_sep) == nil
until hasNoMoreOddevenMarkers or wikitext == prevWikitext
wikitext = wikitext:gsub(cfg.marker.odd, first):gsub(cfg.marker.even, second)
if not hasNoMoreOddevenMarkers then
-- Something went wrong. Flag for investigation.
-- See <https://discord.com/channels/246075715714416641/1266361437484486778> for details.
wikitext = wikitext .. cfg.category.error
end
return wikitext
end

------------------------------------------------
-- Title
------------------------------------------------

--- Processes the VDE links in the title
--
-- @param titlecell The table cell of the title
local function processVde( titlecell )
if not args.template then return end

titlecell:wikitext('<span class="navbox-vde">'
.. mw.getCurrentFrame():expandTemplate({
title = 'vdelinks',
args = { args.template, ['type'] = 'navbox' }
}) .. '</span>')
end

--- Processes the main title row
local function processTitle()
if not hasTitle then return end

local titlerow = mw.html.create('tr'):addClass('navbox-title'..cfg.marker.restart_header)
local titlecell = mw.html.create('th'):attr('colspan',colspan):attr('scope','col')
local titlediv = mw.html.create('div')

if not pcall( processVde, titlecell ) then
titlediv:wikitext( '<b class="navbox-vde error" title="Missing Template:Vdelinks">!!!</b>' )
end

titlediv:wikitext( args.title or '{{{title}}}' )

-- Padding
local hasTemplate = args.template ~= nil
local hasState = not args.state or args.state ~= 'plain'

if hasTemplate or hasState then
-- remove redundant classes in future if it won't break the display of wikis' navboxes
titlediv:addClass('navbox-title-pad navbox-title-padleft navbox-title-padright')
end

if args.titleclass then titlerow:addClass( args.titleclass ) end
if args.titlestyle then titlecell:cssText( args.titlestyle ) end

titlecell:node(titlediv)
titlerow:node(titlecell)

if useZhConverter then
navbox_zh_hans:node(titlerow)
navbox_zh_hant:node(titlerow)
navbox_zh_hant_hk:node(titlerow)
else
navbox:node(titlerow)
end
end

local function _addGutter( parent, incRowspan )
parent:tag('tr'):addClass('navbox-gutter'):tag('td'):attr('colspan',2)

if incRowspan then
rowspan = rowspan + 1
end
end

------------------------------------------------
-- Above/Below
------------------------------------------------

--- Processes the above and below rows
--
-- @param rowtype Either 'above' or 'below'
local function processAboveBelow( rowtype )
if not args[rowtype] then return end

local abrow = mw.html.create('tr'):addClass('navbox-'..rowtype)
local abcell = mw.html.create('td'):attr('colspan',colspan):wikitext( processItem(args[rowtype]) )

if args[rowtype .. 'class'] then abrow:addClass( args[rowtype .. 'class'] ) end
if args[rowtype .. 'style'] then abcell:cssText( args[rowtype .. 'style'] ) end

abrow:node( abcell )
if hasTitle or rowtype == 'below' then
if useZhConverter then
_addGutter( navbox_zh_hans )
_addGutter( navbox_zh_hant )
_addGutter( navbox_zh_hant_hk )
else
_addGutter( navbox )
end
end

if useZhConverter then
navbox_zh_hans:node( abrow )
navbox_zh_hant:node( abrow )
navbox_zh_hant_hk:node( abrow )
else
navbox:node( abrow )
end
end

------------------------------------------------
-- Main Rows
------------------------------------------------

--- Processes the images
local function _processImage(row, imgtype)
if not args[imgtype] then return end

local iclass = imgtype == 'image' and 'navbox-image-right' or 'navbox-image-left'

local imagecell = mw.html.create('td'):addClass('navbox-image'):addClass(iclass)

local image = args[imgtype]
if image:sub(1,1) ~= '[' then
local width = args[imgtype .. 'width'] or '100px'
imagecell:css('width',width):wikitext('['..'[' .. image .. '|' .. width .. '|link=' .. (args[imgtype .. 'link'] or '') .. ']]')
else
imagecell:css('width','0%'):wikitext(image)
end

if args[imgtype .. 'class'] then imagecell:addClass( args[imgtype .. 'class'] ) end
if args[imgtype .. 'style'] then imagecell:cssText( args[imgtype .. 'style'] ) end

row:node( imagecell )
if imgtype == 'image' then
cimage = imagecell
else
cimageleft = imagecell
end
end

--- Closes the currently active section (if any)
local function _closeCurrentSection()
if not activeSection then return end

local row = mw.html.create('tr'):addClass('navbox-section-row')
local cell = mw.html.create('td'):attr('colspan', 2)

if not hasrows then
_processImage(row, 'imageleft')
end

cell:node(sections[activeSection])
row:node(cell)

local firstRow = false
if not hasrows then
firstRow = true
hasrows = true
_processImage(row, 'image')
end

if not isChild or not firstRow or hasTitle or args.above then
if useZhConverter then
_addGutter(navbox_zh_hans, not firstRow)
_addGutter(navbox_zh_hant, not firstRow)
_addGutter(navbox_zh_hant_hk, not firstRow)
else
_addGutter(navbox, not firstRow)
end
end

if useZhConverter then
navbox_zh_hans:node(row)
navbox_zh_hant:node(row)
navbox_zh_hant_hk:node(row)
else
navbox:node(row)
end

rowspan = rowspan + 1

activeSection = false
hasData = false
end

--- Process a single Header "row"
--
-- @param num Number of the row to be processed
local function processHeader(num)
if not args['header'..num] then return end

_closeCurrentSection()

local subtable = mw.html.create('table'):addClass('navbox-section')
local headerrow = mw.html.create('tr')
local header = mw.html.create('th'):addClass('navbox-header'..cfg.marker.restart_header):attr('colspan',2):attr('scope','col')
local headerdiv = mw.html.create('div'):wikitext( args['header'..num] )

local collapseme = args['state'..num] or false
local state = false

if collapseme then
-- Look at this one
if collapseme ~= 'plain' then
state = collapseme == 'expanded' and 'expanded' or 'collapsed'
end
else
-- Look at default
local collapseall = args.defaultstate or false
if collapseall then
state = collapseall == 'expanded' and 'expanded' or 'collapsed'
end
end

if state then
subtable:addClass('mw-collapsible'):attr('data-expandtext',args['expandtext'..num] or args['defaultexpandtext'] or showText):attr('data-collapsetext',args['collapsetext'..num] or args['defaultcollapsetext'] or hideText)
if state == 'collapsed' then
subtable:addClass('mw-collapsed')
end
-- remove redundant classes in future if it won't break the display of wikis' navboxes
headerdiv:addClass('navbox-header-pad navbox-title-padleft navbox-title-padright')
end

if args.headerclass then headerrow:addClass( args.headerclass ) end
if args.headerstyle then header:cssText( args.headerstyle ) end

header:node(headerdiv)
headerrow:node(header)
subtable:node(headerrow)

sections[num] = subtable
activeSection = num
end

-- Check if a string contains a particular CSS class
local function hasListClass(htmlclass, arg)
local patterns = {
'^' .. htmlclass .. '$',
'%s' .. htmlclass .. '$',
'^' .. htmlclass .. '%s',
'%s' .. htmlclass .. '%s'
}

for _, pattern in ipairs(patterns) do
if mw.ustring.find(args[arg] or '', pattern) then
return true
end
end
return false
end

--- Processes a single list row
--
-- @param num Number of the row to be processed
local function processList(num)
if not args['list'..num] then return end

local oddEven = cfg.marker.oddeven

local data = args['list'..num]

hasChild = false

if data:sub(1, 12) == '</div><table' then
hasChild = true
oddEven = cfg.marker.contains_subgroup
end

local row = mw.html.create('tr'):addClass('navbox-row'..oddEven)

if not hasrows and not activeSection then
_processImage(row, 'imageleft')
end

local listcell = mw.html.create('td'):addClass('navbox-list')
local hlistcell = listcell:tag('div')

-- Only add hlist class if listclass parameter does not contain hlist or plainlist
if not (args.listclass and (hasListClass(cfg.pattern.hlist, 'listclass') or hasListClass(cfg.pattern.plainlist, 'listclass'))) then
hlistcell:addClass('hlist')
end

hlistcell:wikitext( processItem(data) )

if args.rowclass then row:addClass( args.rowclass ) end
if args.listclass then listcell:addClass( args.listclass ) end
if args.liststyle then listcell:cssText( args.liststyle ) end

if hasChild then
listcell:cssText('background: none')
end

if args['group'..num] then
local groupcell = mw.html.create('th'):addClass('navbox-group'):attr('scope','row'):wikitext( args['group'..num] )

if args.groupclass then groupcell:addClass( args.groupclass ) end
if args.groupstyle then groupcell:cssText( args.groupstyle ) end

row:node( groupcell )
else
listcell:attr('colspan',2)
if not hasChild then
listcell:addClass('no-group')
end
end

row:node( listcell )

local firstRow = false
if not hasrows and not activeSection then
firstRow = true
hasrows = true
_processImage(row, 'image')
end

if activeSection then
local parent = sections[activeSection]
if not isChild or not firstRow then
_addGutter(parent)
end
parent:node(row)
hasData = true
else
if not isChild or not firstRow or hasTitle or args.above then
if useZhConverter then
_addGutter(navbox_zh_hans, not firstRow)
_addGutter(navbox_zh_hant, not firstRow)
_addGutter(navbox_zh_hant_hk, not firstRow)
else
_addGutter(navbox, not firstRow)
end
end

if useZhConverter then
navbox_zh_hans:node( row )
navbox_zh_hant:node( row )
navbox_zh_hant_hk:node( row )
else
navbox:node( row )
end

rowspan = rowspan + 1
end
end

--- Processes all rows
local function processRows()
sections = {}
for i=1,#rownums do
local num = rownums[i]
if not skiprows[num] then
processHeader(num)
processList(num)
end
end
_closeCurrentSection()

if cimageleft then
cimageleft:attr('rowspan',rowspan)
end
if cimage then
cimage:attr('rowspan',rowspan)
end
end

-- Create the root HTML element

if isChild then
if useZhConverter then
navbox_zh_hans = mw.html.create('table'):addClass('navbox-subgroup')
navbox_zh_hant = mw.html.create('table'):addClass('navbox-subgroup')
navbox_zh_hant_hk = mw.html.create('table'):addClass('navbox-subgroup')
else
navbox = mw.html.create('table'):addClass('navbox-subgroup')
end
else
if useZhConverter then
navbox_zh_hans = mw.html.create('table'):addClass('navbox')
navbox_zh_hant = mw.html.create('table'):addClass('navbox')
navbox_zh_hant_hk = mw.html.create('table'):addClass('navbox')
else
navbox = mw.html.create('table'):addClass('navbox')
end
end

if not isChild or args.title then
hasTitle = true
end

if hasTitle and isChild then
if useZhConverter then
navbox_zh_hans:addClass('navbox-subgroup-with-title')
navbox_zh_hant:addClass('navbox-subgroup-with-title')
navbox_zh_hant_hk:addClass('navbox-subgroup-with-title')
else
navbox:addClass('navbox-subgroup-with-title')
end
end

if hasTitle and args.state ~= 'plain' then
if useZhConverter then
navbox_zh_hans:addClass('mw-collapsible'):attr('data-expandtext', args['expandtext_zh-hans'] or args['expandtext'] or args['defaultexpandtext_zh-hans'] or args['defaultexpandtext'] or showText_zh_hans or showText):attr('data-collapsetext', args['collapsetext_zh-hans'] or args['collapsetext'] or args['defaultcollapsetext_zh-hans'] or args['defaultcollapsetext'] or hideText_zh_hans or hideText)
navbox_zh_hant:addClass('mw-collapsible'):attr('data-expandtext', args['expandtext_zh-hant'] or args['expandtext'] or args['defaultexpandtext_zh-hant'] or args['defaultexpandtext'] or showText_zh_hant or showText):attr('data-collapsetext', args['collapsetext_zh-hant'] or args['collapsetext'] or args['defaultcollapsetext_zh-hant'] or args['defaultcollapsetext'] or hideText_zh_hant or hideText)
navbox_zh_hant_hk:addClass('mw-collapsible'):attr('data-expandtext', args['expandtext_zh-hant-hk'] or args['expandtext_zh-hant'] or args['expandtext'] or args['defaultexpandtext_zh-hant-hk'] or args['defaultexpandtext_zh-hant'] or args['defaultexpandtext'] or showText_zh_hant_hk or showText_zh_hant or showText):attr('data-collapsetext', args['collapsetext_zh-hant-hk'] or args['collapsetext_zh-hant'] or args['collapsetext'] or args['defaultcollapsetext_zh-hant-hk'] or args['defaultcollapsetext_zh-hant'] or args['defaultcollapsetext'] or hideText_zh_hant_hk or hideText_zh_hant or hideText)
else
navbox:addClass('mw-collapsible'):attr('data-expandtext', args['expandtext'] or args['defaultexpandtext'] or showText):attr('data-collapsetext', args['collapsetext'] or args['defaultcollapsetext'] or hideText)
end

if args.state == 'collapsed' then
if useZhConverter then
navbox_zh_hans:addClass('mw-collapsed')
navbox_zh_hant:addClass('mw-collapsed')
navbox_zh_hant_hk:addClass('mw-collapsed')
else
navbox:addClass('mw-collapsed')
end
end
end

if args.bodyclass then
if useZhConverter then
navbox_zh_hans:addClass(args.bodyclass)
navbox_zh_hant:addClass(args.bodyclass)
navbox_zh_hant_hk:addClass(args.bodyclass)
else
navbox:addClass(args.bodyclass)
end
end
if args.bodystyle then
if useZhConverter then
navbox_zh_hans:cssText(args.bodystyle)
navbox_zh_hant:cssText(args.bodystyle)
navbox_zh_hant_hk:cssText(args.bodystyle)
else
navbox:cssText(args.bodystyle)
end
end

-- Process...
processTitle()
processAboveBelow('above')
processRows()
processAboveBelow('below')

if not isChild then
if useZhConverter then
return '-{|' ..
'zh-hans:-{zh-cn|' .. striped(tostring(navbox_zh_hans), border) .. '}-; ' ..
'zh-hant:-{zh-tw|' .. striped(tostring(navbox_zh_hant), border) .. '}-; ' ..
'zh-hk:-{zh-hk|' .. striped(tostring(navbox_zh_hant_hk), border) .. '}-;' ..
'}-'
end
return striped(tostring(navbox), border)
else
local wrapper = mw.html.create('')
wrapper:wikitext('</div>')

if useZhConverter then
wrapper:wikitext('-{|')
wrapper:wikitext('zh-hans:-{zh-cn|')
wrapper:node(navbox_zh_hans)
wrapper:wikitext('}-; ')
wrapper:wikitext('zh-hant:-{zh-tw|')
wrapper:node(navbox_zh_hant)
wrapper:wikitext('}-; ')
wrapper:wikitext('zh-hk:-{zh-hk|')
wrapper:node(navbox_zh_hant_hk)
wrapper:wikitext('}-; ')
wrapper:wikitext('}-')
else
wrapper:node(navbox)
end

wrapper:wikitext('<div class="hlist">')
return striped(tostring(wrapper), border)
end
end

--- Main module entry point.
-- To be called with {{#invoke:navbox|main}} or directly from another module.
--
-- @param frame The frame passed to the module via the #invoke. If called from another
-- module directly, this should be a table with the parameter definition.
function p.main(frame)
return _navbox(preProcessArgs(frame))
end

return p

模块:Dev/Namespace detect/data

WikiAdmin — Mon, 31 Aug 2026 12:54:50 GMT

从 Fandom Developer Wiki 本地化全局模块，源修订 198201

新页面

-- 来源：https://dev.fandom.com/wiki/Module%3ANamespace_detect/data
-- 许可：CC BY-SA，作者与修订记录见来源页面
--------------------------------------------------------------------------------
-- Namespace detect data --
-- This module holds data for [[Module:Namespace detect]] to be loaded per --
-- page, rather than per #invoke, for performance reasons. --
--------------------------------------------------------------------------------

local cfg = mw.title.new( 'Module:Namespace detect/config').exists and require('Module:Namespace detect/config') or require('Module:Dev/Namespace detect/config')

local function addKey(t, key, defaultKey)
if key ~= defaultKey then
t[#t + 1] = key
end
end

-- Get a table of parameters to query for each default parameter name.
-- This allows wikis to customise parameter names in the cfg table while
-- ensuring that default parameter names will always work. The cfg table
-- values can be added as a string, or as an array of strings.

local defaultKeys = {
'main',
'talk',
'other',
'subjectns',
'demospace',
'demopage'
}

local argKeys = {}
for i, defaultKey in ipairs(defaultKeys) do
argKeys[defaultKey] = {defaultKey}
end

for defaultKey, t in pairs(argKeys) do
local cfgValue = cfg[defaultKey]
local cfgValueType = type(cfgValue)
if cfgValueType == 'string' then
addKey(t, cfgValue, defaultKey)
elseif cfgValueType == 'table' then
for i, key in ipairs(cfgValue) do
addKey(t, key, defaultKey)
end
end
cfg[defaultKey] = nil -- Free the cfg value as we don't need it any more.
end

local function getParamMappings()
--[[
-- Returns a table of how parameter names map to namespace names. The keys
-- are the actual namespace names, in lower case, and the values are the
-- possible parameter names for that namespace, also in lower case. The
-- table entries are structured like this:
-- {
-- [''] = {'main'},
-- ['wikipedia'] = {'wikipedia', 'project', 'wp'},
-- ...
-- }
--]]
local mappings = {}
local mainNsName = mw.site.subjectNamespaces[0].name
mainNsName = mw.ustring.lower(mainNsName)
mappings[mainNsName] = mw.clone(argKeys.main)
mappings['talk'] = mw.clone(argKeys.talk)
for nsid, ns in pairs(mw.site.subjectNamespaces) do
if nsid ~= 0 then -- Exclude main namespace.
local nsname = mw.ustring.lower(ns.name)
local canonicalName = mw.ustring.lower(ns.canonicalName)
mappings[nsname] = {nsname}
if canonicalName ~= nsname then
table.insert(mappings[nsname], canonicalName)
end
for _, alias in ipairs(ns.aliases) do
table.insert(mappings[nsname], mw.ustring.lower(alias))
end
end
end
return mappings
end

return {
argKeys = argKeys,
cfg = cfg,
mappings = getParamMappings()
}

模块:Dev/Namespace detect/config

WikiAdmin — Mon, 31 Aug 2026 12:54:49 GMT

从 Fandom Developer Wiki 本地化全局模块，源修订 32183

新页面

-- 来源：https://dev.fandom.com/wiki/Module%3ANamespace_detect/config
-- 许可：CC BY-SA，作者与修订记录见来源页面
--------------------------------------------------------------------------------
-- Namespace detect configuration data --
-- --
-- This module stores configuration data for Module:Namespace detect. Here --
-- you can localise the module to your wiki's language. --
-- --
-- To activate a configuration item, you need to uncomment it. This means --
-- that you need to remove the text "-- " at the start of the line. --
--------------------------------------------------------------------------------

local cfg = {} -- Don't edit this line.

--------------------------------------------------------------------------------
-- Parameter names --
-- These configuration items specify custom parameter names. Values added --
-- here will work in addition to the default English parameter names. --
-- To add one extra name, you can use this format: --
-- --
-- cfg.foo = 'parameter name' --
-- --
-- To add multiple names, you can use this format: --
-- --
-- cfg.foo = {'parameter name 1', 'parameter name 2', 'parameter name 3'} --
--------------------------------------------------------------------------------

---- This parameter displays content for the main namespace:
-- cfg.main = 'main'

---- This parameter displays in talk namespaces:
-- cfg.talk = 'talk'

---- This parameter displays content for "other" namespaces (namespaces for which
---- parameters have not been specified):
-- cfg.other = 'other'

---- This parameter makes talk pages behave as though they are the corresponding
---- subject namespace. Note that this parameter is used with [[Module:Yesno]].
---- Edit that module to change the default values of "yes", "no", etc.
-- cfg.subjectns = 'subjectns'

---- This parameter sets a demonstration namespace:
-- cfg.demospace = 'demospace'

---- This parameter sets a specific page to compare:
cfg.demopage = 'page'

--------------------------------------------------------------------------------
-- Table configuration --
-- These configuration items allow customisation of the "table" function, --
-- used to generate a table of possible parameters in the module --
-- documentation. --
--------------------------------------------------------------------------------

---- The header for the namespace column in the wikitable containing the list of
---- possible subject-space parameters.
-- cfg.wikitableNamespaceHeader = 'Namespace'

---- The header for the wikitable containing the list of possible subject-space
---- parameters.
-- cfg.wikitableAliasesHeader = 'Aliases'

--------------------------------------------------------------------------------
-- End of configuration data --
--------------------------------------------------------------------------------

return cfg -- Don't edit this line.

模块:Dev/Namespace detect

WikiAdmin — Mon, 31 Aug 2026 12:54:48 GMT

从 Fandom Developer Wiki 本地化全局模块，源修订 118284

新页面

-- 来源：https://dev.fandom.com/wiki/Module%3ANamespace_detect
-- 许可：CC BY-SA，作者与修订记录见来源页面
-- <nowiki>
--[[
--------------------------------------------------------------------------------
-- --
-- NAMESPACE DETECT --
-- --
-- This module implements the {{namespace detect}} template in Lua, with a --
-- few improvements: all namespaces and all namespace aliases are supported, --
-- and namespace names are detected automatically for the local wiki. The --
-- module can also use the corresponding subject namespace value if it is --
-- used on a talk page. Parameter names can be configured for different wikis --
-- by altering the values in the "cfg" table in --
-- Module:Namespace detect/config. --
-- --
--------------------------------------------------------------------------------
--]]

local data = mw.title.new( 'Module:Namespace detect/data').exists and mw.loadData('Module:Namespace detect/data') or mw.loadData('Module:Dev/Namespace detect/data')
local argKeys = data.argKeys
local cfg = data.cfg
local mappings = data.mappings

local yesno = require('Module:Dev/Yesno')
local mArguments -- Lazily initialise Module:Arguments
local mTableTools -- Lazily initilalise Module:TableTools
local ustringLower = mw.ustring.lower

local p = {}

local function fetchValue(t1, t2)
-- Fetches a value from the table t1 for the first key in array t2 where
-- a non-nil value of t1 exists.
for i, key in ipairs(t2) do
local value = t1[key]
if value ~= nil then
return value
end
end
return nil
end

local function equalsArrayValue(t, value)
-- Returns true if value equals a value in the array t. Otherwise
-- returns false.
for i, arrayValue in ipairs(t) do
if value == arrayValue then
return true
end
end
return false
end

function p.getPageObject(page)
-- Get the page object, passing the function through pcall in case of
-- errors, e.g. being over the expensive function count limit.
if page then
local success, pageObject = pcall(mw.title.new, page)
if success then
return pageObject
else
return nil
end
else
return mw.title.getCurrentTitle()
end
end

-- Provided for backward compatibility with other modules
function p.getParamMappings()
return mappings
end

local function getNamespace(args)
-- This function gets the namespace name from the page object.
local page = fetchValue(args, argKeys.demopage)
if page == '' then
page = nil
end
local demospace = fetchValue(args, argKeys.demospace)
if demospace == '' then
demospace = nil
end
local subjectns = fetchValue(args, argKeys.subjectns)
local ret
if demospace then
-- Handle "demospace = main" properly.
if equalsArrayValue(argKeys.main, ustringLower(demospace)) then
ret = mw.site.namespaces[0].name
else
ret = demospace
end
else
local pageObject = p.getPageObject(page)
if pageObject then
if pageObject.isTalkPage then
-- Get the subject namespace if the option is set,
-- otherwise use "talk".
if yesno(subjectns) then
ret = mw.site.namespaces[pageObject.namespace].subject.name
else
ret = 'talk'
end
else
ret = pageObject.nsText
end
else
return nil -- return nil if the page object doesn't exist.
end
end
ret = ret:gsub('_', ' ')
return ustringLower(ret)
end

function p._main(args)
-- Check the parameters stored in the mappings table for any matches.
local namespace = getNamespace(args) or 'other' -- "other" avoids nil table keys
local params = mappings[namespace] or {}
local ret = fetchValue(args, params)
--[[
-- If there were no matches, return parameters for other namespaces.
-- This happens if there was no text specified for the namespace that
-- was detected or if the demospace parameter is not a valid
-- namespace. Note that the parameter for the detected namespace must be
-- completely absent for this to happen, not merely blank.
--]]
if ret == nil then
ret = fetchValue(args, argKeys.other)
end
return ret
end

function p.main(frame)
mArguments = require('Module:Dev/Arguments')
local args = mArguments.getArgs(frame, {removeBlanks = false})
local ret = p._main(args)
return ret or ''
end

function p.table(frame)
--[[
-- Create a wikitable of all subject namespace parameters, for
-- documentation purposes. The talk parameter is optional, in case it
-- needs to be excluded in the documentation.
--]]

-- Load modules and initialise variables.
mTableTools = require('Module:Dev/TableTools')
local namespaces = mw.site.namespaces
local cfg = data.cfg
local useTalk = type(frame) == 'table'
and type(frame.args) == 'table'
and yesno(frame.args.talk) -- Whether to use the talk parameter.

-- Get the header names.
local function checkValue(value, default)
if type(value) == 'string' then
return value
else
return default
end
end
local nsHeader = checkValue(cfg.wikitableNamespaceHeader, 'Namespace')
local aliasesHeader = checkValue(cfg.wikitableAliasesHeader, 'Aliases')

-- Put the namespaces in order.
local mappingsOrdered = {}
for nsname, params in pairs(mappings) do
if useTalk or nsname ~= 'talk' then
local nsid = namespaces[nsname].id
-- Add 1, as the array must start with 1; nsid 0 would be lost otherwise.
nsid = nsid + 1
mappingsOrdered[nsid] = params
end
end
mappingsOrdered = mTableTools.compressSparseArray(mappingsOrdered)

-- Build the table.
local ret = '{| class="wikitable"'
.. '\n|-'
.. '\n! ' .. nsHeader
.. '\n! ' .. aliasesHeader
for i, params in ipairs(mappingsOrdered) do
for j, param in ipairs(params) do
if j == 1 then
ret = ret .. '\n|-'
.. '\n| <code>' .. param .. '</code>'
.. '\n| '
elseif j == 2 then
ret = ret .. '<code>' .. param .. '</code>'
else
ret = ret .. ', <code>' .. param .. '</code>'
end
end
end
ret = ret .. '\n|-'
.. '\n|}'
return ret
end

return p

模块:Dev/Mbox/i18n

WikiAdmin — Mon, 31 Aug 2026 12:54:47 GMT

从 Fandom Developer Wiki 本地化全局模块，源修订 191139

新页面

-- 来源：https://dev.fandom.com/wiki/Module%3AMbox/i18n
-- 许可：CC BY-SA，作者与修订记录见来源页面
-- <nowiki>
return {
["_metadata"] = {
["order"] = {
"aside",
"bgcolor",
"bordercolor",
"class",
"collapsed",
"comment",
"dismiss",
"header",
"id",
"image",
"imagelink",
"imagewidth",
"style",
"text",
"type"
}
},
["en"] = {
["aside"] = "aside",
["bgcolor"] = "bgcolor",
["bordercolor"] = "bordercolor",
["class"] = "class",
["collapsed"] = "collapsed",
["comment"] = "comment",
["dismiss"] = "Dismiss",
["header"] = "header",
["id"] = "id",
["image"] = "image",
["imagelink"] = "imagelink",
["imagewidth"] = "imagewidth",
["style"] = "style",
["text"] = "text",
["type"] = "type"
},
["de"] = {
["aside"] = "nebenbemerkung",
["bgcolor"] = "hintergrundfarbe",
["bordercolor"] = "randfarbe",
["class"] = "klasse",
["collapsed"] = "eingeklappt",
["comment"] = "Kommentar",
["dismiss"] = "Verstecken",
["header"] = "Titel",
["id"] = "id",
["image"] = "bild",
["imagelink"] = "bildlink",
["imagewidth"] = "bildbreite",
["style"] = "style",
["text"] = "Text",
["type"] = "typ"
},
["et"] = {
["aside"] = "kõrval",
["bgcolor"] = "taustavärv",
["bordercolor"] = "piirivärv",
["class"] = "klass",
["comment"] = "kommentaar",
["dismiss"] = "Loobu",
["id"] = "id",
["image"] = "pilt",
["imagelink"] = "pildilink",
["imagewidth"] = "pildisuurus",
["style"] = "stiil",
["text"] = "tekst",
["type"] = "tüüp"
},
["hi"] = {
["aside"] = "अलग",
["bgcolor"] = "bgcolor",
["bordercolor"] = "bordercolour",
["class"] = "क्लास",
["collapsed"] = "छोटा",
["comment"] = "टिप्पणी",
["dismiss"] = "हटाएँ",
["header"] = "हैडर",
["id"] = "id",
["image"] = "चित्र",
["imagelink"] = "imagelink",
["imagewidth"] = "imagewidth",
["style"] = "स्टाइल",
["text"] = "टेक्स्ट",
["type"] = "प्रकार"
},
["ja"] = {
["aside"] = "アサイド",
["bgcolor"] = "背景色",
["bordercolor"] = "境界線の色",
["class"] = "クラス",
["collapsed"] = "折り畳む",
["comment"] = "コメント",
["dismiss"] = "後で見る",
["header"] = "ヘッダー",
["id"] = "ID",
["image"] = "画像",
["imagelink"] = "画像リンク",
["imagewidth"] = "画像の幅",
["style"] = "スタイル",
["text"] = "テキスト",
["type"] = "種類"
},
["pl"] = {
["aside"] = "aside",
["bgcolor"] = "tło",
["bordercolor"] = "krawędź",
["class"] = "klasa",
["collapsed"] = "zwinięty",
["comment"] = "komentarz",
["dismiss"] = "Odrzuć",
["header"] = "nagłówek",
["id"] = "id",
["image"] = "obraz",
["imagelink"] = "link obrazu",
["imagewidth"] = "szerokość obrazu",
["style"] = "style",
["text"] = "tekst",
["type"] = "typ"
},
["pt-br"] = {
["aside"] = "de lado",
["bgcolor"] = "bgcolor",
["bordercolor"] = "cor da borda",
["class"] = "class",
["collapsed"] = "recolher",
["comment"] = "comentário",
["dismiss"] = "Dispensar",
["header"] = "cabeçalho",
["id"] = "id",
["image"] = "imagem",
["imagelink"] = "link imagem",
["imagewidth"] = "largura da imagem",
["style"] = "estilo",
["text"] = "texto",
["type"] = "tipo"
},
["ru"] = {
["aside"] = "текст справа",
["bgcolor"] = "bgcolor",
["bordercolor"] = "bordercolor",
["class"] = "class",
["collapsed"] = "collapsed",
["comment"] = "дополнение",
["dismiss"] = "dismiss",
["header"] = "заголовок",
["id"] = "id",
["image"] = "изображение",
["imagelink"] = "ссылка в изображении",
["imagewidth"] = "ширина изображения",
["style"] = "style",
["text"] = "текст",
["type"] = "type"
},
["tr"] = {
["aside"] = "kenar",
["bgcolor"] = "aprengi",
["bordercolor"] = "kenarlıkrengi",
["class"] = "sınıf",
["collapsed"] = "daratılmış",
["comment"] = "yorum",
["dismiss"] = "Kapat",
["header"] = "başlık",
["id"] = "kimlik",
["image"] = "resim",
["imagelink"] = "resimbağlantısı",
["imagewidth"] = "resimgenişliği",
["style"] = "stil",
["text"] = "metin",
["type"] = "tür"
},
["vi"] = {
["aside"] = "phía bên",
["bgcolor"] = "màu nền",
["bordercolor"] = "màu viền",
["class"] = "lớp",
["collapsed"] = "đã đóng",
["comment"] = "bình luận",
["dismiss"] = "Bỏ qua",
["header"] = "tiêu đề",
["id"] = "id",
["image"] = "hình ảnh",
["imagelink"] = "liên kết ảnh",
["imagewidth"] = "độ rộng ảnh",
["style"] = "phong cách",
["text"] = "văn bản",
["type"] = "loại"
},
["zh"] = {
["aside"] = "侧栏",
["bgcolor"] = "背景颜色",
["bordercolor"] = "边框颜色",
["class"] = "类",
["collapsed"] = "折叠",
["comment"] = "备注",
["dismiss"] = "关闭",
["header"] = "标题",
["id"] = "id",
["image"] = "图像",
["imagelink"] = "图像链接",
["imagewidth"] = "图像宽度",
["style"] = "样式",
["text"] = "文字",
["type"] = "类型"
},
["zh-tw"] = {
["aside"] = "邊界",
["bgcolor"] = "背景色彩",
["bordercolor"] = "邊框色彩",
["class"] = "屬性",
["collapsed"] = "摺疊",
["comment"] = "評論",
["dismiss"] = "忽略",
["header"] = "標頭",
["id"] = "ID",
["image"] = "圖片",
["imagelink"] = "圖片連結",
["imagewidth"] = "圖片長度",
["style"] = "樣式",
["text"] = "文字",
["type"] = "類型"
}
}
-- </nowiki>

模块:Dev/Mbox

WikiAdmin — Mon, 31 Aug 2026 12:54:46 GMT

从 Fandom Developer Wiki 本地化全局模块，源修订 210980

新页面

-- 来源：https://dev.fandom.com/wiki/Module%3AMbox
-- 许可：CC BY-SA，作者与修订记录见来源页面
-- <nowiki>
local Mbox = {}
local getArgs = require('Module:Dev/Arguments').getArgs
local i18n = require('Module:Dev/I18n').loadMessages('Mbox')

function Mbox.main(frame)
local args = getArgs(frame)

-- styles
local styles = {}
styles['border-left-color'] = i18n:parameter('bordercolor', args)
styles['background-color'] = i18n:parameter('bgcolor', args)

-- images
local image = i18n:parameter('image', args) or ''
local imageadjust = ''
if args.imageadjust then
imageadjust = '|' .. args.imageadjust
end
local imagewidth = i18n:parameter('imagewidth', args) or '80px'
local imagelink = '|link='
local imagelinkarg = i18n:parameter('imagelink', args)
if imagelinkarg then
imagelink = imagelink .. imagelinkarg
end

local imagewikitext = '[[File:' .. image .. '|' .. imagewidth .. imageadjust .. imagelink .. ']]'

-- id for closure
local id = i18n:parameter('id', args) or 'mbox'
local typeclass = i18n:parameter('type', args)

local container = mw.html.create('div')
:addClass('mbox')
:addClass(typeclass and ('mbox-type-' .. typeclass))
:addClass(i18n:parameter('class', args))
:css(styles)
:cssText(i18n:parameter('style', args))

local content = container:tag('div')
:addClass('mbox__content')
local collapsed = i18n:parameter('collapsed', args)

if image ~= '' then
local image = content:tag('div')
:addClass('mbox__content__image')
:addClass('mw-collapsible')
:attr('id', 'mw-customcollapsible-' .. id)
:wikitext(imagewikitext)
if collapsed then
image:addClass('mw-collapsed')
end
end

local contentwrapper = content:tag('div')
:addClass('mbox__content__wrapper')
local header = i18n:parameter('header', args)

if header then
contentwrapper:tag('div')
:addClass('mbox__content__header')
:wikitext(header)
end

local textarg = i18n:parameter('text', args)
if textarg then
local text = contentwrapper:tag('div')
:addClass('mbox__content__text')
:addClass('mw-collapsible')
:attr('id', 'mw-customcollapsible-' .. id)
:wikitext(textarg)
if collapsed then
text:addClass('mw-collapsed')
end

local comment = i18n:parameter('comment', args)
if comment then
text:tag('div')
:addClass('mbox__content__text__comment')
:wikitext(comment)
end
end

contentwrapper:tag('span')
:addClass('mbox__close')
:addClass('mw-customtoggle-' .. id)
:attr('title', i18n:msg('dismiss'))

local asidearg = i18n:parameter('aside', args)
if asidearg then
local aside = content:tag('div')
:addClass('mbox__content__aside')
:addClass('mw-collapsible')
:attr('id', 'mw-customcollapsible-' .. id)
:wikitext(asidearg)
if collapsed then
aside:addClass('mw-collapsed')
end
end

return container
end

return Mbox

模块:Dev/I18n

WikiAdmin — Mon, 31 Aug 2026 12:54:45 GMT

从 Fandom Developer Wiki 本地化全局模块，源修订 213110

新页面

-- 来源：https://dev.fandom.com/wiki/Module%3AI18n
-- 许可：CC BY-SA，作者与修订记录见来源页面
--- I18n library for message storage in Lua datastore collections.
-- The module is designed to enable message separation from modules &
-- templates. It has support for handling language fallbacks. This
-- module is a Lua port of [[I18n-js]] and i18n modules that can be loaded
-- by it are editable through [[I18nEdit]].
--
-- @module i18n
-- @version 1.5.0
-- @require Module:Entrypoint
-- @require Module:Fallbacklist
-- @author [[User:KockaAdmiralac|KockaAdmiralac]]
-- @author [[User:Speedit|Speedit]]
-- @attribution [[User:Cqm|Cqm]]
-- @release stable
-- @see [[I18n|I18n guide]]
-- @see [[I18n-js]]
-- @see [[I18nEdit]]
-- <nowiki>
local i18n, _i18n = {}, {}

-- Module variables & dependencies.
local title = mw.title.getCurrentTitle()
local fallbacks = require('Module:Dev/Fallbacklist')
local entrypoint = require('Module:Dev/Entrypoint')
local uselang

--- Argument substitution as $n where n > 0.
-- @function _i18n.handleArgs
-- @param {string} msg Message to substitute arguments into.
-- @param {table} args Arguments table to substitute.
-- @return {string} Resulting message.
-- @local
function _i18n.handleArgs(msg, args)
for i, a in ipairs(args) do
msg = (string.gsub(msg, '%$' .. tostring(i), tostring(a)))
end
return msg
end

--- Checks whether a language code is valid.
-- @function _i18n.isValidCode
-- @param {string} code Language code to check.
-- @return {boolean} Whether the language code is valid.
-- @local
function _i18n.isValidCode(code)
return type(code) == 'string' and #mw.language.fetchLanguageName(code) ~= 0
end

--- Checks whether a message contains unprocessed wikitext.
-- Used to optimise message getter by not preprocessing pure text.
-- @function _i18n.isWikitext
-- @param {string} msg Message to check.
-- @return {boolean} Whether the message contains wikitext.
function _i18n.isWikitext(msg)
return
type(msg) == 'string' and
(
msg:find('%-%-%-%-') or
msg:find('%f[^\n%z][;:*#] ') or
msg:find('%f[^\n%z]==* *[^\n|]+ =*=%f[\n]') or
msg:find('%b<>') or msg:find('\'\'') or
msg:find('%[%b[]%]') or msg:find('{%b{}}')
)
end

--- I18n datastore class.
-- This is used to control language translation and access to individual
-- messages. The datastore instance provides language and message
-- getter-setter methods, which can be used to internationalize Lua modules.
-- The language methods (any ending in `Lang`) are all **chainable**.
-- @type Data
local Data = {}
Data.__index = Data

--- Gets data message utility.
-- This method returns localized messages from the datastore corresponding
-- to a `key`. These messages may have `$n` parameters, which can be
-- replaced by optional argument strings supplied by the `msg` call.
--
-- This function supports [[Lua reference manual#named_arguments|named
-- arguments]]. The named argument syntax is more versatile despite its
-- verbosity; it can be used to select message language & source(s).
-- @function Data:msg

-- @usage
--
-- ds:msg{
-- key = 'message-name',
-- lang = '',
-- args = {...},
-- sources = {}
-- }
--
-- @usage
--
-- ds:msg('message-name', ...)
--
-- @param {string|table} opts Message configuration or key.
-- @param[opt] {string} opts.key Message key to return from the
-- datastore.
-- @param[opt] {table} opts.args Arguments to substitute into the
-- message (`$n`).
-- @param[opt] {table} opts.sources Source names to limit to (see
-- `Data:fromSources`).
-- @param[opt] {table} opts.lang Temporary language to use (see
-- `Data:inLang`).
-- @param[opt] {string} ... Arguments to substitute into the message
-- (`$n`).
-- @error[115] {string} 'missing arguments in Data:msg'
-- @return {string} Localised datastore message or `'<key>'`.
function Data:msg(opts, ...)
local frame = mw.getCurrentFrame()
-- Argument normalization.
if not self or not opts then
error('missing arguments in Data:msg')
end
local key = type(opts) == 'table' and opts.key or opts
local args = opts.args or {...}
-- Configuration parameters.
if opts.sources then
self:fromSources(unpack(opts.sources))
end
if opts.lang then
self:inLang(opts.lang)
end
-- Source handling.
local source_n = self.tempSources or self._sources
local source_i = {}
for n, i in pairs(source_n) do
source_i[i] = n
end
self.tempSources = nil
-- Language handling.
local lang = self.tempLang or self.defaultLang
self.tempLang = nil
-- Language converter handling
-- Types: 'languageConverterMarkup', 'pageSourceCodeLanguage',
-- 'siteLanguage', 'userLanguage'
-- Note: Currently cannot handle page view language without using
-- 'languageConverterMarkup', should use 'userLanguage' in most cases if
-- not able to use 'languageConverterMarkup'.
local languageConversionType = self.tempLanguageConversionType or
'languageConverterMarkup'
self.tempLangConversionType = 'languageConverterMarkup'
-- Message fetching.
local msg
for i, messages in ipairs(self._messages) do
-- Message data.
local msg = nil
-- Language converter support
if lang == 'zh' and
languageConversionType ~= 'pageSourceCodeLanguage' and
languageConversionType ~= 'siteLanguage' and
-- Lua error: too many expensive function calls.
-- (
-- mw.title.getCurrentTitle().pageLang:toBcp47Code() == 'zh' or
-- (
-- -- Module namespace
-- mw.title.getCurrentTitle():inNamespace( 828 ) and
mw.language.getContentLanguage():toBcp47Code() == 'zh'
-- )
-- )
then
local userLang = ( i18n.getLang() or self.defaultLang )
local zh_hani = (messages['zh'] or {})[key]
local zh_hans = (messages['zh-hans'] or {})[key]
local zh_hant = (messages['zh-hant'] or {})[key]
local zh_hant_hk = (messages['zh-hk'] or {})[key]

if
languageConversionType == 'userLanguage'
then
if userLang == 'zh' then
msg = zh_hani or zh_hans or zh_hant or zh_hant_hk
elseif
userLang == 'zh-hans' or
userLang == 'zh-cn' or
userLang == 'zh-my' or
userLang == 'zh-sg'
then
msg = zh_hans or zh_hani or zh_hant or zh_hant_hk
elseif
userLang == 'zh-hant' or
userLang == 'zh-tw'
then
msg = zh_hant or zh_hant_hk or zh_hani or zh_hans
elseif
userLang == 'zh-hk' or
userLang == 'zh-mo'
then
msg = zh_hant_hk or zh_hant or zh_hani or zh_hans
end
elseif zh_hans ~= nil then
if zh_hant ~= nil then
msg = '-{' ..
'zh-hans:' .. zh_hans .. ';' ..
' zh-hant:' .. zh_hant .. ';'

if zh_hant_hk ~= nil then
msg = msg ..
' zh-hk:' .. zh_hant_hk .. ';'
end

msg = msg .. '}-'
elseif zh_hant_hk ~= nil then
msg = '-{' ..
'zh-hans:' .. zh_hans .. ';' ..
' zh-hk:' .. zh_hant_hk .. ';' ..
'}-'
else
msg = zh_hans
end
elseif zh_hant ~= nil then
if zh_hant_hk ~= nil then
msg = '-{' ..
'zh-hant:' .. zh_hant .. ';' ..
' zh-hk:' .. zh_hant_hk .. ';' ..
'}-'
else
msg = zh_hant
end
elseif zh_hant_hk ~= nil then
msg = zh_hant_hk
end
end

if msg == nil then
msg = (messages[lang] or {})[key]
end
-- Fallback support (experimental).
for _, l in ipairs((fallbacks[lang] or {})) do
if msg == nil then
msg = (messages[l] or {})[key]
end
end
-- Internal fallback to 'en'.
msg = msg ~= nil and msg or messages.en[key]
-- Handling argument substitution from Lua.
if msg and source_i[i] and #args > 0 then
msg = _i18n.handleArgs(msg, args)
end
if msg and source_i[i] and lang ~= 'qqx' then
return frame and _i18n.isWikitext(msg)
and frame:preprocess(msg)
or mw.text.trim(msg, '\r\n\f\v')
end
end
return mw.text.nowiki('<' .. key .. '>')
end

--- Gets localised template parameter from a datastore.
-- This method, given a table of arguments, tries to find a parameter's
-- localized name in the datastore and returns its value, or nil if
-- not present.
--
-- This method always uses the wiki's content language.
-- @function Data:parameter
-- @param {string} parameter Parameter's key in the datastore
-- @param {table} args Arguments to find the parameter in
-- @error[176] {string} 'missing arguments in Data:parameter'
-- @return {string|nil} Parameter's value or nil if not present
function Data:parameter(key, args)
-- Argument normalization.
if not self or not key or not args then
error('missing arguments in Data:parameter')
end
local contentLang = mw.language.getContentLanguage():getCode()
-- Message fetching.
for i, messages in ipairs(self._messages) do
local msg = (messages[contentLang] or {})[key]
if msg ~= nil and args[msg] ~= nil then
return args[msg]
end
for _, l in ipairs((fallbacks[contentLang] or {})) do
if msg == nil or args[msg] == nil then
-- Check next fallback.
msg = (messages[l] or {})[key]
else
-- A localized message was found.
return args[msg]
end
end
-- Fallback to English.
msg = messages.en[key]
if msg ~= nil and args[msg] ~= nil then
return args[msg]
end
end
end

--- Sets temporary source to a specificed subset of datastores.
-- By default, messages are fetched from the datastore in the same
-- order of priority as `i18n.loadMessages`.
-- @function Data:fromSource
-- @param {string} ... Source name(s) to use.
-- @return {Data} Datastore instance.
function Data:fromSource(...)
local c = select('#', ...)
if c ~= 0 then
self.tempSources = {}
for i = 1, c do
local n = select(i, ...)
if type(n) == 'string' and type(self._sources[n]) == 'number' then
self.tempSources[n] = self._sources[n]
end
end
end
return self
end

--- Gets data default language.
-- @function Data:getLang
-- @return {string} Default language to serve datastore messages in.
function Data:getLang()
return self.defaultLang
end

--- Sets data language to `wgUserLanguage`.
-- @function Data:useUserLang
-- @return {Data} Datastore instance.
-- @note Scribunto only registers `wgUserLanguage` when an
-- invocation is at the top of the call stack.
function Data:useUserLang()
self.defaultLang = i18n.getLang() or self.defaultLang
return self
end

--- Sets data language to `wgContentLanguage`.
-- @function Data:useContentLang
-- @return {Data} Datastore instance.
function Data:useContentLang()
self.defaultLang = i18n.getContentLang()
return self
end

--- Sets data language to specificed language.
-- @function Data:useLang
-- @param {string} code Language code to use.
-- @return {Data} Datastore instance.
function Data:useLang(code)
self.defaultLang = _i18n.isValidCode(code)
and code
or self.defaultLang
return self
end

--- Sets temporary data language to `wgUserLanguage`.
-- The data language reverts to the default language in the next
-- @{Data:msg} call.
-- @function Data:inUserLang
-- @return {Data} Datastore instance.
function Data:inUserLang()
self.tempLang = i18n.getLang() or self.tempLang
return self
end

--- Sets temporary data language to `wgContentLanguage`.
-- Only affects the next @{Data:msg} call.
-- @function Data:inContentLang
-- @return {Data} Datastore instance.
function Data:inContentLang()
self.tempLang = i18n.getContentLang()
return self
end

--- Sets temporary data language to a specificed language.
-- Only affects the next @{Data:msg} call.
-- @function Data:inLang
-- @param {string} code Language code to use.
-- @return {Data} Datastore instance.
function Data:inLang(code)
self.tempLang = _i18n.isValidCode(code)
and code
or self.tempLang
return self
end

--- Sets temporary data language to a specificed language conversion resolution.
-- Only affects the next @{Data:msg} call.
-- @function Data:useLanguageConversionType
-- @param {string} convType Language conversion type to use.
-- @return {Data} Datastore instance.
function Data:useLanguageConversionType(convType)
self.tempLanguageConversionType = convType
return self
end

-- Package functions.

--- Gets a localized message by data module key.
-- Can be used to fetch messages in a specific language code through `uselang`
-- parameter. Extra numbered parameters can be supplied for substitution into
-- the data collection's message.
-- @function i18n.getMsg
-- @param {table} frame Frame table from invocation.
-- @param {table} frame.args Metatable containing arguments.
-- @param {string} frame.args[1] ROOTPAGENAME of i18n submodule.
-- @param {string} frame.args[2] Key of i18n message.
-- @param[opt] {string} frame.args.lang Default language of message.
-- @error[271] 'missing arguments in i18n.getMsg'
-- @return {string} I18n message in localised language.
-- @usage {{i18n|getMsg|source|key|arg1|arg2|uselang {{=}} code}}
function i18n.getMsg(frame)
if
not frame or
not frame.args or
not frame.args[1] or
not frame.args[2]
then
error('missing arguments in i18n.getMsg')
end
local source = frame.args[1]
local key = frame.args[2]
-- Pass through extra arguments.
local repl = {}
for i, a in ipairs(frame.args) do
if i >= 3 then
repl[i-2] = a
end
end
-- Load message data.
local ds = i18n.loadMessages(source)
-- Pass through language argument.
ds:inLang(frame.args.uselang)
-- Return message.
return ds:msg { key = key, args = repl }
end

--- I18n data loader for message collections.
-- @function i18n.loadMessages
-- @param {string} ... ROOTPAGENAME/path for target i18n
-- submodules.
-- @error[322] {string} 'no source supplied to i18n.loadMessages'
-- @return {table} I18n datastore instance.
-- @usage require('Module:Dev/I18n').loadMessages('1', '2')
function i18n.loadMessages(...)
local ds
local i = 0
local s = {}
for j = 1, select('#', ...) do
local source = select(j, ...)
if type(source) == 'string' and source ~= '' then
i = i + 1
s[source] = i
if not ds then
-- Instantiate datastore.
ds = {}
ds._messages = {}
-- Set default language.
setmetatable(ds, Data)
ds:useUserLang()
end
source = string.gsub(source, '^.', mw.ustring.upper)
source = mw.ustring.find(source, ':')
and source
or 'Module:Dev/' .. source .. '/i18n'
ds._messages[i] = mw.loadData(source)
end
end
if not ds then
error('no source supplied to i18n.loadMessages')
else
-- Attach source index map.
ds._sources = s
-- Return datastore instance.
return ds
end
end

--- Gets the language code of the wiki or page contents.
-- @function i18n.getContentLang
-- @usage {{i18n|getContentLang}}
-- @return {string} Content language code.
function i18n.getContentLang()
local code = mw.language.getContentLanguage():getCode()
local subPage = title.subpageText

-- Subpage language test.
if title.isSubpage and _i18n.isValidCode(subPage) then
code = _i18n.isValidCode(subPage) and subPage or code
end

return code
end

--- Gets the language code of the content.
-- Can validate a template's language code through `uselang` parameter.
-- @function i18n.getLang
-- @usage {{i18n|getLang|uselang {{=}} code}}
-- @return {string} Language code.
function i18n.getLang()
local frame = mw.getCurrentFrame() or {}
local parentFrame = frame.getParent and frame:getParent() or {}

local code = i18n.getContentLang()

-- Language argument test.
local langOverride =
(frame.args or {}).uselang or
(parentFrame.args or {}).uselang
if _i18n.isValidCode(langOverride) then
code = langOverride

-- User language test.
elseif parentFrame.preprocess or frame.preprocess then
uselang = uselang
or parentFrame.preprocess
and parentFrame:preprocess('{{int:lang}}')
or frame:preprocess('{{int:lang}}')
local decodedLang = mw.text.decode(uselang)
if decodedLang ~= '<lang>' and decodedLang ~= '⧼lang⧽' then
code = decodedLang == '(lang)'
and 'qqx'
or uselang
end
end

return code
end

--- Template wrapper for [[Template:I18n]].
-- @function i18n.main
-- @param {table} frame Frame invocation object.
-- @return {string} Module output in template context.
-- @usage {{#invoke:i18n|main}}
i18n.main = entrypoint(i18n)

return i18n
-- </nowiki>

模块:Dev/Hatnote/i18n

WikiAdmin — Mon, 31 Aug 2026 12:54:43 GMT

从 Fandom Developer Wiki 本地化全局模块，源修订 214552

显示更改

模块:Dev/Hatnote

WikiAdmin — Mon, 31 Aug 2026 12:54:42 GMT

从 Fandom Developer Wiki 本地化全局模块，源修订 214904

新页面

-- 来源：https://dev.fandom.com/wiki/Module%3AHatnote
-- 许可：CC BY-SA，作者与修订记录见来源页面
-- <nowiki>
--------------------------------------------------------------------------------
-- Module:Hatnote --
-- --
-- This module produces hatnote links and links to related articles. It --
-- implements the {{hatnote}} and {{format link}} meta-templates and includes --
-- helper functions for other Lua hatnote modules. --
--------------------------------------------------------------------------------

local libraryUtil = require('libraryUtil')
local checkType = libraryUtil.checkType
local mArguments = require('Module:Dev/Arguments')
local yesno = require('Module:Dev/Yesno')
local mTableTools = require('Module:Dev/TableTools')
local i18n = require('Module:Dev/I18n').loadMessages('Hatnote')
local hatnote = {}

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

local function getArgs(frame)
-- Fetches the arguments from the parent frame. Whitespace is trimmed and
-- blanks are removed.
return mArguments.getArgs(frame, {parentOnly = true})
end

local function removeInitialColon(s)
-- Removes the initial colon from a string, if present.
return s:match('^:?(.*)')
end

function hatnote.findNamespaceId(link, removeColon)
-- Finds the namespace id (namespace number) of a link or a pagename. This
-- function will not work if the link is enclosed in double brackets. Colons
-- are trimmed from the start of the link by default. To skip colon
-- trimming, set the removeColon parameter to false.
checkType('findNamespaceId', 1, link, 'string')
checkType('findNamespaceId', 2, removeColon, 'boolean', true)
if removeColon ~= false then
link = removeInitialColon(link)
end
local namespace = link:match('^(.-):')
if namespace then
local nsTable = mw.site.namespaces[namespace]
if nsTable then
return nsTable.id
end
end
return 0
end

function hatnote.quote(title)
--Wraps titles in quotation marks. If the title starts/ends with a quotation
--mark, kerns that side as with {{-'}}
local quotationMarks = {
["'"]=true, ['"']=true, ['“']=true, ["‘"]=true, ['”']=true, ["’"]=true
}
local quoteLeft, quoteRight = -- Test if start/end are quotation marks
quotationMarks[string.sub(title, 1, 1)],
quotationMarks[string.sub(title, -1, -1)]
if quoteLeft or quoteRight then
title = mw.html.create("span"):wikitext(title)
end
if quoteLeft then title:css("padding-left", "0.15em") end
if quoteRight then title:css("padding-right", "0.15em") end
return '"' .. tostring(title) .. '"'
end

function hatnote.formatPages(...)
-- Formats a list of pages using formatLink and returns it as an array. Nil
-- values are not allowed.
local pages = {...}
local ret = {}
for i, page in ipairs(pages) do
ret[i] = hatnote._formatLink(page)
end
return ret
end

function hatnote.formatPageTables(...)
-- Takes a list of page/display tables and returns it as a list of
-- formatted links. Nil values are not allowed.
local pages = {...}
local links = {}
for i, t in ipairs(pages) do
checkType('formatPageTables', i, t, 'table')
local link = t[1]
local display = t[2]
links[i] = hatnote._formatLink(link, display)
end
return links
end

function hatnote.makeWikitextError(msg, helpLink, addTrackingCategory, title)
-- Formats an error message to be returned to wikitext. If
-- addTrackingCategory is not false after being returned from
-- [[Module:Yesno]], and if we are not on a talk page, a tracking category
-- is added.
checkType('makeWikitextError', 1, msg, 'string')
checkType('makeWikitextError', 2, helpLink, 'string', true)
title = title or mw.title.getCurrentTitle()
-- Make the help link text.
local helpText
if helpLink then
helpText = ' ([[' .. helpLink .. '|' .. i18n:msg('help') .. ']])'
else
helpText = ''
end
-- Make the category text.
local category
if not title.isTalkPage and yesno(addTrackingCategory) ~= false then
-- Category LinkTarget is unconvertible
category = i18n:useLanguageConversionType('siteLanguage'):msg('cat-errors')
category = string.format(
'[[%s:%s]]',
mw.site.namespaces[14].name,
category
)
else
category = ''
end
-- string.format doesn't support positional specifiers
return string.format(
i18n:useLanguageConversionType('userLanguage'):msg('error'),
msg,
helpText,
category
)
end

function hatnote.disambiguate(page, disambiguator)
-- Formats a page title with a disambiguation parenthetical,
-- i.e. "Example" → "Example (disambiguation)".
checkType('disambiguate', 1, page, 'string')
checkType('disambiguate', 2, disambiguator, 'string', true)
disambiguator = disambiguator or i18n:msg('disambiguation')
-- string.format doesn't support positional specifiers
return string.format(i18n:useLanguageConversionType('userLanguage'):msg('brackets'), page, disambiguator)
end

--------------------------------------------------------------------------------
-- Format link
--
-- Makes a wikilink from the given link and display values. Links are escaped
-- with colons if necessary, and links to sections are detected and displayed
-- with " § " as a separator rather than the standard MediaWiki "#". Used in
-- the {{format link}} template.
--------------------------------------------------------------------------------

function hatnote.formatLink(frame)
local args = getArgs(frame)
local link = args[1]
local display = args[2]
if not link then
return hatnote.makeWikitextError(
i18n:msg('error-link'),
'w:c:dev:Template:Format link#Errors',-- there is no actual docs for this. not even on wikipedia
args.category
)
end
return hatnote._formatLink(link, display)
end

function hatnote._formatLink(link, display)
checkType('_formatLink', 1, link, 'string')
checkType('_formatLink', 2, display, 'string', true)

-- Remove the initial colon for links where it was specified manually.
link = removeInitialColon(link)

-- Find whether a faux display value has been added with the {{!}} magic
-- word.
if not display then
local prePipe, postPipe = link:match('^(.-)|(.*)$')
link = prePipe or link
display = postPipe
end

-- Find the display value.
if not display then
local page, section = link:match('^(.-)#(.*)$')
if page then
display = page .. ' § ' .. section
end
end

-- Assemble the link.
if display then
return string.format(
'[[:%s|%s]]',
string.gsub(link, '|(.*)$', ''), -- display overwrites manual piping
display
)
else
return string.format('[[:%s]]', link)
end
end

--------------------------------------------------------------------------------
-- Hatnote
--
-- Produces standard hatnote text. Implements the {{hatnote}} template.
--------------------------------------------------------------------------------

function hatnote.hatnote(frame)
local args = getArgs(frame)
local s = args[1]
local options = {}
if not s then
return hatnote.makeWikitextError(
i18n:msg('error-text'),
'w:c:dev:Template:Hatnote#Errors',
args.category
)
end
options.extraclasses = args.extraclasses
options.selfref = args.selfref
return hatnote._hatnote(s, options)
end

function hatnote._hatnote(s, options)
checkType('_hatnote', 1, s, 'string')
checkType('_hatnote', 2, options, 'table', true)
options = options or {}
local classes = {'notice', 'hatnote'}
local extraclasses = options.extraclasses
local selfref = options.selfref
if type(extraclasses) == 'string' then
classes[#classes + 1] = extraclasses
end
if selfref then
classes[#classes + 1] = 'selfref'
end
return string.format(
'<div role="note" data-nosnippet class="%s">%s</div>',
table.concat(classes, ' '),
s
)
end

--------------------------------------------------------------------------------
-- Module:Hatnote list --
-- --
-- This module produces and formats lists for use in hatnotes. In particular, --
-- it implements the for-see list, i.e. lists of "For X, see Y" statements, --
-- as used in {{about}}, and its variants. Also introduced are andList & --
-- orList helpers for formatting lists with those conjunctions. --
--------------------------------------------------------------------------------

--------------------------------------------------------------------------------
-- List stringification helper functions
--
-- These functions are used for stringifying lists, usually page lists inside
-- the "Y" portion of "For X, see Y" for-see items.
--------------------------------------------------------------------------------

--default options table used across the list stringification functions
local stringifyListDefaultOptions = {
conjunction = i18n:msg('conjunction'),
separator = i18n:msg('separator'),
altSeparator = i18n:msg('altSeparator'),
space = i18n:msg('space'),
formatted = false
}

-- Stringifies a list generically; probably shouldn't be used directly
local function stringifyList(list, options)
-- Type-checks, defaults, and a shortcut
checkType("stringifyList", 1, list, "table")
if #list == 0 then return nil end
checkType("stringifyList", 2, options, "table", true)
options = options or {}
for k, v in pairs(stringifyListDefaultOptions) do
if options[k] == nil then options[k] = v end
end
local s = options.space
-- Format the list if requested
if options.formatted then list = hatnote.formatPages(unpack(list)) end
-- Set the separator; if any item contains it, use the alternate separator
local separator = options.separator
--searches display text only
function searchDisp(t, f)
return string.find(string.sub(t, (string.find(t, '|') or 0) + 1), f)
end
for k, v in pairs(list) do
if searchDisp(v, separator) then
separator = options.altSeparator
break
end
end
-- Set the conjunction, apply Oxford comma, and force a comma if #1 has "§"
local oxfordLangs = {
-- list of languages that does respect oxford commas
['en'] = true,
['en-us'] = true,
['en-gb'] = true,
}

local conjunction = s .. options.conjunction .. s
if #list == 2 and searchDisp(list[1], "§") or #list > 2 then
conjunction = (oxfordLangs[i18n.defaultLang] and separator or '') .. conjunction
end
-- Return the formatted string
return mw.text.listToText(list, separator .. s, conjunction)
end

--DRY function
local function conjList (conj, list, fmt)
return stringifyList(list, {conjunction = conj, formatted = fmt})
end

-- Stringifies lists with "and" or "or"
function hatnote.andList (...) return conjList(i18n:msg('conj-and'), ...) end
function hatnote.orList (...) return conjList(i18n:msg('conj-or'), ...) end

--------------------------------------------------------------------------------
-- For see
--
-- Makes a "For X, see [[Y]]." list from raw parameters. Intended for the
-- {{about}} templates and their variants.
--------------------------------------------------------------------------------

--default options table used across the forSee family of functions
local forSeeDefaultOptions = {
andKeyword = i18n:msg('conj-and'),
title = mw.title.getCurrentTitle().text,
otherText = i18n:msg('other-uses'),
-- string.format doesn't support positional specifiers
forSeeForm = i18n:useLanguageConversionType('userLanguage'):msg('for')
}

--Collapses duplicate punctuation
local function punctuationCollapse (text)
local replacements = {
["%.%.$"] = ".",
["%?%.$"] = "?",
["%!%.$"] = "!",
["%.%]%]%.$"] = ".]]",
["%?%]%]%.$"] = "?]]",
["%!%]%]%.$"] = "!]]"
}
for k, v in pairs(replacements) do text = string.gsub(text, k, v) end
return text
end

-- Structures arguments into a table for stringification, & options
function hatnote.forSeeArgsToTable (args, from, options)
-- Type-checks and defaults
checkType("forSeeArgsToTable", 1, args, 'table')
checkType("forSeeArgsToTable", 2, from, 'number', true)
from = from or 1
checkType("forSeeArgsToTable", 3, options, 'table', true)
options = options or {}
for k, v in pairs(forSeeDefaultOptions) do
if options[k] == nil then options[k] = v end
end
-- maxArg's gotten manually because getArgs() and table.maxn aren't friends
local maxArg = 0
for k, v in pairs(args) do
if type(k) == 'number' and k > maxArg then maxArg = k end
end
-- Structure the data out from the parameter list:
-- * forTable is the wrapper table, with forRow rows
-- * Rows are tables of a "use" string & a "pages" table of pagename strings
-- * Blanks are left empty for defaulting elsewhere, but can terminate list
local forTable = {}
local i = from
local terminated = false
-- Loop to generate rows
repeat
-- New empty row
local forRow = {}
-- On blank use, assume list's ended & break at end of this loop
forRow.use = args[i]
if not args[i] then terminated = true end
-- New empty list of pages
forRow.pages = {}
-- Insert first pages item if present
table.insert(forRow.pages, args[i + 1])
-- If the param after next is "and", do inner loop to collect params
-- until the "and"'s stop. Blanks are ignored: "1|and||and|3" → {1, 3}
while args[i + 2] == options.andKeyword do
if args[i + 3] then
table.insert(forRow.pages, args[i + 3])
end
-- Increment to next "and"
i = i + 2
end
-- Increment to next use
i = i + 2
-- Append the row
table.insert(forTable, forRow)
until terminated or i > maxArg

return forTable
end

-- Stringifies a table as formatted by forSeeArgsToTable
function hatnote.forSeeTableToString (forSeeTable, options)
-- Type-checks and defaults
checkType("forSeeTableToString", 1, forSeeTable, "table")
checkType("forSeeTableToString", 2, options, "table", true)
options = options or {}
for k, v in pairs(forSeeDefaultOptions) do
if options[k] == nil then options[k] = v end
end
-- Stringify each for-see item into a list
local strList = {}
for k, v in pairs(forSeeTable) do
local useStr = v.use or options.otherText
local pagesStr = hatnote.andList(v.pages, true) or
hatnote._formatLink(hatnote.disambiguate(options.title))
local forSeeStr = string.format(options.forSeeForm, useStr, pagesStr)
forSeeStr = punctuationCollapse(forSeeStr)
table.insert(strList, forSeeStr)
end
-- Return the concatenated list
return table.concat(strList, i18n:msg('space'))
end

-- Produces a "For X, see [[Y]]" string from arguments. Expects index gaps
-- but not blank/whitespace values. Ignores named args and args < "from".
function hatnote._forSee (args, from, options)
local forSeeTable = hatnote.forSeeArgsToTable(args, from, options)
return hatnote.forSeeTableToString(forSeeTable, options)
end

-- As _forSee, but uses the frame.
function hatnote.forSee (frame, from, options)
return hatnote._forSee(mArguments.getArgs(frame), from, options)
end

--------------------------------------------------------------------------------
-- Produces a labelled pages-list hatnote.
-- The main frame (template definition) takes 1 or 2 arguments, for a singular
-- and (optionally) plural label respectively:
-- * {{#invoke:Hatnote|labelledList|Singular label|Plural label}}
-- The resulting template takes pagename & label parameters normally.
--------------------------------------------------------------------------------
-- Defaults global to this module
local LPLHdefaults = {
label = i18n:msg('see-also'), --Final fallback for label argument
labelForm = i18n:msg('colon'),
prefixes = {'label', 'label ', 'l'},
template = 'Module:Hatnote'
}

-- Helper function that pre-combines display parameters into page arguments.
-- Also compresses sparse arrays, as a desirable side-effect.
function hatnote.preprocessDisplays (args, prefixes)
-- Prefixes specify which parameters, in order, to check for display options
-- They each have numbers auto-appended, e.g. 'label1', 'label 1', & 'l1'
prefixes = prefixes or LPLHdefaults.prefixes
local pages = {}
for k, v in pairs(args) do
if type(k) == 'number' then
local display
for i = 1, #prefixes do
display = args[prefixes[i] .. k]
if display then break end
end
local page = display and
string.format('%s|%s', string.gsub(v, '|.*$', ''), display) or v
pages[#pages + 1] = page
end
end
return pages
end

function hatnote.labelledList (frame)
local labels = {frame.args[1] or LPLHdefaults.label}
labels[2] = frame.args[2] or labels[1]
local template = frame:getParent():getTitle()
local args = mArguments.getArgs(frame, {parentOnly = true})
local pages = hatnote.preprocessDisplays(args)
local options = {
extraclasses = frame.args.extraclasses,
category = args.category,
selfref = frame.args.selfref or args.selfref,
template = template
}
return hatnote._labelledList(pages, labels, options)
end

function hatnote._labelledList (pages, labels, options)
labels = labels or {}
if #pages == 0 then
return hatnote.makeWikitextError(
i18n:msg('error-pagename', 2),
(options.template or LPLHdefaults.template) .. '#Errors',
options.category
)
end
label = (#pages == 1 and labels[1] or labels[2]) or LPLHdefaults.label
local text = string.format(
options.labelForm or LPLHdefaults.labelForm,
label,
hatnote.andList(pages, true)
)
local hnOptions = {
extraclasses = options.extraclasses,
selfref = options.selfref
}
return hatnote._hatnote(text, hnOptions)
end

--------------------------------------------------------------------------------
-- About
--
-- These functions implement the {{about}} hatnote template.
--------------------------------------------------------------------------------
function hatnote.about (frame)
-- A passthrough that gets args from the frame and all
args = mArguments.getArgs(frame)
return hatnote._about(args)
end

function hatnote._about (args, options)
-- Produces "about" hatnote.

-- Type checks and defaults
checkType('_about', 1, args, 'table', true)
args = args or {}
checkType('_about', 2, options, 'table', true)
options = options or {}
local defaultOptions = {
-- string.format doesn't support positional specifiers
aboutForm = i18n:useLanguageConversionType('userLanguage'):msg('about', mw.title.getCurrentTitle().namespace),
defaultPageType = i18n:msg('page'),
namespace = mw.title.getCurrentTitle().namespace,
otherText = nil, --included for complete list
pageTypesByNamespace = {
[0] = i18n:msg('pagetype-0'),
[14] = i18n:msg('pagetype-14')
},
sectionString = i18n:msg('section')
}
for k, v in pairs(defaultOptions) do
if options[k] == nil then options[k] = v end
end

-- Set initial "about" string
local pageType = (args.section and options.sectionString) or
options.pageTypesByNamespace[options.namespace] or
options.defaultPageType
local about = ''
if args[1] then
about = string.format(options.aboutForm, pageType, args[1])
end

--Allow passing through certain options
local fsOptions = {
otherText = options.otherText
}

-- Set for-see list
local forSee = i18n:msg('space') .. hatnote._forSee(args, 2, fsOptions)

-- Concatenate and return
return hatnote._hatnote(about .. forSee, {extraclasses = 'context-link about dablink'})
end

--------------------------------------------------------------------------------
-- Details
--
-- These functions implement the {{details}} hatnote template.
--------------------------------------------------------------------------------
function hatnote.details (frame)
local args = mArguments.getArgs(frame, {parentOnly = true})
local topic, category = args.topic, args.category
local options = {
selfref = args.selfref,
extraclasses = 'context-link details dablink'
}
args = mTableTools.compressSparseArray(args)
if #args == 0 then
return hatnote.makeWikitextError(
i18n:msg('error-pagename'),
'w:c:dev:Template:Details#Errors',-- another undocumented thing
category
)
end
return hatnote._details(args, topic, options)
end

function hatnote._details (list, topic, options)
list = hatnote.andList(list, true)
topic = topic or i18n:msg('topic')
-- string.format doesn't support positional specifiers
local text = string.format(i18n:useLanguageConversionType('userLanguage'):msg('details'), topic, list)
return hatnote._hatnote(text, options)
end

--------------------------------------------------------------------------------
-- For
--
-- These functions implement the {{for}} hatnote template.
--------------------------------------------------------------------------------
function hatnote.For (frame)
return hatnote._For(mArguments.getArgs(frame))
end

--Implements {{For}} but takes a manual arguments table
function hatnote._For (args)
local use = args[1]
local category = ''
if
(not use or use == i18n:msg('other-uses')) and
(not args.category or yesno(args.category))
then
-- Category LinkTarget is unconvertible
category = '[[Category:' .. i18n:useLanguageConversionType('siteLanguage'):msg('cat-unusual-parameters') .. ']]'
end
local pages = {}
function two (a, b) return a, b, 1 end --lets us run ipairs from 2
for k, v in two(ipairs(args)) do table.insert(pages, v) end
return hatnote._hatnote(
hatnote.forSeeTableToString({{use = use, pages = pages}}),
{selfref = args.selfref, extraclasses = args.extraclasses}
) .. category
end

--------------------------------------------------------------------------------
-- Further
--
-- These functions implement the {{further}} hatnote template.
--------------------------------------------------------------------------------
function hatnote.further(frame)
local args = mArguments.getArgs(frame, {parentOnly = true})
local pages = mTableTools.compressSparseArray(args)
if #pages < 1 then
return hatnote.makeWikitextError(
i18n:msg('error-pagename', 2),
'w:c:dev:Template:Further#Errors',-- undocumented thing #3
args.category
)
end
local options = {
selfref = args.selfref,
extraclasses = 'context-link further dablink'
}
return hatnote._further(pages, options)
end

function hatnote._further(pages, options)
local text = i18n:msg('further2') .. hatnote.andList(pages, true)
return hatnote._hatnote(text, options)
end

--------------------------------------------------------------------------------
-- Main
--
-- These functions implement the {{main}} hatnote template.
--------------------------------------------------------------------------------
function hatnote.main(frame)
local args = mArguments.getArgs(frame, {parentOnly = true})
local pages = {}
for k, v in pairs(args) do
if type(k) == 'number' then
local display = args['label ' .. k] or args['l' .. k]
local page = display and
string.format('%s|%s', string.gsub(v, '|.*$', ''), display) or v
pages[#pages + 1] = page
end
end
if #pages == 0 and mw.title.getCurrentTitle().namespace == 0 then
return hatnote.makeWikitextError(
i18n:msg('error-pagename', 2),
'w:c:dev:Template:Main#Errors',-- undocumented thing #4
args.category
)
end
local options = {
selfref = args.selfref
}
return hatnote._main(pages, options)
end

function hatnote._main(args, options)
-- Get the list of pages. If no first page was specified we use the current
-- page name.
local currentTitle = mw.title.getCurrentTitle()
if #args == 0 then args = {currentTitle.text} end
local firstPage = string.gsub(args[1], '|.*$', '')
-- Make the formatted link text
list = hatnote.andList(args, true)
-- Build the text.
local pageCount = #args
-- Find the pagetype.
local pageType = hatnote.findNamespaceId(firstPage) == 0 and i18n:msg('article', pageCount) or i18n:msg('page', pageCount)
local mainForm
local curNs = currentTitle.namespace
if (curNs == 14) or (curNs == 15) then --category/talk namespaces
-- string.format doesn't support positional specifiers
mainForm = i18n:useLanguageConversionType('userLanguage'):msg('main-category', pageCount, pageType, list)
else
-- string.format doesn't support positional specifiers
mainForm = i18n:useLanguageConversionType('userLanguage'):msg('main', pageCount, pageType, list)
end
local text = string.format(mainForm, pageType, list)
options = options or {}
local hnOptions = {
selfref = options.selfref,
extraclasses = 'context-link main dablink'
}
return hatnote._hatnote(text, hnOptions)
end

--------------------------------------------------------------------------------
-- See also
--
-- These functions implement the {{see also}} hatnote template.
--------------------------------------------------------------------------------
function hatnote.seeAlso(frame)
local args = mArguments.getArgs(frame, {parentOnly = true})
local pages = {}
for k, v in pairs(args) do
if type(k) == 'number' then
local display = args['label ' .. k] or args['l' .. k]
local page = display and
string.format('%s|%s', string.gsub(v, '|.*$', ''), display) or v
pages[#pages + 1] = page
end
end
if not pages[1] then
return hatnote.makeWikitextError(
i18n:msg('error-pagename', 2),
'w:c:dev:Template:See also#Errors',-- undocumented thing #5
args.category
)
end
local options = {
selfref = args.selfref
}
return hatnote._seeAlso(pages, options)
end

function hatnote._seeAlso(args, options)
checkType('_seeAlso', 1, args, 'table')
checkType('_seeAlso', 2, options, 'table', true)
options = options or {}
local list = hatnote.andList(args, true)
-- string.format doesn't support positional specifiers
local text = string.format(i18n:useLanguageConversionType('userLanguage'):msg('see-also2'), list)
-- Pass options through.
local hnOptions = {
selfref = options.selfref,
extraclasses = 'context-link seealso dablink'
}
return hatnote._hatnote(text, hnOptions)
end

hatnote['for'] = hatnote.For

return hatnote

模块:Dev/Fallbacklist

WikiAdmin — Mon, 31 Aug 2026 12:54:39 GMT

从 Fandom Developer Wiki 本地化全局模块，源修订 205706

新页面

-- 来源：https://dev.fandom.com/wiki/Module%3AFallbacklist
-- 许可：CC BY-SA，作者与修订记录见来源页面
-- Language fallback rules for other Lua modules.
-- @see https://commons.wikimedia.org/wiki/Module:Fallbacklist
-- @release 2017-01-01T20:33:00.000Z
-- @submodule
return {

-- crh (Crimean Tatar) cluster: crh-cyrl , crh-latn -> crh (Crimean Tatar)
['crh'] = {'crh-latn'},
['crh-cyrl'] = {'crh', 'ru'},
['crh-latn'] = {'crh'},

-- de (German) cluster:
['als'] = {'gsw', 'de'}, -- Alemannisch
['bar'] = {'de'}, -- Bavarian
['de-at'] = {'de'}, -- Austrian German
['de-ch'] = {'de'}, -- Swiss High German
['de-formal'] = {'de'}, -- German (formal address)
['dsb'] = {'de'}, -- Lower Sorbian
['frr'] = {'de'}, -- Northern Frisian
['hsb'] = {'de'}, -- Upper Sorbian
['ksh'] = {'de'}, -- Colognian
['lb'] = {'de'}, -- Luxembourgish
['nds'] = {'nds-nl', 'de'}, -- Low German
['nds-nl'] = {'nds', 'nl'}, -- Low Saxon (Netherlands)
['pdc'] = {'de'}, -- Deitsch
['pdt'] = {'nds', 'de'}, -- Plautdietsch
['pfl'] = {'de'}, -- Pälzisch
['sli'] = {'de'}, -- Lower Silesian
['stq'] = {'de'}, -- Seeltersk
['vmf'] = {'de'}, -- Upper Franconian

-- es (Spanish) cluster
['an'] = {'es'}, -- Aragonese
['arn'] = {'es'}, -- Mapuche
['ay'] = {'es'}, -- Aymara
['cbk-zam'] = {'es'}, -- Chavacano de Zamboanga
['gn'] = {'es'}, -- Guarani
['lad'] = {'es'}, -- Ladino
['nah'] = {'es'}, -- Nahuatl
['qu'] = {'es'}, -- Quechua
['qug'] = {'qu', 'es'}, -- Runa shimi

-- et (Estonian) cluster
['liv'] = {'et'}, -- Līvõ kēļ
['vep'] = {'et'}, -- Veps
['vro'] = {'et'}, -- Võro
['fiu-vro'] = {'vro', 'et'}, -- Võro

-- fa (Persian) cluster
['bcc'] = {'fa'}, -- Southern Balochi
['bqi'] = {'fa'}, -- Bakhtiari
['glk'] = {'fa'}, -- Gilaki
['mzn'] = {'fa'}, -- Mazandarani

-- fi (Finnish) cluster:
['fit'] = {'fi'}, -- meänkieli
['vot'] = {'fi'}, -- Votic

-- fr (French) cluster:
['bm'] = {'fr'}, -- Bambara
['br'] = {'fr'}, -- Breton
['co'] = {'fr'}, -- Corsican
['ff'] = {'fr'}, -- Fulah
['frc'] = {'fr'}, -- Cajun French
['frp'] = {'fr'}, -- Franco-Provençal
['ht'] = {'fr'}, -- Haitian
['ln'] = {'fr'}, -- Lingala
['mg'] = {'fr'}, -- Malagasy
['pcd'] = {'fr'}, -- Picard
['sg'] = {'fr'}, -- Sango
['ty'] = {'fr'}, -- Tahitian
['wa'] = {'fr'}, -- Walloon
['wo'] = {'fr'}, -- Wolof

-- hi (Hindi) cluster
['anp'] = {'hi'}, -- Angika
['mai'] = {'hi'}, -- Maithili
['sa'] = {'hi'}, -- Sanskrit

-- hif (Fiji Hindi) cluster: hif-deva , hif-latn -> hif (Fiji Hindi)
['hif'] = {'hif-latn'},
['hif-deva'] = {'hif'},
['hif-latn'] = {'hif'},

-- id (Indonesian) cluster
['min'] = {'id'}, -- Minangkabau
['ace'] = {'id'}, -- Achinese
['bug'] = {'id'}, -- Buginese
['bjn'] = {'id'}, -- Banjar
['jv'] = {'id'}, -- Javanese
['su'] = {'id'}, -- Sundanese
['map-bms'] = {'jv', 'id'}, -- Basa Banyumasan

-- ike (Eastern Canadian Inuktitut) cluster: ike-cans , ike-latn -> ike (Eastern Canadian Inuktitut)
['ike-cans'] = {'ik'},
['ike-latn'] = {'ik'},

-- it (Italian) cluster
['egl'] = {'it'}, -- Emiliàn
['eml'] = {'it'}, -- Emiliano-Romagnolo
['fur'] = {'it'}, -- Friulian
['lij'] = {'it'}, -- Ligure
['lmo'] = {'it'}, -- lumbaart
['nap'] = {'it'}, -- Neapolitan
['pms'] = {'it'}, -- Piedmontese
['rgn'] = {'it'}, -- Romagnol
['scn'] = {'it'}, -- Sicilian
['vec'] = {'it'}, -- vèneto

-- kk (Kazakh) cluster:
-- kk-arab , kk-cyrl , kk-latn , kk-cn , kk-kz , kk-tr -> kk (Kazakh)
['kk'] = {'kk-cyrl'}, -- Kazakh
['kk-arab'] = {'kk-cyrl', 'kk'}, -- Kazakh (Arabic script)
['kk-cn'] = {'kk-arab', 'kk-cyrl', 'kk'}, -- Kazakh (China)
['kk-cyrl'] = {'kk'}, -- Kazakh (Cyrillic script)
['kk-kz'] = {'kk', 'kk-cyrl'}, -- Kazakh (Kazakhstan)
['kk-latn'] = {'kk-cyrl', 'kk'}, -- Kazakh (Latin script)
['kk-tr'] = {'kk-latn', 'kk-cyrl', 'kk'}, -- Kazakh (Turkey)
['kaa'] = {'kk-latn', 'kk-cyrl'}, -- Kara-Kalpak

-- ku (Kurdish) cluster: ku-latn , ku-arab -> ku (Kurdish)
['ku'] = {'ku-latn'},
['ku-arab'] = {'ckb', 'ckb-arab', 'ku'}, -- كوردي (عەرەبی)
['ku-latn'] = {'ku'},
['ckb'] = {'ckb-arab', 'ku'},

-- nl (Dutch) cluster
['af'] = {'nl'}, -- Afrikaans
['fy'] = {'nl'}, -- Western Frisian
['li'] = {'nl'}, -- Liechtenstein
['nl-informal'] = {'nl'}, -- Nederlands (informeel)
['vls'] = {'nl'}, -- Vlaams
['zea'] = {'nl'}, -- Zeeuws

--pl (Polish) cluster
['csb'] = {'pl'}, -- Kashubian
['szl'] = {'pl'}, -- Silesian

-- pt (Portuguese) cluster
['gl'] = {'pt'}, -- Galician
['mwl'] = {'pt'}, -- Mirandese
['pt'] = {'pt-br'}, -- Brazilian Portuguese

-- ro (Romanian) cluster
['mo'] = {'ro'}, -- Moldavian
['rmy'] = {'ro'}, -- Romani

-- ru (Russian) cluster
['ab'] = {'ru'}, -- Abkhazian
['av'] = {'ru'}, -- Avaric
['ba'] = {'ru'}, -- Bashkir
['be-tarask'] = {'ru'}, -- Belorussian
['ce'] = {'ru'}, -- Chechen
['crh-cyrl'] = {'ru'}, -- Crimean Tatar (Cyrillic script)
['cv'] = {'ru'}, -- Chuvash
['inh'] = {'ru'}, -- Ingush
['koi'] = {'ru'}, -- Komi-Permyak
['krc'] = {'ru'}, -- Karachay-Balkar
['kv'] = {'ru'}, -- Komi
['lbe'] = {'ru'}, -- лакку
['lez'] = {'ru'}, -- Lezghian
['mhr'] = {'ru'}, -- Eastern Mari
['mrj'] = {'ru'}, -- Hill Mari
['myv'] = {'ru'}, -- Erzya
['os'] = {'ru'}, -- Ossetic
['rue'] = {'uk', 'ru'}, -- Rusyn
['sah'] = {'ru'}, -- Sakha
['tt'] = {'tt-cyrl', 'ru'}, -- Tatar
['tt-cyrl'] = {'ru'}, -- Tatar (Cyrillic script)
['udm'] = {'ru'}, -- Udmurt
['uk'] = {'ru'}, -- Ukranian
['xal'] = {'ru'}, -- Kalmyk
['tt'] = {'tt-cyrl', 'ru'}, -- Tatar

-- ruq (Megleno Romanian) cluster: ruq-cyrl , ruq-grek , ruq-latn -> ruq (Megleno Romanian)
['ruq'] = {'ruq-latn', 'ro'}, -- Megleno-Romanian
['ruq-cyrl'] = {'ruq', 'mk'}, -- Megleno-Romanian (Cyrillic script)
['ruq-grek'] = {'ruq'}, -- Megleno-Romanian (Greek script)
['ruq-latn'] = {'ro', 'ruq'}, -- Megleno-Romanian (Latin script)

-- sr (Serbian) cluster: sr-ec , sr-el -> sr (Serbian)
['sr'] = {'sr-ec'},
['sr-ec'] = {'sr'},
['sr-el'] = {'sr'},

-- tg (Tajik) cluster: tg-cyrl , tg-latn -> tg (Tajik)
['tg'] = {'tg-cyrl'},
['tg-cyrl'] = {'tg'},
['tg-latn'] = {'tg'},

-- tr (Turkish) cluster
['gag'] = {'tr'}, -- Gagauz
['kiu'] = {'tr'}, -- Kirmanjki
['lzz'] = {'tr'}, -- Lazuri

-- tt (Tatar) cluster: tt-cyrl , tt-latn -> tt (Tatar)
['tt-cyrl'] = {'tt'},
['tt-latn'] = {'tt'},

-- zh (Chinese) cluster
-- /includes/language/converters/ZhConverter.php
-- https://gerrit.wikimedia.org/r/703560
['cdo'] = {'nan', 'zh-hant', 'zh', 'zh-hans'}, -- Min Dong Chinese
['gan'] = {'gan-hant', 'gan-hans', 'zh-hant', 'zh-hans', 'zh'}, -- Gan
['gan-hans'] = {'gan', 'gan-hant', 'zh-hans', 'zh', 'zh-hant'}, -- Simplified Gan script
['gan-hant'] = {'gan', 'gan-hans', 'zh-hant', 'zh', 'zh-hans'}, -- Traditional Gan script
['hak'] = {'zh-hant', 'zh', 'zh-hans'}, -- Hakka
['ii'] = {'zh-cn', 'zh-hans', 'zh', 'zh-hant'}, -- Sichuan Yi
['lzh'] = {'zh-hant', 'zh', 'zh-hans'}, -- Literary Chinese
['nan'] = {'cdo', 'zh-hant', 'zh', 'zh-hans'}, -- Min Nan Chinese
['szy'] = {'zh-tw', 'zh-hant', 'zh', 'zh-hans'}, -- Sakizaya
['tay'] = {'zh-tw', 'zh-hant', 'zh', 'zh-hans'}, -- Atayal
['trv'] = {'zh-tw', 'zh-hant', 'zh', 'zh-hans'}, -- Seediq
['wuu'] = {'zh-hans', 'zh-hant', 'zh'}, -- Wu
-- https://phabricator.wikimedia.org/T59138
-- ['wuu'] = {'wuu-hans, 'wuu-hant', 'zh-hans', 'zh-hant', 'zh'}, -- Wu
-- ['wuu-hans'] = {'wuu', 'wuu-hant', 'zh-hans', 'zh', 'zh-hant'}, -- Simplified Wu
-- ['wuu-hant'] = {'wuu', 'wuu-hans', 'zh-hant', 'zh', 'zh-hans'}, -- Traditional Wu
['yue'] = {'zh-hk', 'zh-hant', 'zh-hans', 'zh'}, -- Cantonese
-- https://phabricator.wikimedia.org/T59106
-- ['yue'] = {'yue-hant', 'yue-hans, 'zh-hk', 'zh-hant', 'zh-hans', 'zh'}, -- Cantonese
-- ['yue-hans'] = {'yue', 'yue-hant', 'zh-hans', 'zh', 'zh-hk', 'zh-hant'}, -- Simplified Cantonese
-- ['yue-hant'] = {'yue', 'yue-hans', 'zh-hk', 'zh-hant', 'zh', 'zh-hans'}, -- Traditional Cantonese
['za'] = {'zh-hans', 'zh-hant', 'zh'}, -- Zhuang
-- The time allocated for running scripts has expired.
-- ['zh'] = {'zh-hans', 'zh-hant', 'zh-cn', 'zh-tw', 'zh-hk'}, -- Chinese
-- ['zh-hans'] = {'zh-cn', 'zh', 'zh-hant'}, -- Simplified Chinese
-- ['zh-hant'] = {'zh-tw', 'zh-hk', 'zh', 'zh-hans'}, -- Traditional Chinese
-- ['zh-tw'] = {'zh-hant', 'zh-hk', 'zh', 'zh-hans'}, -- Chinese (Taiwan)
-- ['zh-hk'] = {'zh-hant', 'zh-tw', 'zh', 'zh-hans'}, -- Chinese (Hong Kong)
['zh'] = {'zh-hans', 'zh-hant', 'zh-hk'}, -- Chinese
['zh-hans'] = {'zh-hant', 'zh-hk'}, -- Simplified Chinese
['zh-hant'] = {'zh-hk', 'zh-hans'}, -- Traditional Chinese
['zh-cn'] = {'zh-hans', 'zh', 'zh-hant'}, -- Chinese (Mainland China)
['zh-sg'] = {'zh-hans', 'zh-cn', 'zh', 'zh-hant'}, -- Chinese (Singapore)
['zh-my'] = {'zh-hans', 'zh-sg', 'zh-cn', 'zh', 'zh-hant'}, -- Chinese (Malaysia)
['zh-tw'] = {'zh-hant', 'zh-hk', 'zh-hans'}, -- Chinese (Taiwan)
['zh-hk'] = {'zh-hant', 'zh-hans'}, -- Chinese (Hong Kong)
['zh-mo'] = {'zh-hant', 'zh-hk', 'zh-tw', 'zh', 'zh-hans'}, -- Chinese (Macau)
['zh-classical'] = {'lzh', 'zh-hant', 'zh', 'zh-hans'}, -- Classical Chinese -> Literary Chinese
['zh-min-nan'] = {'nan', 'cdo', 'zh-hant', 'zh', 'zh-hans'}, -- Chinese (Min Nan) -> Min Nan Chinese
['zh-yue'] = {'yue', 'zh-hk', 'zh-hant', 'zh-hans', 'zh'}, -- Yue Chinese -> Cantonese

------------------------
--------- misc ---------
------------------------
['arz'] = {'ar'}, -- Egyptian Arabic -> Arabic
['azb'] = {'az'}, -- Southern Azerbaijani -> Azerbaijani
['be-x-old'] = {'be-tarask'}, -- be-x-old -> be-tarask (wrong to correct Taraškievica form of Belarusian orthography)
['bh'] = {'bho'}, -- Bihari -> Bhojpuri
['bpy'] = {'bn'}, -- Bishnupria Manipuri -> Bengali

-- da
['jut'] = {'da'}, -- Jutish -> Danish
['kl'] = {'da'}, -- Kalaallisut -> Danish

['en-gb'] = {'en'}, -- Brexit -> English
['yi'] = {'he'}, -- Yiddish -> Hebrew
['iu'] = {'ike-cans'}, -- Inuktitut -> Eastern Canadian (Aboriginal syllabics)
['xmf'] = {'ka'}, -- Mingrelian -> Georgian
['kbd'] = {'kbd-cyrl', 'ru'}, -- Kabardian -> Адыгэбзэ
['tcy'] = {'kn'}, -- Tulu -> Kannada
['ko-kp'] = {'ko'}, -- 한국어 (조선) -> Korean
['ks'] = {'ks-arab'}, -- Kashmiri -> Kashmiri (Arabic script)

-- lt
['bat-smg'] = {'sgs', 'lt'}, -- Samogitian -> Lithuanian
['sgs'] = {'lt'}, -- Samogitian -> Lithuanian

['ltg'] = {'lv'}, -- Latvian -> Latgalian
['dtp'] = {'ms'}, -- Central Dusun -> Malay
['no'] = {'nb'}, -- Norwegian (bokmål) -> Norwegian Bokmål
['roa-rup'] = {'rup'}, -- Aromanian (other Romance) -> Aromanian
['aln'] = {'sq'}, -- Gheg Albanian -> Albanian
['ug'] = {'ug-arab'}, -- Uyghur -> Uyghur (Arabic script)
['khw'] = {'ur'}, -- Khowar -> Urdu
}

模块:Dev/Entrypoint

WikiAdmin — Mon, 31 Aug 2026 12:54:33 GMT

从 Fandom Developer Wiki 本地化全局模块，源修订 155355

新页面

-- 来源：https://dev.fandom.com/wiki/Module%3AEntrypoint
-- 许可：CC BY-SA，作者与修订记录见来源页面
--- Entrypoint templating wrapper for Scribunto packages.
-- The module generates an entrypoint function that can execute Scribunto
-- package calls in the template context. This allows a package to support
-- both direct and template invocations.
--
-- @script entrypoint
-- @release stable
-- @author [[User:8nml|8nml]]
-- @param {table} package Scribunto package.
-- @error[85] {string} 'you must specify a function to call'
-- @error[91] {string} 'the function you specified did not exist'
-- @error[opt,95] {string} '$2 is not a function'
-- @return {function} Template entrypoint - @{main}.
-- @note Parent frames are not available in Entrypoint's
-- `frame`. This is because recursive (grandparent)
-- frame access is impossible in legacy Scribunto
-- due to [[mw:Manual:Parser#Empty-argument expansion
-- cache|empty-argument expansion cache]] limitations.
-- @note As Entrypoint enables template access rather than
-- a new extension hook, it does not work with named
-- numeric parameters such as `1=` or `2=`. This may
-- result in unexpected behaviour such as Entrypoint
-- and module errors.

--- Stateless, sequential Lua iterator.
-- @function inext
-- @param {table} t Invariant state to loop over.
-- @param {number} i Control variable (current index).
-- @return[opt] {number} Next index.
-- @return[opt] {number|string|table|boolean} Next value.
-- @see [[github:lua/lua/blob/v5.1.1/lbaselib.c#L247]]
local inext = select(1, ipairs{})

--- Check for MediaWiki version 1.25.
-- The concurrent Scribunto release adds a type check for package functions.
-- @variable {boolean} func_check
-- @see [[mw:MediaWiki 1.24/wmf7#Scribunto]]
local func_check = tonumber(mw.site.currentVersion:match('^%d+.%d+')) >= 1.25

--- MediaWiki error message getter.
-- Mimics Scribunto error formatting for script errors.
-- @function msg
-- @param {string} key MediaWiki i18n message key.
-- @param[opt] {string} fn_name Name of package function.
-- @return {string} Formatted lowercase message.
-- @local
local function msg(key, fn_name)
return select(1, mw.message.new(key)
:plain()
:match(':%s*(.-)[.۔。෴։።]?$')
:gsub('^.', mw.ustring.lower)
:gsub('$2', fn_name or '$2')
)
end

--- Template entrypoint function generated by this module.
-- @function main
-- @param {Frame} frame Scribunto frame in module context.
-- @return {string} Module output in template context.
return function(package) return function(f)
local frame = f:getParent()

local args_mt = {}
local arg_cache = {}

args_mt.__pairs = function()
return next, arg_cache, nil
end
args_mt.__ipairs = function()
return inext, arg_cache, 0
end
args_mt.__index = function(t, k)
return arg_cache[k]
end

for key, val in pairs(frame.args) do
arg_cache[key] = val
end
local fn_name = table.remove(arg_cache, 1)

f.args = setmetatable({}, args_mt)
frame.args = setmetatable({}, args_mt)

if not fn_name then
error(msg('scribunto-common-nofunction'))
end

fn_name = mw.text.trim(fn_name)

if not package[fn_name] then
error(msg('scribunto-common-nosuchfunction', fn_name))
end

if func_check and type(package[fn_name]) ~= 'function' then
error(msg('scribunto-common-notafunction', fn_name))
end

return package[fn_name](frame)
end end

模块:Dev/Dialogue

WikiAdmin — Mon, 31 Aug 2026 12:54:32 GMT

从 Fandom Developer Wiki 本地化全局模块，源修订 194365

新页面

-- 来源：https://dev.fandom.com/wiki/Module%3ADialogue
-- 许可：CC BY-SA，作者与修订记录见来源页面
--| Creates dialogue definition lists
--- For whatever reason, refuses to make blockquotes
--- <nowiki>
local Dialogue = {}

----
-- Libraries and Globals
----
-- Parses invocation and template parameters, trims whitespace, and removes blanks.
local getArgs = require('Module:Dev/Arguments').getArgs

----
-- Local Functions
----
local function makeInvokeFunc(funcName)
return function (frame)
local args = getArgs(frame, {removeBlanks = false})
return Dialogue[funcName](args)
end
end

----
-- Public Functions
----
--% Formats dialogue between multiple speakers
--- Intended to replace {{Dialogue}}.
--- Syntax compliant with [[wikipedia:Template:Dialogue]]
--- with portability and citation modifications
--@ frame (table) Invokes the frame from {{Dialogue}}. See [[Template:Dialogue/doc]].
--: (string) HTML <dl />
Dialogue.main = makeInvokeFunc('dialogue')
--% & crafts the Dialogue definition list
--@ args (table) Arguments passed from Module function call <code>[.main]</code> or other Lua Modules
function Dialogue.dialogue (args)
local block = mw.html.create('dl'):addClass('dialogue-wrapper')
for i,v in ipairs(args) do
local next_param = i + 1
local mood_line = next_param / 2
if i == 1 then
if v == 'action' then
block:tag('dd')
:tag('small'):attr('data-dialogue','action')
:tag('u')
:wikitext('['..args[next_param]..']')
:done():done():done()
else
local speaker =
(args[i] and args[args[i]])
and args[args[i]]
or (
type(args[i]) == 'string'
and mw.text.trim(args[i]):len() > 0
)
and args[i]
or nil
speaker = speaker and string.format("'''%s'''", speaker)
local mood = args['mood'..mood_line] or nil
mood = mood and string.format(" ''(%s)''", mood)
if speaker or mood then
block:tag('dt')
:wikitext(
('%s%s'):format( speaker or '', mood or '')
):done()
end
if args[next_param] then
block:tag('dd'):tag('q')
:wikitext(args[next_param])
:done():done()
else
block:tag('dd'):wikitext('...'):done()
end
end
elseif math.fmod(i, 2) == 1 then
if v == 'action' then
block:tag('dd')
:tag('small')
:attr('data-dialogue','action')
:tag('u')
:wikitext('['..args[next_param]..']')
:done():done():done()
else
local speaker =
(args[i] and args[args[i]])
and args[args[i]]
or (
type(args[i]) == 'string'
and mw.text.trim(args[i]):len() > 0
)
and args[i]
or nil
speaker = speaker and string.format("'''%s'''", speaker)
local mood = args['mood'..mood_line] or nil
mood = mood and string.format(" ''(%s)''", mood)
if speaker or mood then
block:tag('dt')
:wikitext(
('%s%s'):format( speaker or '', mood or '')
)
:done()
end
if args[next_param] ~= '' then
block:tag('dd'):tag('q')
:wikitext(args[next_param])
:done():done()
else
block:tag('dd'):wikitext('...'):done()
end
end
end
end
block:done()
if args['cite'] then
block:tag('cite'):wikitext(string.format("— %s", args['cite'])):done()
end
return tostring(block)
end

----
-- Output
----
return Dialogue

模块:Dev/Arguments/i18n

WikiAdmin — Mon, 31 Aug 2026 12:54:31 GMT

从 Fandom Developer Wiki 本地化全局模块，源修订 204766

新页面

-- 来源：https://dev.fandom.com/wiki/Module%3AArguments/i18n
-- 许可：CC BY-SA，作者与修订记录见来源页面
-- <nowiki>
return {
["_metadata"] = {
["order"] = {
"error-overwrite-permission",
"error-value-func",
"error-write-permission"
}
},
["en"] = {
["error-overwrite-permission"] = "could not write to argument table key \"$1\"; overwriting existing arguments is not permitted",
["error-value-func"] = "bad value assigned to option \"valueFunc\" (function expected, got $1)",
["error-write-permission"] = "could not write to argument table key \"$1\"; the table is read-only"
},
["qqq"] = {
["error-overwrite-permission"] = "Error thrown after write attempt to existing arguments when options.noOverwrite is true",
["error-value-func"] = "Error thrown when options.valueFunc is not a function",
["error-write-permission"] = "Error thrown after write attempt to arguments when options.readOnly is true"
},
["bn"] = {
["error-overwrite-permission"] = "আর্গুমেন্ট টেবিল কী \"$1\" কে লিখতে পারেনি ; আগের থেকে থাকা আর্গুমেন্ট কে ওভাররাইট করার অনুমতি নাই",
["error-value-func"] = "\"valueFunc\" কে খারাপ ভ্যালু দেয়া হয়েছে। (fফাঙ্কশনের অপক্ষা করতে $1 পেয়েছে)",
["error-write-permission"] = "আর্গুমেন্ট টেবিল কী \"$1\" কে ওভাররাইট করতে পৰ যায়নি; এই টেবিলটি রিড-অনলি"
},
["de"] = {
["error-overwrite-permission"] = "konnte nicht in den Argument Tabellenschlüssel „$1“ schreiben; das Überschreiben vorhandener Argumente ist nicht erlaubt",
["error-value-func"] = "der Option „valueFunc“ wurde ein falscher Wert zugewiesen (Funktion erwartet, erhielt $1)",
["error-write-permission"] = "konnte nicht in das Argument Tabellenschlüssel „$1“ schreiben; die Tabelle ist schreibgeschützt"
},
["es"] = {
["error-overwrite-permission"] = "No se puede escribir en la clave de matriz de argumentos \"$1\"; no se permite sobrescribir los argumentos existentes",
["error-value-func"] = "Se asignó un valor inválido a la opción \"valueFunc\" (se esperaba una función, se obtuvo $1)",
["error-write-permission"] = "No se puede escribir en la matriz clave de los argumentos \"$1\"; la matriz está en modo de solo lectura"
},
["fr"] = {
["error-overwrite-permission"] = "impossible d'écrire dans la clé du tableau des arguments \"$1\"; l'écrasement des arguments existants n'est pas autorisé",
["error-value-func"] = "valeur invalide assignée à une option \"valueFunc\" (fonction espérée, donne $1)",
["error-write-permission"] = "impossible d'écrire dans la clé du tableau des arguments \"$1\"; le tableau est en mode lecture-seule"
},
["hi"] = {
["error-overwrite-permission"] = "तर्क टेबल की \"$1\" पर ओवर्राइट नहीं किया जा सका; मौजूदा तर्कों को ओवर्राइट करने की अनुमति नहीं है",
["error-value-func"] = "\"valueFunc\" फंक्शन को बुरा वैल्यू निर्धारित किया गया है (फंक्शन की अपेक्षा की, $1 पाया)",
["error-write-permission"] = "तर्क टेबल की \"$1\" पर ओवर्राइट नहीं किया जा सका; टेबल केवल पठन के लिए है"
},
["ru"] = {
["error-overwrite-permission"] = "невозможно записать аргумент \"$1\": перезаписывать существующие аргументы запрещено",
["error-value-func"] = "параметру \"valueFunc\" присвоено неверное значение (ожидается функция, предоставлено $1)",
["error-write-permission"] = "невозможно записать аргумент \"$1\": таблица находится в режиме \"только чтение\""
},
["tr"] = {
["error-overwrite-permission"] = "\"$1\" bağımsız değişken tablosu anahtarına yazılamadı; mevcut bağımsız değişkenlerin üzerine yazılmasına izin verilmez",
["error-value-func"] = "\"valueFunc\" seçeneğine atanan hatalı değer (işlev beklendi, $1 alındı)",
["error-write-permission"] = "\"$1\" bağımsız değişken tablosu anahtarına yazılamadı; tablo salt okunurdur"
}
}
-- </nowiki>

模块:Dev/Arguments

WikiAdmin — Mon, 31 Aug 2026 12:54:30 GMT

从 Fandom Developer Wiki 本地化全局模块，源修订 197966

新页面

-- 来源：https://dev.fandom.com/wiki/Module%3AArguments
-- 许可：CC BY-SA，作者与修订记录见来源页面
--- Arguments invocation argument extractor for Scribunto modules.
-- It is intended for use by other Lua modules, and should not be
-- called from an invocation (`#invoke`) directly.
--
-- This module supports the following features:
-- * Trimming and blank argument removal.
-- * Argument inheritance between child and parent frames.
-- * Argument extraction for external modules and console input.
-- * Options to customise argument extraction behaviour.
--
-- @script arguments
-- @release stable
-- @note The `args` table from the @{arguments.getArgs}
-- function is a metatable for performance reasons.
-- Thus, the table will not permit Lua table methods
-- such as `#args`, @{next|next(args)}, and @{table}
-- library functions.
-- @note This module will eventually be adapted as a
-- library in [[mw:gerrit:q/158323|MediaWiki
-- core]], called as `require('getArgs')`. The core
-- library will remove `options.parentOnly`.
-- @author [[wikipedia:User:Mr. Stradivarius|Mr. Stradivarius]] (Wikipedia)
-- @author [[wikipedia:User:Anomie|Anomie]] (Wikipedia)
-- @author [[wikipedia:User:Jackmcbarn|Jackmcbarn]] (Wikipedia)
-- @author [[User:Dessamator|Dessamator]]
-- @author [[User:DarthKitty|DarthKitty]]
-- @attribution [[wikipedia:Module:Arguments|Module:Arguments]] (Wikipedia)
-- @see [[wikipedia:Module:Arguments|Original module on Wikipedia]]
-- @see [[Module:Arguments/testcases|Test cases for this module]]
local arguments = {}

-- Module dependencies.
local i18n = require('Module:Dev/I18n').loadMessages('Arguments')
local util = require('libraryUtil')
local checkType = util.checkType

-- Four different value tidying functions.
-- This way, we don't have to check the options every time we call them.

--- Default value tidying function.
-- Trims parameter values automatically if they are defined strings.
-- Treats blank strings as `nil`.
-- @function tidyValDefault
-- @param {string|number} key MediaWiki parameter key.
-- @param {string|nil} val MediaWiki parameter value,
-- or nil if `key` is an empty string or nil.
-- @local
local function tidyValDefault(key, val)
if type(val) == 'string' then
val = val:match('^%s*(.-)%s*$')
if val == '' then
return nil
else
return val
end
else
return val
end
end

--- Value tidying function that trims values.
-- Trims parameter values automatically if they are defined strings.
-- @function tidyValTrimOnly
-- @param {string|number} key MediaWiki parameter key.
-- @param {string|nil} val MediaWiki parameter value.
-- @local
local function tidyValTrimOnly(key, val)
if type(val) == 'string' then
return val:match('^%s*(.-)%s*$')
else
return val
end
end

--- Value tidying function that removes blanks.
-- Removes blank values from the arguments table.
-- @function tidyValRemoveBlanksOnly
-- @param {string|number} key MediaWiki parameter key.
-- @param {string|nil} val MediaWiki parameter value,
-- or nil if `key` is whitespace or nil.
-- @local
local function tidyValRemoveBlanksOnly(key, val)
if type(val) == 'string' then
if val:find('%S') then
return val
else
return nil
end
else
return val
end
end

--- Value tidying function that returns original value.
-- Effectively a NOOP function that does no value processing.
-- @function tidyValNoChange
-- @param {string|number} key MediaWiki parameter key.
-- @param {string|nil} val MediaWiki parameter value.
-- @local
local function tidyValNoChange(key, val)
return val
end

--- Parent template title match checker.
-- @function matchesTitle
-- @param {string|number|nil} given Local prefixed page
-- title, or MediaWiki article ID (`wgArticleId`).
-- @param {string} title Title of parent template.
-- @return {boolean} Whether the `given` ID/title matches
-- the title of the parent template.
local function matchesTitle(given, title)
local tp = type( given )
return (tp == 'string' or tp == 'number') and mw.title.new( given ).prefixedText == title
end

--- Default argument translation metatable.
-- @table translate_mt
-- @local
local translate_mt = { __index = function(t, k) return k end }

--- Main argument extraction utility.
-- Arguments are memoized once fetched for optimal performance,
-- as with the `frame.args` metatable in Scribunto core.
--
-- The default argument lookup behaviour uses the child frame arguments
-- first, then the parent frame arguments. There are numerous frame
-- options to change this behaviour.
--
-- The default value tidying behaviour trims parameter values if they
-- are defined strings and treats blank strings as `nil`. This can be
-- customised in the `getArgs` options.
--
-- @param {frame|table} frame Scribunto frame object or
-- Lua arguments table, passed from an invocation
-- or Lua logic such as `frame:getParent()`.
-- If this parameter does not have an `args` field
-- and a `getParent` method, `frame` is assumed
-- to be a Lua arguments table, such as the
-- arguments from a named arguments call.
-- @param[opt] {table} options Extraction/processing options.
-- @param[opt] {boolean} options.trim
-- Whether to trim the blank arguments present in
-- the arguments table. Accepts `false` only.
-- Default: `true`.
-- @param[opt] {boolean} options.removeBlanks
-- Whether to remove blank arguments from the
-- arguments table. Does not shift sequential
-- arguments removed by the processing stage.
-- Accepts `false` only. Default: `true`.
-- @param[opt] {function} options.valueFunc
-- Custom value tidying function for use if the
-- `trim` and `removeBlanks` options don't cover
-- the developer's argument processing use case.
-- @param[opt] {boolean} options.frameOnly
-- Only read arguments from child frame (the
-- `frame` parameter - usually invocation frame).
-- @param[opt] {boolean} options.parentOnly
-- Only read arguments from `frame` parent (the
-- `frame` parameter - usually template frame).
-- @param[opt] {boolean} options.parentFirst
-- Argument lookup in the `frame` parent first,
-- prioritised over the invocation frame arguments.
-- @param[opt] {table} options.wrappers
-- Individual value or array of values, listing
-- wrapper title name(s) or article ID(s) to permit
-- parent argument lookup from.
-- @param[opt] {string|number} options.wrapper
-- Alias of `options.wrappers` - contains title
-- name or article ID to permit parent argument
-- lookup from.
-- @param[opt] {boolean} options.readOnly
-- Whether to restrict write permissions to the
-- arguments table. When set to a truthy value,
-- an error will be thrown on any write attempt.
-- @param[opt] {boolean} options.noOverwrite
-- Whether to restrict overwrite attempts on
-- existing argument keys in the arguments table.
-- When set to a truthy value, an error will be
-- thrown on any write attempt that would result
-- in an existing argument being overwritten.
-- @param[opt] {table} options.translate
-- Map of parameter name aliases to their canonical
-- argument parameter names.
-- @param[opt] {table} options.backtranslate
-- Map of canonical parameter names to their
-- argument parameter aliases.
-- Supersedes `options.translate` if both options
-- are in use.
-- @error[opt,317] 'bad value assigned to option "valueFunc"
-- (function expected, got $type)'
-- @error[opt,407] 'could not write to argument table key "$key";
-- the table is read-only'
-- @error[opt,409] 'could not write to argument table key "$key";
-- overwriting existing arguments is not permitted'
-- @return {table} Arguments extracted from invocation.
-- The argument data is embedded as a metatable in
-- the exported table and cannot be accessed with
-- the `#` operator or @{table} library methods.
-- However, the exported table can be written to if
-- the `options.readOnly` flag parameter is not
-- truthy.
-- @usage
--
-- local getArgs = require('Module:Arguments').getArgs
-- function p.main(frame)
-- local args = getArgs(frame, {
-- wrapper = 'Template:<TEMPLATE>'
-- })
-- -- Use the args table here.
-- -- A common paradigm is `return p._main(args)`.
-- -- This allows other Lua modules to access the
-- -- main logic in a performant manner without a
-- -- frame object.
-- end
--
-- @note Reference tags in the form of `<ref>` will
-- generate phantom references when calling the
-- @{pairs} iterator on the arguments table,
-- **IF** the `<ref>` tag does not appear in the
-- dependent module's wikitext output.
function arguments.getArgs(frame, options)
checkType('getArgs', 1, frame, 'table', true)
checkType('getArgs', 2, options, 'table', true)
frame = frame or {}
options = options or {}

-- Set up argument translation.
options.translate = options.translate or {}
if getmetatable(options.translate) == nil then
setmetatable(options.translate, translate_mt)
end
if options.backtranslate == nil then
options.backtranslate = {}
for k,v in pairs(options.translate) do
options.backtranslate[v] = k
end
end
if options.backtranslate and getmetatable(options.backtranslate) == nil then
setmetatable(options.backtranslate, {
__index = function(t, k)
if options.translate[k] ~= k then
return nil
else
return k
end
end
})
end

-- Get the argument tables. If we were passed a valid frame object,
-- get the frame arguments (fargs) and the parent frame arguments
-- (pargs), depending on the options set and on the parent frame's
-- availability. If we weren't passed a valid frame object, we are
-- being called from another Lua module or from the debug console,
-- so assume that we were passed a table of args directly, and
-- assign it to a new variable (luaArgs).
local fargs, pargs, luaArgs
options.wrappers = options.wrappers or options.wrapper
if
type(frame.args) == 'table' and
type(frame.getParent) == 'function'
then
-- The wrappers option makes Module:Arguments look up
-- arguments in either the frame argument table or the
-- parent argument table, but not both. This means that
-- users can use either the #invoke syntax or a wrapper
-- template without the loss of performance associated
-- with looking arguments up in both the frame and the
-- parent frame.
-- The arguments will be fetched from the parent frame if
-- the parent frame's title is present in options.wrapper;
-- otherwise it will look up arguments in the frame object
-- passed to getArgs.
if options.wrappers then
local parent = frame:getParent()
if not parent then
fargs = frame.args
else
local title = parent:getTitle():gsub('/sandbox$', '')
local found = false
if matchesTitle(options.wrappers, title) then
found = true
elseif type(options.wrappers) == 'table' then
for _,v in pairs(options.wrappers) do
if matchesTitle(v, title) then
found = true
break
end
end
end

-- We test for false specifically here so that nil (the
-- default) acts like true.
if found or options.frameOnly == false then
pargs = parent.args
end
if not found or options.parentOnly == false then
fargs = frame.args
end
end
-- When options.wrapper isn't set, check the other options.
else
if not options.parentOnly then
fargs = frame.args
end
if not options.frameOnly then
local parent = frame:getParent()
pargs = parent and parent.args or nil
end
end
if options.parentFirst then
fargs, pargs = pargs, fargs
end
else
luaArgs = frame
end

-- Set the order of precedence of the argument tables. If the variables are
-- nil, nothing will be added to the table, which is how we avoid clashes
-- between the frame/parent args and the Lua args.
local argTables = {fargs}
argTables[#argTables + 1] = pargs
argTables[#argTables + 1] = luaArgs

-- Generate the tidyVal function. If it has been specified by the user, we
-- use that; if not, we choose one of four functions depending on the
-- options chosen. This is so that we don't have to call the options table
-- every time the function is called.
local tidyVal = options.valueFunc
if tidyVal then
if type(tidyVal) ~= 'function' then
error(i18n:msg('error-value-func', type(tidyVal)), 2)
end
elseif options.trim ~= false then
if options.removeBlanks ~= false then
tidyVal = tidyValDefault
else
tidyVal = tidyValTrimOnly
end
else
if options.removeBlanks ~= false then
tidyVal = tidyValRemoveBlanksOnly
else
tidyVal = tidyValNoChange
end
end

-- Set up the args, metaArgs and nilArgs tables. args will be the one
-- accessed from functions, and metaArgs will hold the actual arguments. Nil
-- arguments are memoized in nilArgs, and the metatable connects all of them
-- together.
local args, metaArgs, nilArgs, metatable = {}, {}, {}, {}
setmetatable(args, metatable)

-- Accepts multiple tables as input and merges their keys and values
-- into one table. If a value is already present it is not overwritten;
-- tables listed earlier have precedence. We are also memoizing nil
-- values, which can be overwritten if they are 's' (soft).
local function mergeArgs(tables)
for _, t in ipairs(tables) do
for key, val in pairs(t) do
if metaArgs[key] == nil and nilArgs[key] ~= 'h' then
local tidiedVal = tidyVal(key, val)
if tidiedVal == nil then
nilArgs[key] = 's'
else
metaArgs[key] = tidiedVal
end
end
end
end
end

-- Define metatable behaviour. Arguments are memoized in the metaArgs table,
-- and are only fetched from the argument tables once. Fetching arguments
-- from the argument tables is the most resource-intensive step in this
-- module, so we try and avoid it where possible. For this reason, nil
-- arguments are also memoized, in the nilArgs table. Also, we keep a record
-- in the metatable of when pairs and ipairs have been called, so we do not
-- run pairs and ipairs on the argument tables more than once. We also do
-- not run ipairs on fargs and pargs if pairs has already been run, as all
-- the arguments will already have been copied over.

-- Fetches an argument when the args table is indexed. First we check
-- to see if the value is memoized, and if not we try and fetch it from
-- the argument tables. When we check memoization, we need to check
-- metaArgs before nilArgs, as both can be non-nil at the same time.
-- If the argument is not present in metaArgs, we also check whether
-- pairs has been run yet. If pairs has already been run, we return nil.
-- This is because all the arguments will have already been copied into
-- metaArgs by the mergeArgs function, meaning that any other arguments
-- must be nil.
metatable.__index = function (t, key)
if type(key) == 'string' then
key = options.translate[key]
end
local val = metaArgs[key]
if val ~= nil then
return val
elseif metatable.donePairs or nilArgs[key] then
return nil
end
for _, argTable in ipairs(argTables) do
local argTableVal = tidyVal(key, argTable[key])
if argTableVal ~= nil then
metaArgs[key] = argTableVal
return argTableVal
end
end
nilArgs[key] = 'h'
return nil
end

metatable.__newindex = function (t, key, val)
-- This function is called when a module tries to add a new
-- value to the args table, or tries to change an existing
-- value.
if type(key) == 'string' then
key = options.translate[key]
end
if options.readOnly then
error(i18n:msg('error-write-permission', tostring(key)), 2)
elseif options.noOverwrite and args[key] ~= nil then
error(i18n:msg('error-overwrite-permission', tostring(key)), 2)
elseif val == nil then
-- If the argument is to be overwritten with nil, we need to erase
-- the value in metaArgs, so that __index, __pairs and __ipairs do
-- not use a previous existing value, if present; and we also need
-- to memoize the nil in nilArgs, so that the value isn't looked
-- up in the argument tables if it is accessed again.
metaArgs[key] = nil
nilArgs[key] = 'h'
else
metaArgs[key] = val
end
end

local function translatenext(invariant)
local k, v = next(invariant.t, invariant.k)
invariant.k = k
if k == nil then
return nil
elseif type(k) ~= 'string' or not options.backtranslate then
return k, v
else
local backtranslate = options.backtranslate[k]
if backtranslate == nil then
-- Skip this one. This is a tail call, so this
-- won't cause stack overflow.
return translatenext(invariant)
else
return backtranslate, v
end
end
end

-- This metamethod is called when pairs is run on the args table.
metatable.__pairs = function ()
if not metatable.donePairs then
mergeArgs(argTables)
metatable.donePairs = true
end
return translatenext, { t = metaArgs }
end

-- This custom `ipairs`-style iterator uses our __index metamethod.
local function inext(t, i)
local v = t[i + 1]
if v ~= nil then
return i + 1, v
end
end

-- This metamethod is called when ipairs is run on the args table.
metatable.__ipairs = function (t)
return inext, t, 0
end

return args
end

return arguments

文件:Fish raw.png

WikiAdmin — Mon, 31 Aug 2026 12:23:23 GMT

WikiAdmin上传文件:Fish raw.png == 摘要 == 从旧 Fandom Unimage Wiki 迁移图片

新页面

文件:Chao icon1.png

WikiAdmin — Mon, 31 Aug 2026 12:23:23 GMT

WikiAdmin上传文件:Chao icon1.png == 摘要 == 从旧 Fandom Unimage Wiki 迁移图片

新页面

文件:Zs4.gif

WikiAdmin — Mon, 31 Aug 2026 12:23:22 GMT

WikiAdmin上传文件:Zs4.gif == 摘要 == 从旧 Fandom Unimage Wiki 迁移图片

新页面

文件:Sg.png

WikiAdmin — Mon, 31 Aug 2026 12:23:22 GMT

WikiAdmin上传文件:Sg.png == 摘要 == 从旧 Fandom Unimage Wiki 迁移图片

新页面

文件:Declined.png