Regio - Recent changes [en]

Wave Decay

Marie — Mon, 20 Jul 2026 23:53:23 GMT

← Older revision		Revision as of 23:53, 20 July 2026
Line 1:		Line 1:
	'''Wave Decay''' is a phenomena created when living beings are exposed to altered versions of the [[Universal Wave Construction]]. Exposure to these altered waves for prolonged periods of time are known to have extremely dangerous side-effects, utilized in the [[Wave Bomb\|Wave Bombs]] that rendered much of the world uninhabitable.		'''Wave Decay''' is a phenomena created when living beings are exposed to altered versions of the [[Universal Wave Construction]]. Exposure to these altered waves for prolonged periods of time are known to have extremely dangerous side-effects, utilized in the [[Wave Bomb\|Wave Bombs]] that rendered much of the world uninhabitable. When exposed to altered waves, all living matter is known to experience mutations and alterations depending on the differences between the wave exposed to and the Universal Wave Construction.

Wave Decay

Marie — Mon, 20 Jul 2026 23:50:01 GMT

Created page with "'''Wave Decay''' is a phenomena created when living beings are exposed to altered versions of the Universal Wave Construction. Exposure to these altered waves for prolonged periods of time are known to have extremely dangerous side-effects, utilized in the Wave Bombs that rendered much of the world uninhabitable."

New page

'''Wave Decay''' is a phenomena created when living beings are exposed to altered versions of the [[Universal Wave Construction]]. Exposure to these altered waves for prolonged periods of time are known to have extremely dangerous side-effects, utilized in the [[Wave Bomb|Wave Bombs]] that rendered much of the world uninhabitable.

War of All Colors

Marie — Mon, 20 Jul 2026 23:27:43 GMT

Created page with "The '''War of All Colors''' was a globe-spanning conflict and the deadliest conflict in history. The war was fought between all major powers of the Pre-Wave Decay world. The war saw the first use of large-scale organized machine warfare, which culminated in the deployment of the Wave Bomb by several nations of the world. The exact causes behind the war have been long forgotten, as many of the nations involved were rendered completely uninhabitable due to Wave Decay."

New page

The '''War of All Colors''' was a globe-spanning conflict and the deadliest conflict in history. The war was fought between all major powers of the Pre-[[Wave Decay]] world. The war saw the first use of large-scale organized machine warfare, which culminated in the deployment of the [[Wave Bomb]] by several nations of the world. The exact causes behind the war have been long forgotten, as many of the nations involved were rendered completely uninhabitable due to Wave Decay.

Module:Documentation

Marie — Mon, 20 Jul 2026 23:19:14 GMT

Marie imported Module:Documentation by file upload (1 revision)

Show changes

Module:Documentation/config

Marie — Mon, 20 Jul 2026 23:19:14 GMT

Marie imported Module:Documentation/config by file upload (1 revision)

New page

----------------------------------------------------------------------------------------------------
--
-- Configuration for Module:Documentation
--
-- Here you can set the values of the parameters and messages used in Module:Documentation to
-- localise it to your wiki and your language. Unless specified otherwise, values given here
-- should be string values.
----------------------------------------------------------------------------------------------------

local cfg = {} -- Do not edit this line.

----------------------------------------------------------------------------------------------------
-- Protection template configuration
----------------------------------------------------------------------------------------------------

-- cfg['protection-template']
-- The name of the template that displays the protection icon (a padlock on enwiki).
cfg['protection-template'] = 'pp-template'

--[[
-- cfg['protection-template-args']
-- Any arguments to send to the protection template. This should be a Lua table.
-- For example, if the protection template is "pp-template", and the wikitext template invocation
-- looks like "{{pp-template|docusage=yes}}", then this table should look like "{docusage = 'yes'}".
--]]
cfg['protection-template-args'] = {docusage = 'yes'}

--[[
----------------------------------------------------------------------------------------------------
-- Sandbox notice configuration
--
-- On sandbox pages the module can display a template notifying users that the current page is a
-- sandbox, and the location of test cases pages, etc. The module decides whether the page is a
-- sandbox or not based on the value of cfg['sandbox-subpage']. The following settings configure the
-- messages that the notices contains.
----------------------------------------------------------------------------------------------------
--]]

-- cfg['sandbox-notice-image']
-- The image displayed in the sandbox notice.
cfg['sandbox-notice-image'] = '[[Image:Sandbox.png|50px|alt=|link=]]'

--[[
-- cfg['sandbox-notice-pagetype-template']
-- cfg['sandbox-notice-pagetype-module']
-- cfg['sandbox-notice-pagetype-other']
-- The page type of the sandbox page. The message that is displayed depends on the current subject
-- namespace. This message is used in either cfg['sandbox-notice-blurb'] or
-- cfg['sandbox-notice-diff-blurb'].
--]]
cfg['sandbox-notice-pagetype-template'] = '[[Blazblue_Wiki:Template test cases|template sandbox]] page'
cfg['sandbox-notice-pagetype-module'] = '[[Blazblue_Wiki:Template test cases|module sandbox]] page'
cfg['sandbox-notice-pagetype-other'] = 'sandbox page'

--[[
-- cfg['sandbox-notice-blurb']
-- cfg['sandbox-notice-diff-blurb']
-- cfg['sandbox-notice-diff-display']
-- Either cfg['sandbox-notice-blurb'] or cfg['sandbox-notice-diff-blurb'] is the opening sentence
-- of the sandbox notice. The latter has a diff link, but the former does not. $1 is the page
-- type, which is either cfg['sandbox-notice-pagetype-template'],
-- cfg['sandbox-notice-pagetype-module'] or cfg['sandbox-notice-pagetype-other'] depending what
-- namespace we are in. $2 is a link to the main template page, and $3 is a diff link between
-- the sandbox and the main template. The display value of the diff link is set by
-- cfg['sandbox-notice-compare-link-display'].
--]]
cfg['sandbox-notice-blurb'] = 'This is the $1 for $2.'
cfg['sandbox-notice-diff-blurb'] = 'This is the $1 for $2 ($3).'
cfg['sandbox-notice-compare-link-display'] = 'diff'

--[[
-- cfg['sandbox-notice-testcases-blurb']
-- cfg['sandbox-notice-testcases-link-display']
-- cfg['sandbox-notice-testcases-blurb'] is a sentence notifying the user that there is a test cases page
-- corresponding to this sandbox that they can edit. $1 is a link to the test cases page.
-- cfg['sandbox-notice-testcases-link-display'] is the display value for that link.
--]]
cfg['sandbox-notice-testcases-blurb'] = 'See also the companion subpage for $1.'
cfg['sandbox-notice-testcases-link-display'] = 'test cases'

-- cfg['sandbox-category']
-- A category to add to all template sandboxes.
cfg['sandbox-category'] = 'Template sandboxes'

----------------------------------------------------------------------------------------------------
-- Start box configuration
----------------------------------------------------------------------------------------------------

-- cfg['documentation-icon-wikitext']
-- The wikitext for the icon shown at the top of the template.
cfg['documentation-icon-wikitext'] = '[[File:Template-info.png|50px|link=|alt=Documentation icon]]'

-- cfg['template-namespace-heading']
-- The heading shown in the template namespace.
cfg['template-namespace-heading'] = 'Template documentation'

-- cfg['module-namespace-heading']
-- The heading shown in the module namespace.
cfg['module-namespace-heading'] = 'Module documentation'

-- cfg['file-namespace-heading']
-- The heading shown in the file namespace.
cfg['file-namespace-heading'] = 'Summary'

-- cfg['other-namespaces-heading']
-- The heading shown in other namespaces.
cfg['other-namespaces-heading'] = 'Documentation'

-- cfg['view-link-display']
-- The text to display for "view" links.
cfg['view-link-display'] = 'view'

-- cfg['edit-link-display']
-- The text to display for "edit" links.
cfg['edit-link-display'] = 'edit'

-- cfg['history-link-display']
-- The text to display for "history" links.
cfg['history-link-display'] = 'history'

-- cfg['purge-link-display']
-- The text to display for "purge" links.
cfg['purge-link-display'] = 'purge'

-- cfg['create-link-display']
-- The text to display for "create" links.
cfg['create-link-display'] = 'create'

----------------------------------------------------------------------------------------------------
-- Link box (end box) configuration
----------------------------------------------------------------------------------------------------

-- cfg['transcluded-from-blurb']
-- Notice displayed when the docs are transcluded from another page. $1 is a wikilink to that page.
cfg['transcluded-from-blurb'] = 'The above [[Blazblue_Wiki:Template documentation|documentation]] is [[Blazblue_Wiki:Transclusion|transcluded]] from $1.'

--[[
-- cfg['create-module-doc-blurb']
-- Notice displayed in the module namespace when the documentation subpage does not exist.
-- $1 is a link to create the documentation page with the preload cfg['module-preload'] and the
-- display cfg['create-link-display'].
--]]
cfg['create-module-doc-blurb'] = 'You might want to $1 a documentation page for this [[Blazblue_Wiki:Lua|Scribunto module]].'

----------------------------------------------------------------------------------------------------
-- Experiment blurb configuration
----------------------------------------------------------------------------------------------------

--[[
-- cfg['experiment-blurb-template']
-- cfg['experiment-blurb-module']
-- The experiment blurb is the text inviting editors to experiment in sandbox and test cases pages.
-- It is only shown in the template and module namespaces. With the default English settings, it
-- might look like this:
--
-- Editors can experiment in this template's sandbox (edit | diff) and testcases (edit) pages.
--
-- In this example, "sandbox", "edit", "diff", "testcases", and "edit" would all be links.
--
-- There are two versions, cfg['experiment-blurb-template'] and cfg['experiment-blurb-module'], depending
-- on what namespace we are in.
--
-- Parameters:
--
-- $1 is a link to the sandbox page. If the sandbox exists, it is in the following format:
--
-- cfg['sandbox-link-display'] (cfg['sandbox-edit-link-display'] | cfg['compare-link-display'])
--
-- If the sandbox doesn't exist, it is in the format:
--
-- cfg['sandbox-link-display'] (cfg['sandbox-create-link-display'] | cfg['mirror-link-display'])
--
-- The link for cfg['sandbox-create-link-display'] link preloads the page with cfg['template-sandbox-preload']
-- or cfg['module-sandbox-preload'], depending on the current namespace. The link for cfg['mirror-link-display']
-- loads a default edit summary of cfg['mirror-edit-summary'].
--
-- $2 is a link to the test cases page. If the test cases page exists, it is in the following format:
--
-- cfg['testcases-link-display'] (cfg['testcases-edit-link-display'])
--
-- If the test cases page doesn't exist, it is in the format:
--
-- cfg['testcases-link-display'] (cfg['testcases-create-link-display'])
--
-- If the test cases page doesn't exist, the link for cfg['testcases-create-link-display'] preloads the
-- page with cfg['template-testcases-preload'] or cfg['module-testcases-preload'], depending on the current
-- namespace.
--]]
cfg['experiment-blurb-template'] = "Editors can experiment in this template's $1 and $2 pages."
cfg['experiment-blurb-module'] = "Editors can experiment in this module's $1 and $2 pages."

----------------------------------------------------------------------------------------------------
-- Sandbox link configuration
----------------------------------------------------------------------------------------------------

-- cfg['sandbox-subpage']
-- The name of the template subpage typically used for sandboxes.
cfg['sandbox-subpage'] = 'sandbox'

-- cfg['template-sandbox-preload']
-- Preload file for template sandbox pages.
cfg['template-sandbox-preload'] = 'Template:Documentation/preload-sandbox'

-- cfg['module-sandbox-preload']
-- Preload file for Lua module sandbox pages.
cfg['module-sandbox-preload'] = 'Template:Documentation/preload-module-sandbox'

-- cfg['sandbox-link-display']
-- The text to display for "sandbox" links.
cfg['sandbox-link-display'] = 'sandbox'

-- cfg['sandbox-edit-link-display']
-- The text to display for sandbox "edit" links.
cfg['sandbox-edit-link-display'] = 'edit'

-- cfg['sandbox-create-link-display']
-- The text to display for sandbox "create" links.
cfg['sandbox-create-link-display'] = 'create'

-- cfg['compare-link-display']
-- The text to display for "compare" links.
cfg['compare-link-display'] = 'diff'

-- cfg['mirror-edit-summary']
-- The default edit summary to use when a user clicks the "mirror" link. $1 is a wikilink to the
-- template page.
cfg['mirror-edit-summary'] = 'Create sandbox version of $1'

-- cfg['mirror-link-display']
-- The text to display for "mirror" links.
cfg['mirror-link-display'] = 'mirror'

----------------------------------------------------------------------------------------------------
-- Test cases link configuration
----------------------------------------------------------------------------------------------------

-- cfg['testcases-subpage']
-- The name of the template subpage typically used for test cases.
cfg['testcases-subpage'] = 'testcases'

-- cfg['template-testcases-preload']
-- Preload file for template test cases pages.
cfg['template-testcases-preload'] = 'Template:Documentation/preload-testcases'

-- cfg['module-testcases-preload']
-- Preload file for Lua module test cases pages.
cfg['module-testcases-preload'] = 'Template:Documentation/preload-module-testcases'

-- cfg['testcases-link-display']
-- The text to display for "testcases" links.
cfg['testcases-link-display'] = 'testcases'

-- cfg['testcases-edit-link-display']
-- The text to display for test cases "edit" links.
cfg['testcases-edit-link-display'] = 'edit'

-- cfg['testcases-create-link-display']
-- The text to display for test cases "create" links.
cfg['testcases-create-link-display'] = 'create'

----------------------------------------------------------------------------------------------------
-- Add categories blurb configuration
----------------------------------------------------------------------------------------------------

--[[
-- cfg['add-categories-blurb']
-- Text to direct users to add categories to the /doc subpage. Not used if the "content" or
-- "docname fed" arguments are set, as then it is not clear where to add the categories. $1 is a
-- link to the /doc subpage with a display value of cfg['doc-link-display'].
--]]
cfg['add-categories-blurb'] = 'Please add categories to the $1 subpage.'

-- cfg['doc-link-display']
-- The text to display when linking to the /doc subpage.
cfg['doc-link-display'] = '/doc'

----------------------------------------------------------------------------------------------------
-- Subpages link configuration
----------------------------------------------------------------------------------------------------

--[[
-- cfg['subpages-blurb']
-- The "Subpages of this template" blurb. $1 is a link to the main template's subpages with a
-- display value of cfg['subpages-link-display']. In the English version this blurb is simply
-- the link followed by a period, and the link display provides the actual text.
--]]
cfg['subpages-blurb'] = '$1.'

--[[
-- cfg['subpages-link-display']
-- The text to display for the "subpages of this page" link. $1 is cfg['template-pagetype'],
-- cfg['module-pagetype'] or cfg['default-pagetype'], depending on whether the current page is in
-- the template namespace, the module namespace, or another namespace.
--]]
cfg['subpages-link-display'] = 'Subpages of this $1'

-- cfg['template-pagetype']
-- The pagetype to display for template pages.
cfg['template-pagetype'] = 'template'

-- cfg['module-pagetype']
-- The pagetype to display for Lua module pages.
cfg['module-pagetype'] = 'module'

-- cfg['default-pagetype']
-- The pagetype to display for pages other than templates or Lua modules.
cfg['default-pagetype'] = 'page'

----------------------------------------------------------------------------------------------------
-- Doc link configuration
----------------------------------------------------------------------------------------------------

-- cfg['doc-subpage']
-- The name of the subpage typically used for documentation pages.
cfg['doc-subpage'] = 'doc'

-- cfg['file-docpage-preload']
-- Preload file for documentation page in the file namespace.
cfg['file-docpage-preload'] = 'Template:Documentation/preload-filespace'

-- cfg['docpage-preload']
-- Preload file for template documentation pages in all namespaces.
cfg['docpage-preload'] = 'Template:Documentation/preload'

-- cfg['module-preload']
-- Preload file for Lua module documentation pages.
cfg['module-preload'] = 'Template:Documentation/preload-module-doc'

----------------------------------------------------------------------------------------------------
-- Print version configuration
----------------------------------------------------------------------------------------------------

-- cfg['print-subpage']
-- The name of the template subpage used for print versions.
cfg['print-subpage'] = 'Print'

-- cfg['print-link-display']
-- The text to display when linking to the /Print subpage.
cfg['print-link-display'] = '/Print'

-- cfg['print-blurb']
-- Text to display if a /Print subpage exists. $1 is a link to the subpage with a display value of cfg['print-link-display'].
cfg['print-blurb'] = 'A [[Help:Books/for experts#Improving the book layout|print version]] of this template exists at $1.'
.. ' If you make a change to this template, please update the print version as well.'

-- cfg['display-print-category']
-- Set to true to enable output of cfg['print-category'] if a /Print subpage exists.
-- This should be a boolean value (either true or false).
cfg['display-print-category'] = true

-- cfg['print-category']
-- Category to output if cfg['display-print-category'] is set to true, and a /Print subpage exists.
cfg['print-category'] = 'Templates with print versions'

----------------------------------------------------------------------------------------------------
-- HTML and CSS configuration
----------------------------------------------------------------------------------------------------

-- cfg['main-div-id']
-- The "id" attribute of the main HTML "div" tag.
cfg['main-div-id'] = 'template-documentation'

-- cfg['main-div-classes']
-- The CSS classes added to the main HTML "div" tag.
cfg['main-div-classes'] = 'template-documentation iezoomfix'

-- cfg['start-box-linkclasses']
-- The CSS classes used for the [view][edit][history] or [create] links in the start box.
cfg['start-box-linkclasses'] = 'mw-editsection-like plainlinks'

-- cfg['start-box-link-id']
-- The HTML "id" attribute for the links in the start box.
cfg['start-box-link-id'] = 'doc_editlinks'

----------------------------------------------------------------------------------------------------
-- {{fmbox}} template configuration
----------------------------------------------------------------------------------------------------

-- cfg['fmbox-id']
-- The id sent to the "id" parameter of the {{fmbox}} template.
cfg['fmbox-id'] = 'documentation-meta-data'

-- cfg['fmbox-style']
-- The value sent to the style parameter of {{fmbox}}. --#ecfcf4
cfg['fmbox-style'] = 'background-color: inherit'

-- cfg['fmbox-textstyle']
-- The value sent to the "textstyle parameter of {{fmbox}}.
cfg['fmbox-textstyle'] = 'font-style: italic'

----------------------------------------------------------------------------------------------------
-- Tracking category configuration
----------------------------------------------------------------------------------------------------

-- cfg['display-strange-usage-category']
-- Set to true to enable output of cfg['strange-usage-category'] if the module is used on a /doc subpage
-- or a /testcases subpage. This should be a boolean value (either true or false).
cfg['display-strange-usage-category'] = true

-- cfg['strange-usage-category']
-- Category to output if cfg['display-strange-usage-category'] is set to true and the module is used on a
-- /doc subpage or a /testcases subpage.
cfg['strange-usage-category'] = 'Blazblue Wiki pages with strange ((documentation)) usage'

--[[
----------------------------------------------------------------------------------------------------
-- End configuration
--
-- Don't edit anything below this line.
----------------------------------------------------------------------------------------------------
--]]

return cfg

Module:HtmlBuilder

Marie — Mon, 20 Jul 2026 23:19:14 GMT

Marie imported Module:HtmlBuilder by file upload (1 revision)

New page

-- Module for building complex HTML (e.g. infoboxes, navboxes) using a fluent interface.

local HtmlBuilder = {}

local metatable = {}

metatable.__index = function(t, key)
local ret = rawget(t, key)
if ret then
return ret
end

ret = metatable[key]
if type(ret) == 'function' then
return function(...)
return ret(t, ...)
end
else
return ret
end
end

metatable.__tostring = function(t)
local ret = {}
t._build(ret)
return table.concat(ret)
end

metatable._build = function(t, ret)
if t.tagName then
table.insert(ret, '<' .. t.tagName)
for i, attr in ipairs(t.attributes) do
table.insert(ret, ' ' .. attr.name .. '="' .. attr.val .. '"')
end
if #t.styles > 0 then
table.insert(ret, ' style="')
for i, prop in ipairs(t.styles) do
if type(prop) == 'string' then -- added with cssText()
table.insert(ret, prop .. ';')
else -- added with css()
table.insert(ret, prop.name .. ':' .. prop.val .. ';')
end
end
table.insert(ret, '"')
end
if t.selfClosing then
table.insert(ret, ' /')
end
table.insert(ret, '>')
end
for i, node in ipairs(t.nodes) do
if node then
if type(node) == 'table' then
node._build(ret)
else
table.insert(ret, tostring(node))
end
end
end
if t.tagName and not t.unclosed and not t.selfClosing then
table.insert(ret, '</' .. t.tagName .. '>')
end
end

metatable.node = function(t, builder)
if builder then
table.insert(t.nodes, builder)
end
return t
end

metatable.wikitext = function(t, ...)
local vals = {...}
for i = 1, #vals do
if vals[i] then
table.insert(t.nodes, vals[i])
end
end
return t
end

metatable.newline = function(t)
table.insert(t.nodes, '\n')
return t
end

metatable.tag = function(t, tagName, args)
args = args or {}
args.parent = t
local builder = HtmlBuilder.create(tagName, args)
table.insert(t.nodes, builder)
return builder
end

local function getAttr(t, name)
for i, attr in ipairs(t.attributes) do
if attr.name == name then
return attr
end
end
end

metatable.attr = function(t, name, val)
if type(val) == 'string' or type(val) == 'number' then
-- if caller sets the style attribute explicitly, then replace all styles previously added with css() and cssText()
if name == 'style' then
t.styles = {val}
return t
end

local attr = getAttr(t, name)
if attr then
attr.val = val
else
table.insert(t.attributes, {name = name, val = val})
end
end

return t
end

metatable.addClass = function(t, class)
if class then
local attr = getAttr(t, 'class')
if attr then
attr.val = attr.val .. ' ' .. class
else
t.attr('class', class)
end
end

return t
end

metatable.css = function(t, name, val)
if type(val) == 'string' or type(val) == 'number' then
for i, prop in ipairs(t.styles) do
if prop.name == name then
prop.val = val
return t
end
end

table.insert(t.styles, {name = name, val = val})
end

return t
end

metatable.cssText = function(t, css)
if css then
table.insert(t.styles, css)
end
return t
end

metatable.done = function(t)
return t.parent or t
end

metatable.allDone = function(t)
while t.parent do
t = t.parent
end
return t
end

function HtmlBuilder.create(tagName, args)
args = args or {}
local builder = {}
setmetatable(builder, metatable)
builder.nodes = {}
builder.attributes = {}
builder.styles = {}
builder.tagName = tagName
builder.parent = args.parent
builder.unclosed = args.unclosed or false
builder.selfClosing = args.selfClosing or false
return builder
end

return HtmlBuilder

Module:Message box

Marie — Mon, 20 Jul 2026 23:19:14 GMT

Marie imported Module:Message box by file upload (1 revision)

New page

-- This is a meta-module for producing message box templates, including
-- {{mbox}}, {{ambox}}, {{imbox}}, {{tmbox}}, {{ombox}}, {{cmbox}} and {{fmbox}}.

-- Require necessary modules.
local getArgs = require('Module:Arguments').getArgs
local htmlBuilder = require('Module:HtmlBuilder')
local categoryHandler = require('Module:Category handler').main
local yesno = require('Module:Yesno')

-- Load the configuration page.
local cfgTables = mw.loadData('Module:Message box/configuration')

-- Get a language object for formatDate and ucfirst.
local lang = mw.language.getContentLanguage()

-- Set aliases for often-used functions to reduce table lookups.
local format = mw.ustring.format
local tinsert = table.insert
local tconcat = table.concat
local trim = mw.text.trim

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

local function getTitleObject(page, ...)
if type(page) == 'string' then
-- Get the title object, passing the function through pcall
-- in case we are over the expensive function count limit.
local success, title = pcall(mw.title.new, page, ...)
if success then
return title
end
end
end

local function union(t1, t2)
-- Returns the union of two arrays.
local vals = {}
for i, v in ipairs(t1) do
vals[v] = true
end
for i, v in ipairs(t2) do
vals[v] = true
end
local ret = {}
for k in pairs(vals) do
tinsert(ret, k)
end
table.sort(ret)
return ret
end

local function getArgNums(args, prefix)
local nums = {}
for k, v in pairs(args) do
local num = mw.ustring.match(tostring(k), '^' .. prefix .. '([1-9]%d*)$')
if num then
tinsert(nums, tonumber(num))
end
end
table.sort(nums)
return nums
end

--------------------------------------------------------------------------------
-- Box class definition
--------------------------------------------------------------------------------

local box = {}
box.__index = box

function box.new()
local obj = {}
setmetatable(obj, box)
return obj
end

function box.getNamespaceId(ns)
if not ns then return end
if type(ns) == 'string' then
ns = lang:ucfirst(mw.ustring.lower(ns))
if ns == 'Main' then
ns = 0
end
end
local nsTable = mw.site.namespaces[ns]
if nsTable then
return nsTable.id
end
end

function box.getMboxType(nsid)
-- Gets the mbox type from a namespace number.
if nsid == 0 then
return 'ambox' -- main namespace
elseif nsid == 6 then
return 'imbox' -- file namespace
elseif nsid == 14 then
return 'cmbox' -- category namespace
else
local nsTable = mw.site.namespaces[nsid]
if nsTable and nsTable.isTalk then
return 'tmbox' -- any talk namespace
else
return 'ombox' -- other namespaces or invalid input
end
end
end

function box:addCat(ns, cat, sort)
if type(cat) ~= 'string' then return end
local nsVals = {'main', 'template', 'all'}
local tname
for i, val in ipairs(nsVals) do
if ns == val then
tname = ns .. 'Cats'
end
end
if not tname then
for i, val in ipairs(nsVals) do
nsVals[i] = format('"%s"', val)
end
error(
'invalid ns parameter passed to box:addCat; valid values are '
.. mw.text.listToText(nsVals, nil, ' or ')
)
end
self[tname] = self[tname] or {}
if type(sort) == 'string' then
tinsert(self[tname], format('[[Category:%s|%s]]', cat, sort))
else
tinsert(self[tname], format('[[Category:%s]]', cat))
end
end

function box:addClass(class)
if type(class) ~= 'string' then return end
self.classes = self.classes or {}
tinsert(self.classes, class)
end

function box:addAttr(attr, val)
if type(attr) ~= 'string' or type(val) ~= 'string' then return end
self.attrs = self.attrs or {}
tinsert(self.attrs, attr)
end

function box:setTitle(args)
-- Get the title object and the namespace.
self.pageTitle = getTitleObject(args.page ~= '' and args.page)
self.title = self.pageTitle or mw.title.getCurrentTitle()
self.demospace = args.demospace ~= '' and args.demospace or nil
self.nsid = box.getNamespaceId(self.demospace) or self.title.namespace
end

function box:getConfig(boxType)
-- Get the box config data from the data page.
if boxType == 'mbox' then
boxType = box.getMboxType(self.nsid)
end
local cfg = cfgTables[boxType]
if not cfg then
local boxTypes = {}
for k, v in pairs(dataTables) do
tinsert(boxTypes, format('"%s"', k))
end
tinsert(boxTypes, '"mbox"')
error(format(
'invalid message box type "%s"; valid types are %s',
tostring(boxType),
mw.text.listToText(boxTypes)
), 2)
end
return cfg
end

function box:removeBlankArgs(cfg, args)
-- Only allow blank arguments for the parameter names listed in
-- cfg.allowBlankParams.
local newArgs = {}
for k, v in pairs(args) do
if v ~= '' then
newArgs[k] = v
end
end
for i, param in ipairs(cfg.allowBlankParams or {}) do
newArgs[param] = args[param]
end
return newArgs
end

function box:setBoxParameters(cfg, args)
-- Get type data.
self.type = args.type
local typeData = cfg.types[self.type]
self.invalidTypeError = cfg.showInvalidTypeError
and self.type
and not typeData
and true
or false
typeData = typeData or cfg.types[cfg.default]
self.typeClass = typeData.class
self.typeImage = typeData.image

-- Find if the box has been wrongly substituted.
if cfg.substCheck and args.subst == 'SUBST' then
self.isSubstituted = true
end

-- Find whether we are using a small message box.
if cfg.allowSmall and (
cfg.smallParam and args.small == cfg.smallParam
or not cfg.smallParam and yesno(args.small)
)
then
self.isSmall = true
else
self.isSmall = false
end

-- Add attributes, classes and styles.
if cfg.allowId then
self.id = args.id
end
self:addClass(
cfg.usePlainlinksParam and yesno(args.plainlinks or true) and 'plainlinks'
)
for _, class in ipairs(cfg.classes or {}) do
self:addClass(class)
end
if self.isSmall then
self:addClass(cfg.smallClass or 'mbox-small')
end
self:addClass(self.typeClass)
self:addClass(args.class)
self.style = args.style
self.attrs = args.attrs

-- Set text style.
self.textstyle = args.textstyle

-- Find if we are on the template page or not. This functionality is only
-- used if useCollapsibleTextFields is set, or if both cfg.templateCategory
-- and cfg.templateCategoryRequireName are set.
self.useCollapsibleTextFields = cfg.useCollapsibleTextFields
if self.useCollapsibleTextFields
or cfg.templateCategory
and cfg.templateCategoryRequireName
then
self.name = args.name
if self.name then
local templateName = mw.ustring.match(
self.name,
'^[tT][eE][mM][pP][lL][aA][tT][eE][%s_]*:[%s_]*(.*)$'
) or self.name
templateName = 'Template:' .. templateName
self.templateTitle = getTitleObject(templateName)
end
self.isTemplatePage = self.templateTitle
and mw.title.equals(self.title, self.templateTitle)
or false
end

-- Process data for collapsible text fields. At the moment these are only
-- used in {{ambox}}.
if self.useCollapsibleTextFields then
-- Get the self.issue value.
if self.isSmall and args.smalltext then
self.issue = args.smalltext
else
local sect
if args.sect == '' then
sect = 'This ' .. (cfg.sectionDefault or 'page')
elseif type(args.sect) == 'string' then
sect = 'This ' .. args.sect
end
local issue = args.issue
issue = type(issue) == 'string' and issue ~= '' and issue or nil
local text = args.text
text = type(text) == 'string' and text or nil
local issues = {}
tinsert(issues, sect)
tinsert(issues, issue)
tinsert(issues, text)
self.issue = tconcat(issues, ' ')
end

-- Get the self.talk value.
local talk = args.talk
-- Show talk links on the template page or template subpages if the talk
-- parameter is blank.
if talk == ''
and self.templateTitle
and (
mw.title.equals(self.templateTitle, self.title)
or self.title:isSubpageOf(self.templateTitle)
)
then
talk = '#'
elseif talk == '' then
talk = nil
end
if talk then
-- If the talk value is a talk page, make a link to that page. Else
-- assume that it's a section heading, and make a link to the talk
-- page of the current page with that section heading.
local talkTitle = getTitleObject(talk)
local talkArgIsTalkPage = true
if not talkTitle or not talkTitle.isTalkPage then
talkArgIsTalkPage = false
talkTitle = getTitleObject(
self.title.text,
mw.site.namespaces[self.title.namespace].talk.id
)
end
if talkTitle and talkTitle.exists then
local talkText = 'Relevant discussion may be found on'
if talkArgIsTalkPage then
talkText = format(
'%s [[%s|%s]].',
talkText,
talk,
talkTitle.prefixedText
)
else
talkText = format(
'%s the [[%s#%s|talk page]].',
talkText,
talkTitle.prefixedText,
talk
)
end
self.talk = talkText
end
end

-- Get other values.
self.fix = args.fix ~= '' and args.fix or nil
local date
if args.date and args.date ~= '' then
date = args.date
elseif args.date == '' and self.isTemplatePage then
date = lang:formatDate('F Y')
end
if date then
self.date = format(" <small>''(%s)''</small>", date)
end
self.info = args.info
end

-- Set the non-collapsible text field. At the moment this is used by all box
-- types other than ambox, and also by ambox when small=yes.
if self.isSmall then
self.text = args.smalltext or args.text
else
self.text = args.text
end

-- Set the below row.
self.below = cfg.below and args.below

-- General image settings.
self.imageCellDiv = not self.isSmall and cfg.imageCellDiv and true or false
self.imageEmptyCell = cfg.imageEmptyCell
if cfg.imageEmptyCellStyle then
self.imageEmptyCellStyle = 'border:none;padding:0px;width:1px'
end

-- Left image settings.
local imageLeft = self.isSmall and args.smallimage or args.image
if cfg.imageCheckBlank and imageLeft ~= 'blank' and imageLeft ~= 'none'
or not cfg.imageCheckBlank and imageLeft ~= 'none'
then
self.imageLeft = imageLeft
if not imageLeft then
local imageSize = self.isSmall
and (cfg.imageSmallSize or '30x30px')
or '40x40px'
self.imageLeft = format('[[File:%s|%s|link=|alt=]]', self.typeImage
or 'Imbox notice.svg', imageSize)
end
end

-- Right image settings.
local imageRight = self.isSmall and args.smallimageright or args.imageright
if not (cfg.imageRightNone and imageRight == 'none') then
self.imageRight = imageRight
end

-- Add mainspace categories. At the moment these are only used in {{ambox}}.
if cfg.allowMainspaceCategories then
if args.cat then
args.cat1 = args.cat
end
self.catNums = getArgNums(args, 'cat')
if args.category then
args.category1 = args.category
end
self.categoryNums = getArgNums(args, 'category')
if args.all then
args.all1 = args.all
end
self.allNums = getArgNums(args, 'all')
self.categoryParamNums = union(self.catNums, self.categoryNums)
self.categoryParamNums = union(self.categoryParamNums, self.allNums)
-- The following is roughly equivalent to the old {{Ambox/category}}.
local date = args.date
date = type(date) == 'string' and date
local preposition = 'from'
for _, num in ipairs(self.categoryParamNums) do
local mainCat = args['cat' .. tostring(num)]
or args['category' .. tostring(num)]
local allCat = args['all' .. tostring(num)]
mainCat = type(mainCat) == 'string' and mainCat
allCat = type(allCat) == 'string' and allCat
if mainCat and date and date ~= '' then
local catTitle = format('%s %s %s', mainCat, preposition, date)
self:addCat('main', catTitle)
catTitle = getTitleObject('Category:' .. catTitle)
if not catTitle or not catTitle.exists then
self:addCat(
'main',
'Articles with invalid date parameter in template'
)
end
elseif mainCat and (not date or date == '') then
self:addCat('main', mainCat)
end
if allCat then
self:addCat('main', allCat)
end
end
end

-- Add template-namespace categories.
if cfg.templateCategory then
if cfg.templateCategoryRequireName then
if self.isTemplatePage then
self:addCat('template', cfg.templateCategory)
end
elseif not self.title.isSubpage then
self:addCat('template', cfg.templateCategory)
end
end

-- Add template error category.
if cfg.templateErrorCategory then
local templateErrorCategory = cfg.templateErrorCategory
local templateCat, templateSort
if not self.name and not self.title.isSubpage then
templateCat = templateErrorCategory
elseif self.isTemplatePage then
local paramsToCheck = cfg.templateErrorParamsToCheck or {}
local count = 0
for i, param in ipairs(paramsToCheck) do
if not args[param] then
count = count + 1
end
end
if count > 0 then
templateCat = templateErrorCategory
templateSort = tostring(count)
end
if self.categoryNums and #self.categoryNums > 0 then
templateCat = templateErrorCategory
templateSort = 'C'
end
end
self:addCat('template', templateCat, templateSort)
end

-- Categories for all namespaces.
if self.invalidTypeError then
local allSort = (self.nsid == 0 and 'Main:' or '') .. self.title.prefixedText
self:addCat('all', 'Wikipedia message box parameter needs fixing', allSort)
end
if self.isSubstituted then
self:addCat('all', 'Pages with incorrectly substituted templates')
end

-- Convert category tables to strings and pass them through
-- [[Module:Category handler]].
self.categories = categoryHandler{
main = tconcat(self.mainCats or {}),
template = tconcat(self.templateCats or {}),
all = tconcat(self.allCats or {}),
nocat = args.nocat,
demospace = self.demospace,
page = self.pageTitle and self.pageTitle.prefixedText or nil
}
end

function box:export()
local root = htmlBuilder.create()

-- Add the subst check error.
if self.isSubstituted and self.name then
root
.tag('b')
.addClass('error')
.wikitext(format(
'Template <code>%s[[Template:%s|%s]]%s</code> has been incorrectly substituted.',
mw.text.nowiki('{{'), self.name, self.name, mw.text.nowiki('}}')
))
end

-- Create the box table.
local boxTable = root.tag('table')
boxTable
.attr('id', self.id)
for i, class in ipairs(self.classes or {}) do
boxTable
.addClass(class)
end
boxTable
.cssText(self.style)
.attr('role', 'presentation')
for attr, val in pairs(self.attrs or {}) do
boxTable
.attr(attr, val)
end

-- Add the left-hand image.
local row = boxTable.tag('tr')
if self.imageLeft then
local imageLeftCell = row.tag('td').addClass('mbox-image')
if self.imageCellDiv then
-- If we are using a div, redefine imageLeftCell so that the image
-- is inside it. Divs use style="width: 52px;", which limits the
-- image width to 52px. If any images in a div are wider than that,
-- they may overlap with the text or cause other display problems.
imageLeftCell = imageLeftCell.tag('div').css('width', '52px')
end
imageLeftCell
.wikitext(self.imageLeft)
elseif self.imageEmptyCell then
-- Some message boxes define an empty cell if no image is specified, and
-- some don't. The old template code in templates where empty cells are
-- specified gives the following hint: "No image. Cell with some width
-- or padding necessary for text cell to have 100% width."
row.tag('td')
.addClass('mbox-empty-cell')
.cssText(self.imageEmptyCellStyle)
end

-- Add the text.
local textCell = row.tag('td').addClass('mbox-text')
if self.useCollapsibleTextFields then
-- The message box uses advanced text parameters that allow things to be
-- collapsible. At the moment, only ambox uses this.
textCell
.cssText(self.textstyle)
local textCellSpan = textCell.tag('span')
textCellSpan
.addClass('mbox-text-span')
.wikitext(self.issue)
if not self.isSmall then
textCellSpan
.tag('span')
.addClass('hide-when-compact')
.wikitext(self.talk and ' ' .. self.talk)
.wikitext(self.fix and ' ' .. self.fix)
end
textCellSpan
.wikitext(self.date and ' ' .. self.date)
if not self.isSmall then
textCellSpan
.tag('span')
.addClass('hide-when-compact')
.wikitext(self.info and ' ' .. self.info)
end
else
-- Default text formatting - anything goes.
textCell
.cssText(self.textstyle)
.wikitext(self.text)
end

-- Add the right-hand image.
if self.imageRight then
local imageRightCell = row.tag('td').addClass('mbox-imageright')
if self.imageCellDiv then
-- If we are using a div, redefine imageRightCell so that the image
-- is inside it.
imageRightCell = imageRightCell.tag('div').css('width', '52px')
end
imageRightCell
.wikitext(self.imageRight)
end

-- Add the below row.
if self.below then
boxTable.tag('tr')
.tag('td')
.attr('colspan', self.imageRight and '3' or '2')
.addClass('mbox-text')
.cssText(self.textstyle)
.wikitext(self.below)
end

-- Add error message for invalid type parameters.
if self.invalidTypeError then
root
.tag('div')
.css('text-align', 'center')
.wikitext(format(
'This message box is using an invalid "type=%s" parameter and needs fixing.',
self.type or ''
))
end

-- Add categories.
root
.wikitext(self.categories)

return tostring(root)
end

local function main(boxType, args)
local outputBox = box.new()
outputBox:setTitle(args)
local cfg = outputBox:getConfig(boxType)
args = outputBox:removeBlankArgs(cfg, args)
outputBox:setBoxParameters(cfg, args)
return outputBox:export()
end

local function makeWrapper(boxType)
return function (frame)
local args = getArgs(frame, {trim = false, removeBlanks = false})
return main(boxType, args)
end
end

local p = {
main = main,
mbox = makeWrapper('mbox')
}

for boxType in pairs(cfgTables) do
p[boxType] = makeWrapper(boxType)
end

return p

Module:Message box/configuration

Marie — Mon, 20 Jul 2026 23:19:14 GMT

Marie imported Module:Message box/configuration by file upload (1 revision)

New page

local ambox = {
types = {
speedy = {
class = 'ambox-speedy',
image = 'Ambox speedy deletion.png'
},
delete = {
class = 'ambox-delete',
image = 'Ambox deletion.png'
},
content = {
class = 'ambox-content',
image = 'Ambox content.png'
},
style = {
class = 'ambox-style',
image = 'Edit-clear.svg'
},
move = {
class = 'ambox-move',
image = 'Ambox move.png'
},
protection = {
class = 'ambox-protection',
image = 'Ambox protection.png'
},
notice = {
class = 'ambox-notice',
image = 'Ambox notice.png'
}
},
default = 'notice',
allowBlankParams = {'talk', 'sect', 'date', 'issue', 'fix', 'subst', 'hidden'},
allowSmall = true,
smallParam = 'left',
smallClass = 'mbox-small-left',
substCheck = true,
classes = {'metadata', 'plainlinks', 'ambox'},
imageEmptyCell = true,
imageCheckBlank = true,
imageSmallSize = '20x20px',
imageCellDiv = true,
useCollapsibleTextFields = true,
imageRightNone = true,
sectionDefault = 'article',
allowMainspaceCategories = true,
templateCategory = 'Article message templates',
templateCategoryRequireName = true,
templateErrorCategory = 'Article message templates with missing parameters',
templateErrorParamsToCheck = {'issue', 'fix', 'subst'}
}

local cmbox = {
types = {
speedy = {
class = 'cmbox-speedy',
image = 'Cmbox deletion.png'
},
delete = {
class = 'cmbox-delete',
image = 'Cmbox deletion.png'
},
content = {
class = 'cmbox-content',
image = 'Cmbox content.png'
},
style = {
class = 'cmbox-style',
image = 'Edit-clear.svg'
},
move = {
class = 'cmbox-move',
image = 'Cmbox move.png'
},
protection = {
class = 'cmbox-protection',
image = 'Cmbox protection.png'
},
notice = {
class = 'cmbox-notice',
image = 'Cmbox notice.png'
}
},
default = 'notice',
showInvalidTypeError = true,
classes = {'plainlinks', 'cmbox'},
imageEmptyCell = true
}

local fmbox = {
types = {
warning = {
class = 'fmbox-warning',
image = 'Cmbox deletion.png'
},
editnotice = {
class = 'fmbox-editnotice',
image = 'Imbox notice.svg'
},
system = {
class = 'fmbox-system',
image = 'Imbox notice.svg'
}
},
default = 'system',
showInvalidTypeError = true,
allowId = true,
classes = {'plainlinks', 'fmbox'},
imageEmptyCell = false,
imageRightNone = false
}

local imbox = {
types = {
speedy = {
class = 'imbox-speedy',
image = 'Imbox speedy deletion.png'
},
delete = {
class = 'imbox-delete',
image = 'Imbox deletion.png'
},
content = {
class = 'imbox-content',
image = 'Imbox content.svg'
},
style = {
class = 'imbox-style',
image = 'Edit-clear.svg'
},
move = {
class = 'imbox-move',
image = 'Imbox move.png'
},
protection = {
class = 'imbox-protection',
image = 'Imbox protection.png'
},
license = {
class = 'imbox-license',
image = 'Imbox license.png'
},
featured = {
class = 'imbox-featured',
image = 'Imbox featured.png'
},
notice = {
class = 'imbox-notice',
image = 'Imbox notice.svg'
}
},
default = 'notice',
showInvalidTypeError = true,
classes = {'imbox'},
usePlainlinksParam = true,
imageEmptyCell = true,
below = true,
templateCategory = 'File message boxes'
}

local ombox = {
types = {
speedy = {
class = 'ombox-speedy',
image = 'Imbox speedy deletion.png'
},
delete = {
class = 'ombox-delete',
image = 'Imbox deletion.png'
},
content = {
class = 'ombox-content',
image = 'Imbox content.svg'
},
style = {
class = 'ombox-style',
image = 'Edit-clear.svg'
},
move = {
class = 'ombox-move',
image = 'Imbox move.png'
},
protection = {
class = 'ombox-protection',
image = 'Imbox protection.png'
},
notice = {
class = 'ombox-notice',
image = 'Imbox notice.svg'
}
},
default = 'notice',
showInvalidTypeError = true,
classes = {'plainlinks', 'ombox'},
allowSmall = true,
imageEmptyCell = true,
imageRightNone = true
}

local tmbox = {
types = {
speedy = {
class = 'tmbox-speedy',
image = 'Imbox speedy deletion.png'
},
delete = {
class = 'tmbox-delete',
image = 'Imbox deletion.png'
},
content = {
class = 'tmbox-content',
image = 'Imbox content.svg'
},
style = {
class = 'tmbox-style',
image = 'Edit-clear.svg '
},
move = {
class = 'tmbox-move',
image = 'Imbox move.png'
},
protection = {
class = 'tmbox-protection',
image = 'Imbox protection.png'
},
notice = {
class = 'tmbox-notice',
image = 'Imbox notice.svg'
}
},
default = 'notice',
showInvalidTypeError = true,
classes = {'plainlinks', 'tmbox'},
allowId = true,
allowSmall = true,
imageRightNone = true,
imageEmptyCell = true,
imageEmptyCellStyle = true,
templateCategory = 'Talk message boxes'
}

return {
ambox = ambox,
cmbox = cmbox,
fmbox = fmbox,
imbox = imbox,
ombox = ombox,
tmbox = tmbox
}

Module:Namespace detect

Marie — Mon, 20 Jul 2026 23:19:14 GMT

Marie imported Module:Namespace detect by file upload (1 revision)

New page

--[[
--------------------------------------------------------------------------------
-- --
-- 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.loadData('Module:Namespace detect/data')
local argKeys = data.argKeys
local cfg = data.cfg
local mappings = data.mappings

local yesno = require('Module: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: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: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

Module:Namespace detect/config

Marie — Mon, 20 Jul 2026 23:19:14 GMT

Marie imported Module:Namespace detect/config by file upload (1 revision)

New page

--------------------------------------------------------------------------------
-- 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.

Module:Namespace detect/data

Marie — Mon, 20 Jul 2026 23:19:14 GMT

Marie imported Module:Namespace detect/data by file upload (1 revision)

New page

--------------------------------------------------------------------------------
-- 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 = require('Module: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()
}

Module:Yesno

Marie — Mon, 20 Jul 2026 23:19:14 GMT

Marie imported Module:Yesno by file upload (1 revision)

New page

-- Function allowing for consistent treatment of boolean-like wikitext input.
-- It works similarly to the template {{yesno}}.

return function (val, default)
-- If your wiki uses non-ascii characters for any of "yes", "no", etc., you
-- should replace "val:lower()" with "mw.ustring.lower(val)" in the
-- following line.
val = type(val) == 'string' and val:lower() or val
if val == nil then
return nil
elseif val == true
or val == 'yes'
or val == 'y'
or val == 'true'
or tonumber(val) == 1
then
return true
elseif val == false
or val == 'no'
or val == 'n'
or val == 'false'
or tonumber(val) == 0
then
return false
else
return default
end
end

Template:Documentation

Marie — Mon, 20 Jul 2026 23:19:14 GMT

Marie imported Template:Documentation by file upload (1 revision)

New page

{{#invoke:documentation|main|_content={{ {{#invoke:documentation|contentTitle}}}}}}<noinclude>

</noinclude>

Template:Icon/doc

Marie — Mon, 20 Jul 2026 23:19:14 GMT

Marie imported Template:Icon/doc by file upload (1 revision)

New page

== Usage ==
<pre><nowiki>
{{Icon|BlazBlue Central Fiction Ragna the Bloodedge Icon.png
|img=(named alt of {{{1|}}}) for Cargo queries
|imglink=Ragna the Bloodedge
|header=goes above the icon
|caption=[[Ragna the Bloodedge]]
|width=default is 96px
|class=CSS classes to style the div wrapper
|style=CSS style to style the div wrapper
}}
</nowiki></pre>
{{Icon|BlazBlue Central Fiction Ragna the Bloodedge Icon.png|imglink=Ragna the Bloodedge|caption=[[Ragna the Bloodedge]]}}
{{Icon|BlazBlue Central Fiction Naoto Kurogane Chibi.png|imglink=Naoto Kurogane|caption=[[Naoto Kurogane|Dec 1]]}}
{{Icon|BlazBlue Central Fiction Platinum the Trinity Chibi.png|imglink=Platinum the Trinity|caption=[[Platinum the Trinity|Dec 13]]}}
{{Icon|BlazBlue Central Fiction Noel Vermillion Chibi(A).png|imglink=Noel Vermillion|caption=[[Noel Vermillion|Dec 25]]}}
{{Icon|BlazBlue Central Fiction Nu-13 Chibi.png|imglink=Nu-13|caption=[[Nu-13|Dec 31]]}}
{{Icon|BlazBlue Central Fiction Nu-13 Icon.png|imglink=Nu-13|caption=[[Nu-13|Dec 31]]|header=<big><b>1</b></big>}}
{{Icon|BlazBlue Central Fiction Nu-13 Icon.png|imglink=Nu-13|caption=This is a caption.|header=This is a header.}}
For use with [[Template:Icon Grid]].
<includeonly>[[Category:Templates]]</includeonly>

Template:Icon

Marie — Mon, 20 Jul 2026 23:19:13 GMT

Marie imported Template:Icon by file upload (1 revision)

New page

<includeonly><div class="bb-wiki-nav-button" style="width:{{#if:{{{widths|}}}|{{{widths|}}}|{{{width|96px}}}}}; {{{style|}}}"><center>{{{header|}}}</center>{{#if:{{{1|{{{img|}}}}}}|[[File:{{{1|{{{img|}}}}}}|link={{{imglink|File:{{{1}}}}}}|center|{{{width|96px}}}]]}}<center><small>{{{caption|}}}</small></center></div></includeonly><noinclude>
{{Documentation}}
</noinclude>

Module:Arguments

Marie — Mon, 20 Jul 2026 23:19:13 GMT

Marie imported Module:Arguments by file upload (1 revision)

New page

-- This module provides easy processing of arguments passed to Scribunto from
-- #invoke. It is intended for use by other Lua modules, and should not be
-- called from #invoke directly.

local libraryUtil = require('libraryUtil')
local checkType = libraryUtil.checkType

local arguments = {}

-- Generate four different tidyVal functions, so that we don't have to check the
-- options every time we call it.

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

local function tidyValTrimOnly(key, val)
if type(val) == 'string' then
return val:match('^%s*(.-)%s*$')
else
return val
end
end

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

local function tidyValNoChange(key, val)
return val
end

function arguments.getArgs(frame, options)
checkType('getArgs', 1, frame, 'table', true)
checkType('getArgs', 2, options, 'table', true)
frame = frame or {}
options = options or {}

--[[
-- 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
if type(frame.args) == 'table' and type(frame.getParent) == 'function' then
if options.wrappers 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.
-- Module:Arguments will look up arguments in the parent frame
-- if it finds the parent frame's title in options.wrapper;
-- otherwise it will look up arguments in the frame object passed
-- to getArgs.
--]]
local parent = frame:getParent()
if not parent then
fargs = frame.args
else
local title = parent:getTitle():gsub('/sandbox$', '')
local found = false
if type(options.wrappers) == 'table' then
for _,v in pairs(options.wrappers) do
if v == title then
found = true
break
end
end
elseif options.wrappers == title then
found = true
end
if found then
pargs = parent.args
else
fargs = frame.args
end
end
else
-- options.wrapper isn't set, so check the other options.
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
if options.parentFirst then
fargs, pargs = pargs, fargs
end
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(
"bad value assigned to option 'valueFunc'"
.. '(function expected, got '
.. 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)

local function mergeArgs(iterator, tables)
--[[
-- Accepts multiple tables as input and merges their keys and values
-- into one table using the specified iterator. If a value is already
-- present it is not overwritten; tables listed earlier have precedence.
-- We are also memoizing nil values, but those values can be
-- overwritten.
--]]
for _, t in ipairs(tables) do
for key, val in iterator(t) do
if metaArgs[key] == nil then
local tidiedVal = tidyVal(key, val)
if tidiedVal == nil then
nilArgs[key] = true
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.
--]]

metatable.__index = function (t, key)
--[[
-- 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.
--]]
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
nilArgs[key] = true
else
metaArgs[key] = argTableVal
return argTableVal
end
end
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 options.readOnly then
error(
'could not write to argument table key "'
.. tostring(key)
.. '"; the table is read-only',
2
)
elseif options.noOverwrite and args[key] ~= nil then
error(
'could not write to argument table key "'
.. tostring(key)
.. '"; overwriting existing arguments is not permitted',
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] = true
else
metaArgs[key] = val
end
end

metatable.__pairs = function ()
-- Called when pairs is run on the args table.
if not metatable.donePairs then
mergeArgs(pairs, argTables)
metatable.donePairs = true
metatable.doneIpairs = true
end
return pairs(metaArgs)
end

metatable.__ipairs = function ()
-- Called when ipairs is run on the args table.
if not metatable.doneIpairs then
mergeArgs(ipairs, argTables)
metatable.doneIpairs = true
end
return ipairs(metaArgs)
end

return args
end

return arguments

Module:Category handler

Marie — Mon, 20 Jul 2026 23:19:13 GMT

Marie imported Module:Category handler by file upload (1 revision)

New page

----------------------------------------------------------------------------------------------------------
-- --
-- CATEGORY HANDLER --
-- --
-- This module implements the {{category handler}} 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. This module requires [[Module:Namespace detect]] and --
-- [[Module:Yesno]] to be available on the local wiki. It can be configured for different wikis --
-- by altering the values in the "cfg" table. --
-- --
----------------------------------------------------------------------------------------------------------

----------------------------------------------------------------------------------------------------------
-- Configuration data --
-- Language-specific parameter names and values can be set here. --
----------------------------------------------------------------------------------------------------------

local cfg = {}

-- The following config values set the names of parameters that suppress categorisation. They are used
-- with Module:Yesno, and work as follows:
--
-- cfg.nocat:
-- Result of yesno(args[cfg.nocat]) Effect
-- true Categorisation is suppressed
-- false Categorisation is allowed, and the blacklist check is skipped
-- nil Categorisation is allowed
--
-- cfg.categories:
-- Result of yesno(args[cfg.categories]) Effect
-- true Categorisation is allowed, and the blacklist check is skipped
-- false Categorisation is suppressed
-- nil Categorisation is allowed
cfg.nocat = 'nocat'
cfg.categories = 'categories'

-- The parameter name for the legacy "category2" parameter. This skips the blacklist if set to the
-- cfg.category2Yes value, and suppresses categorisation if present but equal to anything other than
-- cfg.category2Yes or cfg.category2Negative.
cfg.category2 = 'category2'
cfg.category2Yes = 'yes'
cfg.category2Negative = '¬'

-- cfg.subpage is the parameter name to specify how to behave on subpages. cfg.subpageNo is the value to
-- specify to not categorise on subpages; cfg.only is the value to specify to only categorise on subpages.
cfg.subpage = 'subpage'
cfg.subpageNo = 'no'
cfg.subpageOnly = 'only'

-- The parameter for data to return in all namespaces.
cfg.all = 'all'

-- The parameter name for data to return if no data is specified for the namespace that is detected. This
-- must be the same as the cfg.other parameter in [[Module:Namespace detect]].
cfg.other = 'other'

-- The parameter name used to specify a page other than the current page; used for testing and
-- demonstration. This must be the same as the cfg.page parameter in [[Module:Namespace detect]].
cfg.page = 'page'

-- The categorisation blacklist. Pages that match Lua patterns in this list will not be categorised.
-- (However, see the explanation of cfg.nocat, cfg.categories and cfg.category2 for some exceptions.)
-- If the namespace name has a space in, it must be written with an underscore, e.g. "Wikipedia_talk".
-- Other parts of the title can have either underscores or spaces.
cfg.blacklist = {
'^Main Page$', -- don't categorise the main page.

-- Don't categorise the following pages or their subpages.
'^Wikipedia:Cascade%-protected items$',
'^Wikipedia:Cascade%-protected items/.*$',
'^User:UBX$', -- The userbox "template" space.
'^User:UBX/.*$',
'^User_talk:UBX$',
'^User_talk:UBX/.*$',

-- Don't categorise subpages of these pages, but allow
-- categorisation of the base page.
'^Wikipedia:Template messages/.+$',

'/[aA]rchive' -- Don't categorise archives.
}

-- This is a table of namespaces to categorise by default. They should be in the format of parameter
-- names accepted by [[Module:Namespace detect]].
cfg.defaultNamespaces = {
'main',
'file',
'help',
'category'
}

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

-- Get dependent modules
local nsDetect = require('Module:Namespace detect')
local yesno = require('Module:Yesno')

----------------------------------------------------------------------------------------------------------
-- Local functions --
-- The following are internal functions, which we do not want to be accessible from other modules. --
----------------------------------------------------------------------------------------------------------

-- Find whether we need to return a category or not.
local function needsCategory(pageObject, args)
-- Don't categorise if the relevant options are set.
if yesno(args[cfg.nocat])
or yesno(args[cfg.categories]) == false
or (
args[cfg.category2]
and args[cfg.category2] ~= cfg.category2Yes
and args[cfg.category2] ~= cfg.category2Negative
)
then
return false
end
-- If there is no pageObject available, then that either means that we are over
-- the expensive function limit or that the title specified was invalid. Invalid
-- titles will probably only be a problem during testing, so we choose the best
-- fallback for being over the expensive function limit. The fallback behaviour
-- of the old template was to assume the page was not a subpage, so we will do
-- the same here.
if args[cfg.subpage] == cfg.subpageNo and pageObject and pageObject.isSubpage then
return false
end
if args[cfg.subpage] == cfg.subpageOnly
and (not pageObject or (pageObject and not pageObject.isSubpage))
then
return false
end
return true
end

-- Find whether we need to check the blacklist or not.
local function needsBlacklistCheck(args)
if yesno(args[cfg.nocat]) == false
or yesno(args[cfg.categories]) == true
or args[cfg.category2] == cfg.category2Yes
then
return false
else
return true
end
end

-- Find whether any namespace parameters have been specified.
-- Mappings is the table of parameter mappings taken from
-- [[Module:Namespace detect]].
local function nsParamsExist(mappings, args)
if args[cfg.all] or args[cfg.other] then
return true
end
for ns, params in pairs(mappings) do
for i, param in ipairs(params) do
if args[param] then
return true
end
end
end
return false
end

----------------------------------------------------------------------------------------------------------
-- Global functions --
-- The following functions are global, because we want them to be accessible from #invoke and --
-- from other Lua modules. --
----------------------------------------------------------------------------------------------------------

local p = {}

-- Find if a string matches the blacklist. Returns the match if one is found, or nil otherwise.
-- Input should be a page title with a namespace prefix, e.g. "Wikipedia talk:Articles for deletion".
function p.matchesBlacklist(page)
if type(page) ~= 'string' then return end
for i, pattern in ipairs(cfg.blacklist) do
local match = mw.ustring.match(page, pattern)
if match then
return match
end
end
end

-- The main structure of the module. Checks whether we need to categorise,
-- and then passes the relevant arguments to [[Module:Namespace detect]].
function p._main(args)
-- Get the page object and argument mappings from
-- [[Module:Namespace detect]], to save us from having to rewrite the
-- code.
local pageObject = nsDetect.getPageObject(args[cfg.page])
local mappings = nsDetect.getParamMappings()

if not needsCategory(pageObject, args) then return end

local ret = ''
-- Check blacklist if necessary.
if not needsBlacklistCheck(args) or not p.matchesBlacklist(pageObject.prefixedText) then
if not nsParamsExist(mappings, args) then
-- No namespace parameters exist; basic usage. Pass args[1] to
-- [[Module:Namespace detect]] using the default namespace
-- parameters, and return the result.
local ndargs = {}
for _, ndarg in ipairs(cfg.defaultNamespaces) do
ndargs[ndarg] = args[1]
end
ndargs.page = args.page
ndargs.demospace = args.demospace
local ndresult = nsDetect._main(ndargs)
if ndresult then
ret = ret .. ndresult
end
else
-- Namespace parameters exist; advanced usage.
-- If the all parameter is specified, return it.
local all = args.all
if type(all) == 'string' then
ret = ret .. all
end

-- Get the arguments to pass to [[Module:Namespace detect]].
local ndargs = {}
for ns, params in pairs(mappings) do
for _, param in ipairs(params) do
ndargs[param] = args[param] or args[cfg.other] or nil
end
end
ndargs.other = args.other
ndargs.page = args.page
ndargs.demospace = args.demospace

local data = nsDetect._main(ndargs)

-- Work out what to return based on the result of the namespace detect call.
local datanum = tonumber(data)
if type(datanum) == 'number' then
-- "data" is a number, so return that positional parameter.
-- Remove non-positive integer values, as only positive integers
-- from 1-10 were used with the old template.
if datanum > 0 and math.floor(datanum) == datanum then
local dataArg = args[datanum]
if type(dataArg) == 'string' then
ret = ret .. dataArg
end
end
else
-- "data" is not a number, so return it as it is.
if type(data) == 'string' then
ret = ret .. data
end
end
end
end
return ret
end

function p.main(frame)
-- If called via #invoke, use the args passed into the invoking
-- template, or the args passed to #invoke if any exist. Otherwise
-- assume args are being passed directly in.
local origArgs
if frame == mw.getCurrentFrame() then
origArgs = frame:getParent().args
for k, v in pairs(frame.args) do
origArgs = frame.args
break
end
else
origArgs = frame
end

-- Trim whitespace and remove blank arguments for the following args:
-- 1, 2, 3 etc., "nocat", "categories", "subpage", and "page".
local args = {}
for k, v in pairs(origArgs) do
if type(v) == 'string' then
v = mw.text.trim(v) -- Trim whitespace.
end
if type(k) == 'number'
or k == cfg.nocat
or k == cfg.categories
or k == cfg.subpage
or k == cfg.page
then
if v ~= '' then
args[k] = v
end
else
args[k] = v
end
end

-- Lower-case "nocat", "categories", "category2", and "subpage". These
-- parameters are put in lower case whenever they appear in the old
-- template, so we can just do it once here and save ourselves some work.
local lowercase = {cfg.nocat, cfg.categories, cfg.category2, cfg.subpage}
for _, v in ipairs(lowercase) do
local argVal = args[v]
if type(argVal) == 'string' then
args[v] = mw.ustring.lower(argVal)
end
end

return p._main(args)
end

return p

Main Page

Marie — Mon, 20 Jul 2026 23:16:47 GMT

← Older revision		Revision as of 23:16, 20 July 2026
Line 1:		Line 1:
			{{Front/banner}}
	'''Regio''' is a solo worldbuilding project set in a fictional near-apocalyptic world. During the [[War of All Colors]], the nations of the world developed a wonder-weapon which could singlehandedly end the war… and the world. With their deployment, swathes of the world became uninhabitable due to the influence of the [[Wave Bomb\|Wave Bombs]] and the associated [[Wave Decay]]. Society around the world has collapsed, save for a few pocket regions, where small communities, cities, sometimes even nations continue to lead a somewhat normal existence.		'''Regio''' is a solo worldbuilding project set in a fictional near-apocalyptic world. During the [[War of All Colors]], the nations of the world developed a wonder-weapon which could singlehandedly end the war… and the world. With their deployment, swathes of the world became uninhabitable due to the influence of the [[Wave Bomb\|Wave Bombs]] and the associated [[Wave Decay]]. Society around the world has collapsed, save for a few pocket regions, where small communities, cities, sometimes even nations continue to lead a somewhat normal existence.

Template:Front/banner

Marie — Mon, 20 Jul 2026 23:16:21 GMT

← Older revision		Revision as of 23:16, 20 July 2026
(3 intermediate revisions by the same user not shown)
Line 1:		Line 1:
	<div id="mp-topbanner" style="display:flex;flex-direction:row;width:100%;background:#~~f5faff~~;border:1px solid #ccc;justify-content:space-evenly;align-items:center;">		<div id="mp-topbanner" style="display:flex;flex-direction:row;width:100%;background:#FFFCF1;border:1px solid #ccc;justify-content:space-evenly;align-items:center;">
	<div style="display:flex;flex-direction:column;text-align:center;">		<div style="display:flex;flex-direction:column;text-align:center;">
	[[File:~~Niovewikithing~~.png\|~~300px~~]]		[[File:Regio wiki banner.png\|600px]]
	<div style="font-size:200%">A world looking for structure in ruin…</div>		<div style="font-size:200%">A world looking for structure in ruin…</div>
	<div style="font-size:120%;">Welcome the Regio wiki!</div>		<div style="font-size:120%;">Welcome the Regio wiki!</div>

File:Regio wiki banner.png

Marie — Mon, 20 Jul 2026 23:14:23 GMT

Marie uploaded File:Regio wiki banner.png

New page

Main Page

Marie — Mon, 20 Jul 2026 16:39:28 GMT

← Older revision		Revision as of 16:39, 20 July 2026
(One intermediate revision by the same user not shown)
Line 1:		Line 1:
	~~<strong>~~Regio~~</strong>~~		'''Regio''' is a solo worldbuilding project set in a fictional near-apocalyptic world. During the [[War of All Colors]], the nations of the world developed a wonder-weapon which could singlehandedly end the war… and the world. With their deployment, swathes of the world became uninhabitable due to the influence of the [[Wave Bomb\|Wave Bombs]] and the associated [[Wave Decay]]. Society around the world has collapsed, save for a few pocket regions, where small communities, cities, sometimes even nations continue to lead a somewhat normal existence.

Template:Front/banner

Marie — Mon, 20 Jul 2026 14:50:51 GMT

← Older revision		Revision as of 14:50, 20 July 2026
(One intermediate revision by the same user not shown)
Line 2:		Line 2:
	<div style="display:flex;flex-direction:column;text-align:center;">		<div style="display:flex;flex-direction:column;text-align:center;">
	[[File:Niovewikithing.png\|300px]]		[[File:Niovewikithing.png\|300px]]
	<div style="font-size:200%">~~Niove: The Spring Flame~~</div>		<div style="font-size:200%">A world looking for structure in ruin…</div>
	<div style="font-size:120%;">Welcome the ~~Niove~~ wiki!</div>		<div style="font-size:120%;">Welcome the Regio wiki!</div>
	<div id="articlecount" style="font-size:80%;">		<div id="articlecount" style="font-size:80%;">
	With [[Special:Statistics\|{{NUMBEROFARTICLES}}]] articles and [[Special:Statistics\|{{NUMBEROFEDITS}}]] edits since ~~March~~ of ~~2024~~.		With [[Special:Statistics\|{{NUMBEROFARTICLES}}]] articles and [[Special:Statistics\|{{NUMBEROFEDITS}}]] edits since July of 2026.
	</div>		</div>
	</div>		</div>
	</div>		</div>

Template:Front/banner

Marie — Mon, 20 Jul 2026 14:49:33 GMT

Marie imported Template:Front/banner by file upload (1 revision)

New page

<div id="mp-topbanner" style="display:flex;flex-direction:row;width:100%;background:#f5faff;border:1px solid #ccc;justify-content:space-evenly;align-items:center;">
<div style="display:flex;flex-direction:column;text-align:center;">
[[File:Niovewikithing.png|300px]]
<div style="font-size:200%">Niove: The Spring Flame</div>
<div style="font-size:120%;">Welcome the Niove wiki!</div>
<div id="articlecount" style="font-size:80%;">
With [[Special:Statistics|{{NUMBEROFARTICLES}}]] articles and [[Special:Statistics|{{NUMBEROFEDITS}}]] edits since March of 2024.
</div>
</div>
</div>

User:Marie

Autumn — Mon, 20 Jul 2026 14:38:20 GMT

Autumn changed group membership for Marie from (none) to administrator and interface administrator

Main Page

Marie — Sun, 19 Jul 2026 23:03:38 GMT

Replaced content with "<strong>Regio</strong>"

← Older revision		Revision as of 23:03, 19 July 2026
Line 1:		Line 1:
	<strong>~~MediaWiki has been installed.~~</strong>		<strong>Regio</strong>

	~~Consult the [https://www.mediawiki.org/wiki/Special:MyLanguage/Help:Contents User's Guide] for information on using the wiki software.~~

	~~== Getting started ==~~
	* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Configuration_settings Configuration settings list]
	* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:FAQ MediaWiki FAQ]
	* [https://lists.wikimedia.org/postorius/lists/mediawiki-announce.lists.wikimedia.org/ MediaWiki release mailing list]
	* [https://www.mediawiki.org/wiki/Special:MyLanguage/Localisation#Translation_resources Localise MediaWiki for your language]
	* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Combating_spam Learn how to combat spam on your wiki]

User:Marie

Autumn — Sun, 19 Jul 2026 19:32:14 GMT

User account Marie was created by Autumn