FeministWiki - Recent changes [en]

Module:ScribuntoTest

Technician — Sat, 26 Sep 2026 09:10:04 GMT

Created page with "-- Testing Scribunto"

New page

-- Testing Scribunto

MediaWiki:Sidebar

Technician — Sat, 26 Sep 2026 09:00:55 GMT

← Older revision		Revision as of 11:00, 26 September 2026
Line 22:		Line 22:
	* Special		* Special
	** recentchanges-url \| recentchanges		** recentchanges-url \| recentchanges
			** Special:NewFiles \| Newly added files
			** Special:SpecialPages \| specialpages
	** randompage-url \| randompage		** randompage-url \| randompage
	** Special:Version \| version		** Special:Version \| version
	* SEARCH		* SEARCH
	* TOOLBOX		* TOOLBOX

Template:SHORTDESC:

Minervaproject — Fri, 25 Sep 2026 08:39:14 GMT

Blanked the page

← Older revision		Revision as of 10:39, 25 September 2026
Line 1:		Line 1:
	~~#REDIRECT [[Help talk:SHORTDESC]]~~

Template:SHORTDESC:

Minervaproject — Fri, 25 Sep 2026 08:38:59 GMT

Minervaproject moved page Template:SHORTDESC: to Help talk:SHORTDESC

New page

#REDIRECT [[Template:Short description]]
{{Rcatsh|
{{R from incorrect name}}
}}

Module:Lua call

Minervaproject — Fri, 25 Sep 2026 08:36:56 GMT

Created page with "requirestrict local p={} function p.main(frame) local parent = frame.getParent(frame) or {} local explist = {} local fnname, varlist local vars = {} for k, v in pairs(_G) do vars[k] = v -- transfer every global directly to our variable table end for k, v in pairs(parent.args or {}) do vars[k] = tonumber(v) or v -- transfer every parameter directly to our variable table end for k, v in pairs(frame.args or {}) do..."

New page

require[[strict]]
local p={}

function p.main(frame)
local parent = frame.getParent(frame) or {}
local explist = {}
local fnname, varlist
local vars = {}
for k, v in pairs(_G) do
vars[k] = v -- transfer every global directly to our variable table
end
for k, v in pairs(parent.args or {}) do
vars[k] = tonumber(v) or v -- transfer every parameter directly to our variable table
end
for k, v in pairs(frame.args or {}) do
vars[k] = tonumber(v) or v -- transfer every parameter directly to our variable table
end
--- Alas Scribunto does NOT implement coroutines, according to
--- https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual#string.format
--- this will not stop us from trying to implement one single lousy function call
if vars[1] then
fnname, varlist = mw.ustring.match(vars[1], "^%s*(%a[^%s%(]*)%(([^%)]*)%)%s*$")
end
if varlist then
local expn = 0
repeat
expn = expn + 1
explist[expn] = vars[mw.ustring.match(varlist, "([^%,]+)")]
varlist = mw.ustring.match(varlist, "[^%,]+,(.*)$")
until not varlist
end
local scopetab = vars
while mw.ustring.match(fnname, "%.") do
local scopekey
scopekey, fnname = mw.ustring.match(fnname, "^(%a[^%.]*)%.(.*)$")
scopetab = scopetab[scopekey]
end
local fn = scopetab[fnname]
if type(fn) ~= "function" then --XXX: What about callable tables?
return tostring(fn)
else
local output = {fn(unpack(explist))}
return output[vars.reserved_return or 1]
end
end

local function tonumberOrString(v)
return tonumber(v) or v:gsub("^\\", "", 1)
end

local function callWithTonumberOrStringOnPairs(f, ...)
local args = {}
for _, v in ... do
table.insert(args, tonumberOrString(v))
end
return (f(unpack(args)))
end

--[[
------------------------------------------------------------------------------------
-- ipairsAtOffset

-- This is an iterator for arrays. It can be used like ipairs, but with
-- specified i as first index to iterate. i is an offset from 1
--
------------------------------------------------------------------------------------
--]]
local function ipairsAtOffset(t, i)
local f, s, i0 = ipairs(t)
return f, s, i0+i
end

local function get(s)
local G = _G; for _ in mw.text.gsplit(
mw.text.trim(s, '%s'), '%s*%.%s*'
) do
G = G[_]
end
return G
end

--[[
------------------------------------------------------------------------------------
-- call
--
-- This function is usually useful for debugging template parameters.
-- Prefix parameter with backslash (\) to force interpreting parameter as string.
-- The leading backslash will be removed before passed to Lua function.
--
-- Example:
-- {{#invoke:Lua call|call|mw.log|a|1|2|3}} will return results of mw.log('a', 1, 2, 3)
-- {{#invoke:Lua call|call|mw.logObject|\a|321|\321| \321 }} will return results of mw.logObject('a', 321, '321', ' \\321 ')
--
-- This example show the debugging to see which Unicode characters are allowed in template parameters,
-- {{#invoke:Lua call|call|mw.ustring.codepoint|{{#invoke:Lua call|call|mw.ustring.char|0x0061}}}} return 97
-- {{#invoke:Lua call|call|mw.ustring.codepoint|{{#invoke:Lua call|call|mw.ustring.char|0x0000}}}} return 65533
-- {{#invoke:Lua call|call|mw.ustring.codepoint|{{#invoke:Lua call|call|mw.ustring.char|0x0001}}}} return 65533
-- {{#invoke:Lua call|call|string.format|0x%04x|{{#invoke:Lua call|call|mw.ustring.codepoint|{{#invoke:Lua call|call|mw.ustring.char|0x0002}}}}}} return 0xfffd
-- {{#invoke:Lua call|call|string.format|0x%04x|{{#invoke:Lua call|call|mw.ustring.codepoint|{{#invoke:Lua call|call|mw.ustring.char|0x007e}}}}}} return 0x007e
-- {{#invoke:Lua call|call|string.format|0x%04x|{{#invoke:Lua call|call|mw.ustring.codepoint|{{#invoke:Lua call|call|mw.ustring.char|0x007f}}}}}} return 0x007f
-- {{#invoke:Lua call|call|string.format|0x%04x|{{#invoke:Lua call|call|mw.ustring.codepoint|{{#invoke:Lua call|call|mw.ustring.char|0x0080}}}}}} return 0x0080
-- {{#invoke:Lua call|call|string.format|0x%04x|{{#invoke:Lua call|call|mw.ustring.codepoint|{{#invoke:Lua call|call|mw.ustring.char|0x00a0}}}}}} return 0x00a0
--
------------------------------------------------------------------------------------
--]]
function p.call(frame)
return callWithTonumberOrStringOnPairs(get(frame.args[1]),
ipairsAtOffset(frame.args, 1)
)
end

--local TableTools = require('Module:TableTools')
--[[
------------------------------------------------------------------------------------
-- get
--
-- Example:
-- {{#invoke:Lua call|get| math.pi }} will return value of math.pi
-- {{#invoke:Lua call|get|math|pi}} will return value of math.pi
-- {{#invoke:Lua call|get| math |pi}} will return value of _G[' math '].pi
-- {{#invoke:Lua call|get|_G| math.pi }} will return value of _G[' math.pi ']
-- {{#invoke:Lua call|get|obj.a.5.c}} will return value of obj.a['5'].c
-- {{#invoke:Lua call|get|obj|a|5|c}} will return value of obj.a[5].c
--
------------------------------------------------------------------------------------
--]]
function p.get(frame)
-- #frame.args always return 0, regardless of number of unnamed
-- template parameters, so check manually instead
if frame.args[2] == nil then
-- not do tonumber() for this args style,
-- always treat it as string,
-- so 'obj.1' will mean obj['1'] rather obj[1]
return get(frame.args[1])
else
local G = _G
for _, v in ipairs(frame.args) do
G = G[tonumberOrString(v)]
end
return G
end
end

--[[
------------------------------------------------------------------------------------
-- invoke
--
-- This function is used by Template:Invoke
--
------------------------------------------------------------------------------------
--]]
function p.invoke(frame)
local pframe, usedpargs = frame:getParent(), {}
-- get module and function names from parent args if not provided
local pfargs = setmetatable({frame.args[1], frame.args[2]}, {__index = table})
if not pfargs[1] then
pfargs[1], usedpargs[1] = pframe.args[1], true
if not pfargs[2] then
pfargs[2], usedpargs[2] = pframe.args[2], true
end
elseif not pfargs[2] then
pfargs[2], usedpargs[1] = pframe.args[1], true
end
-- repack sequential args
for i, v in ipairs(pframe.args) do
if not usedpargs[i] then
pfargs:insert(v)
usedpargs[i] = true
end
end
-- copy other args
for k, v in pairs(pframe.args) do
if not pfargs[k] and not usedpargs[k] then
pfargs[k], usedpargs[k] = v, true
end
end
-- #invoke off parent frame so the new frame has the same parent
return pframe:callParserFunction{name = '#invoke', args = pfargs}
end

return p

Template:SHORTDESC

Minervaproject — Fri, 25 Sep 2026 08:33:37 GMT

Redirected page to Template:Short description

New page

#REDIRECT [[Template:Short description]]
{{Rcatsh|
{{R from incorrect name}}
}}

Template:SHORTDESC:

Minervaproject — Fri, 25 Sep 2026 08:32:39 GMT

Redirected page to Template:Short description

New page

#REDIRECT [[Template:Short description]]
{{Rcatsh|
{{R from incorrect name}}
}}

Template:Rcatsh

Minervaproject — Fri, 25 Sep 2026 08:30:48 GMT

Redirected page to Template:Redirect category shell

New page

#REDIRECT [[Template:Redirect category shell]]

{{Redirect category shell|
{{R to redirect template}}
{{R from template shortcut}}
}}

Template:Shortdesc

Minervaproject — Fri, 25 Sep 2026 08:30:29 GMT

Redirected page to Template:Short description

New page

#REDIRECT [[Template:Short description]]
{{Rcatsh|
{{R from incorrect name}}
}}

Module:Userbox

Minervaproject — Fri, 25 Sep 2026 08:28:59 GMT

Created page with "-- This module implements {{userbox}}. local categoryHandler = require('Module:Category handler').main local p = {} -------------------------------------------------------------------------------- -- Helper functions -------------------------------------------------------------------------------- local function checkNum(val, default) -- Checks whether a value is a number greater than or equal to zero. If so, -- returns it as a number. If not, returns a default valu..."

New page

-- This module implements {{userbox}}.

local categoryHandler = require('Module:Category handler').main

local p = {}

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

local function checkNum(val, default)
-- Checks whether a value is a number greater than or equal to zero. If so,
-- returns it as a number. If not, returns a default value.
val = tonumber(val)
if val and val >= 0 then
return val
else
return default
end
end

local function addSuffix(num, suffix)
-- Turns a number into a string and adds a suffix.
if num then
return tostring(num) .. suffix
else
return nil
end
end

local function checkNumAndAddSuffix(num, default, suffix)
-- Checks a value with checkNum and adds a suffix.
num = checkNum(num, default)
return addSuffix(num, suffix)
end

local function makeCat(cat, sort)
-- Makes a category link.
if sort then
return mw.ustring.format('[[Category:%s|%s]]', cat, sort)
else
return mw.ustring.format('[[Category:%s]]', cat)
end
end

--------------------------------------------------------------------------------
-- Argument processing
--------------------------------------------------------------------------------

local function makeInvokeFunc(funcName)
return function (frame)
local origArgs = require('Module:Arguments').getArgs(frame)
local args = {}
for k, v in pairs(origArgs) do
args[k] = v
end
return p.main(funcName, args)
end
end

p.userbox = makeInvokeFunc('_userbox')
p['userbox-2'] = makeInvokeFunc('_userbox-2')
p['userbox-r'] = makeInvokeFunc('_userbox-r')

--------------------------------------------------------------------------------
-- Main functions
--------------------------------------------------------------------------------

function p.main(funcName, args)
local userboxData = p[funcName](args)
local userbox = p.render(userboxData)
local cats = p.categories(args)
return userbox .. (cats or '')
end

function p._userbox(args)
-- Does argument processing for {{userbox}}.
local data = {}

-- Get div tag values.
data.float = args.float
local borderWidthNum = checkNum(args['border-width'] or args['border-s'], nil)
data.borderWidth = addSuffix(borderWidthNum, 'px')
data.borderColor = args['border-color'] or args['border-c'] or args[1] or args['id-c']
data.width = borderWidthNum and addSuffix(240 - 2 * borderWidthNum, 'px')
data.bodyClass = args.bodyclass

-- Get table tag values.
data.backgroundColor = args['info-background'] or args[2] or args['info-c']

-- Get info values.
data.info = args.info or args[4] or "<code>{{{info}}}</code>"
data.infoTextAlign = args['info-a']
data.infoFontSize = checkNumAndAddSuffix(args['info-size'] or args['info-s'], nil, 'pt')
data.infoHeight = checkNumAndAddSuffix(args['logo-height'] or args['id-h'], nil, 'px')
data.infoPadding = args['info-padding'] or args['info-p']
data.infoLineHeight = args['info-line-height'] or args['info-lh']
data.infoColor = args['info-color'] or args['info-fc']
data.infoOtherParams = args['info-other-param'] or args['info-op']
data.infoClass = args['info-class']

-- Get id values.
local id = args.logo or args[3] or args.id
data.id = id
data.showId = id and true or false
data.idWidth = checkNumAndAddSuffix(args['logo-width'] or args['id-w'], nil, 'px')
data.idHeight = checkNumAndAddSuffix(args['logo-height'] or args['id-h'], nil, 'px')
data.idBackgroundColor = args['logo-background'] or args[1] or args['id-c']
data.idTextAlign = args['id-a']
data.idFontSize = checkNum(args['logo-size'] or args[5] or args['id-s'], nil)
data.idColor = args['logo-color'] or args['id-fc'] or data.infoColor
data.idPadding = args['logo-padding'] or args['id-p']
data.idLineHeight = args['logo-line-height'] or args['id-lh']
data.idOtherParams = args['logo-other-param'] or args['id-op']
data.idClass = args['id-class']

return data
end

p['_userbox-2'] = function (args)
-- Does argument processing for {{userbox-2}}.
local data = {}

-- Get div tag values.
data.float = args.float
local borderWidthNum = checkNum(args['border-s'] or args[9], nil)
data.borderWidth = addSuffix(borderWidthNum, 'px')
data.borderColor = args['border-c'] or args[6] or args['id1-c'] or args[1]
data.width = borderWidthNum and addSuffix(240 - 2 * borderWidthNum, 'px')
data.bodyClass = args.bodyclass

-- Get table tag values.
data.backgroundColor = args['info-c'] or args[2]

-- Get info values.
data.info = args.info or args[4] or "<code>{{{info}}}</code>"
data.infoTextAlign = args['info-a']
data.infoFontSize = checkNumAndAddSuffix(args['info-s'], nil, 'pt')
data.infoColor = args['info-fc'] or args[8]
data.infoPadding = args['info-p']
data.infoLineHeight = args['info-lh']
data.infoOtherParams = args['info-op']

-- Get id values.
data.showId = true
data.id = args.logo or args[3] or args.id1 or 'id1'
data.idWidth = checkNumAndAddSuffix(args['id1-w'], nil, 'px')
data.idHeight = checkNumAndAddSuffix(args['id-h'], nil, 'px')
data.idBackgroundColor = args['id1-c'] or args[1]
data.idTextAlign = args['id-a']
data.idFontSize = checkNum(args['id1-s'], nil)
data.idLineHeight = args['id1-lh']
data.idColor = args['id1-fc'] or data.infoColor
data.idPadding = args['id1-p']
data.idOtherParams = args['id1-op']

-- Get id2 values.
data.showId2 = true
data.id2 = args.logo or args[5] or args.id2 or 'id2'
data.id2Width = checkNumAndAddSuffix(args['id2-w'], nil, 'px')
data.id2Height = data.idHeight
data.id2BackgroundColor = args['id2-c'] or args[7] or args[1]
data.id2TextAlign = nil -- Always center, but don't set if no content
data.id2FontSize = checkNum(args['id2-s'], nil)
data.id2LineHeight = args['id2-lh']
data.id2Color = args['id2-fc'] or data.infoColor
data.id2Padding = args['id2-p']
data.id2OtherParams = args['id2-op']

return data
end

p['_userbox-r'] = function (args)
-- Does argument processing for {{userbox-r}}.
local data = {}

-- Get div tag values.
data.float = args.float
local borderWidthNum = checkNum(args['border-width'] or args['border-s'], nil)
data.borderWidth = addSuffix(borderWidthNum, 'px')
data.borderColor = args['border-color'] or args['border-c'] or args[1] or args['id-c']
data.width = borderWidthNum and addSuffix(240 - 2 * borderWidthNum, 'px')
data.bodyClass = args.bodyclass

-- Get table tag values.
data.backgroundColor = args['info-background'] or args[2] or args['info-c']

-- Get id values.
data.showId = false -- We only show id2 in userbox-r.

-- Get info values.
data.info = args.info or args[4] or "<code>{{{info}}}</code>"
data.infoTextAlign = args['info-align'] or args['info-a']
data.infoFontSize = checkNumAndAddSuffix(args['info-size'] or args['info-s'], nil, 'pt')
data.infoPadding = args['info-padding'] or args['info-p']
data.infoLineHeight = args['info-line-height'] or args['info-lh']
data.infoColor = args['info-color'] or args['info-fc']
data.infoOtherParams = args['info-other-param'] or args['info-op']

-- Get id2 values.
data.showId2 = true -- userbox-r always shows the ID cell (as id2)
data.id2 = args.logo or args[3] or args.id or 'id'
data.id2Width = checkNumAndAddSuffix(args['logo-width'] or args['id-w'], nil, 'px')
data.id2Height = checkNumAndAddSuffix(args['logo-height'] or args['id-h'], nil, 'px')
data.id2BackgroundColor = args['logo-background'] or args[1] or args['id-c']
data.id2TextAlign = args['id-a']
data.id2FontSize = checkNum(args['logo-size'] or args[5] or args['id-s'], nil)
data.id2Color = args['logo-color'] or args['id-fc'] or data.infoColor
data.id2Padding = args['logo-padding'] or args['id-p']
data.id2LineHeight = args['logo-line-height'] or args['id-lh']
data.id2OtherParams = args['logo-other-param'] or args['id-op']

return data
end

function p.render(data)
-- Renders the userbox html using the content of the data table.
-- Add TemplateStyles
local templateStyles = mw.getCurrentFrame():extensionTag{
name = 'templatestyles', args = { src = 'Template:Userbox/styles.css' }
}

-- Render the div tag html.
local root = mw.html.create('div')
root:addClass('wikipediauserbox')

-- Only add CSS properties if they have values
if data.float then root:css('float', data.float) end
if data.borderWidth then
root:css('border-width', data.borderWidth)
end
if data.borderColor then
root:css('border-color', data.borderColor)
-- Set border style if we have a color but potentially no width set
if not data.borderWidth then
root:css('border-width', '1px') -- default border width
end
root:css('border-style', 'solid')
end
if data.width then root:css('width', data.width) end
if data.bodyClass then root:addClass(data.bodyClass) end

-- Render the table tag html.
local tableroot = root:tag('table')
tableroot:attr('role', 'presentation')

-- Only add CSS if values exist
if data.width then tableroot:css('width', data.width) end
if data.backgroundColor then tableroot:css('background', data.backgroundColor):css('color', 'inherit') end

local tablerow = tableroot:tag('tr')

-- Create cells based on what should actually be shown
if data.showId == false then
-- userbox-r: info cell first, then id2 cell (if showId2 is true)
local infoCell = tablerow:tag('td')
infoCell:addClass('userbox-info')
if data.infoTextAlign then infoCell:css('text-align', data.infoTextAlign) end
if data.infoFontSize then infoCell:css('font-size', data.infoFontSize) end
if data.infoPadding then infoCell:css('padding', data.infoPadding) end
if data.infoHeight then infoCell:css('height', data.infoHeight) end
if data.infoLineHeight then infoCell:css('line-height', data.infoLineHeight) end
if data.infoColor then infoCell:css('color', data.infoColor) end
if data.infoOtherParams then infoCell:cssText(data.infoOtherParams) end
if data.infoClass then infoCell:addClass(data.infoClass) end
if data.info then infoCell:wikitext(data.info) end

-- Create id2 cell only if showId2 is true
if data.showId2 then
local id2Cell = tablerow:tag('td')
id2Cell:addClass('userbox-id2')
if data.id2Width then id2Cell:css('width', data.id2Width) end
if data.id2Height then id2Cell:css('height', data.id2Height) end
if data.id2BackgroundColor then id2Cell:css('background', data.id2BackgroundColor) end
if data.id2TextAlign then id2Cell:css('text-align', data.id2TextAlign) end
if data.id2FontSize then id2Cell:css('font-size', data.id2FontSize .. 'pt') end
if data.id2Color then id2Cell:css('color', data.id2Color) else id2Cell:css('color', 'inherit') end
if data.id2Padding then id2Cell:css('padding', data.id2Padding) end
if data.id2LineHeight then id2Cell:css('line-height', data.id2LineHeight) end
if data.id2OtherParams then id2Cell:cssText(data.id2OtherParams) end
if data.id2 then id2Cell:wikitext(data.id2) end
end
else
-- userbox and userbox-2: create id cell only if showId is true
if data.showId then
local idCell = tablerow:tag('td')
idCell:addClass('userbox-id')
if data.idWidth then idCell:css('width', data.idWidth) end
if data.idHeight then idCell:css('height', data.idHeight) end
if data.idBackgroundColor then idCell:css('background', data.idBackgroundColor) end
if data.idTextAlign then idCell:css('text-align', data.idTextAlign) end
if data.idFontSize then idCell:css('font-size', data.idFontSize .. 'pt') end
if data.idColor then idCell:css('color', data.idColor) else idCell:css('color', 'inherit') end
if data.idPadding then idCell:css('padding', data.idPadding) end
if data.idLineHeight then idCell:css('line-height', data.idLineHeight) end
if data.idOtherParams then idCell:cssText(data.idOtherParams) end
if data.idClass then idCell:addClass(data.idClass) end
if data.id then idCell:wikitext(data.id) end
end

-- Always create info cell for userbox and userbox-2
local infoCell = tablerow:tag('td')
infoCell:addClass('userbox-info')
if data.infoTextAlign then infoCell:css('text-align', data.infoTextAlign) end
if data.infoFontSize then infoCell:css('font-size', data.infoFontSize) end
if data.infoPadding then infoCell:css('padding', data.infoPadding) end
if data.infoHeight then infoCell:css('height', data.infoHeight) end
if data.infoLineHeight then infoCell:css('line-height', data.infoLineHeight) end
if data.infoColor then infoCell:css('color', data.infoColor) end
if data.infoOtherParams then infoCell:cssText(data.infoOtherParams) end
if data.infoClass then infoCell:addClass(data.infoClass) end
if data.info then infoCell:wikitext(data.info) end

-- Create id2 cell only for userbox-2 and only if showId2 is true
if data.showId2 then
local id2Cell = tablerow:tag('td')
id2Cell:addClass('userbox-id2')
if data.id2Width then id2Cell:css('width', data.id2Width) end
if data.id2Height then id2Cell:css('height', data.id2Height) end
if data.id2BackgroundColor then id2Cell:css('background', data.id2BackgroundColor) end
if data.id2TextAlign then id2Cell:css('text-align', data.id2TextAlign) end
if data.id2FontSize then id2Cell:css('font-size', data.id2FontSize .. 'pt') end
if data.id2Color then id2Cell:css('color', data.id2Color) else id2Cell:css('color', 'inherit') end
if data.id2Padding then id2Cell:css('padding', data.id2Padding) end
if data.id2LineHeight then id2Cell:css('line-height', data.id2LineHeight) end
if data.id2OtherParams then id2Cell:cssText(data.id2OtherParams) end
if data.id2 then id2Cell:wikitext(data.id2) end
end
end

local title = mw.title.getCurrentTitle()
if (title.namespace == 2) and not title.text:match("/") then
return templateStyles .. tostring(root) -- regular user page
elseif title.namespace == 14 then
return templateStyles .. tostring(root) -- category
elseif title.isTalkPage then
return templateStyles .. tostring(root) -- talk page
end

-- Color contrast checking (simplified for TemplateStyles)
local legible = true
local contrast = require('Module:Color contrast')._ratio
local function has_text(wikitext)
if not wikitext then return false end
wikitext = wikitext:gsub("]]", "|]]")
wikitext = wikitext:gsub("%[%[%s*[Mm][Ee][Dd][Ii][Aa]%s*:[^|]-(|.-)]]", "")
wikitext = wikitext:gsub("%[%[%s*[Ii][Mm][Aa][Gg][Ee]%s*:[^|]-(|.-)]]", "")
wikitext = wikitext:gsub("%[%[%s*[Ff][Ii][Ll][Ee]%s*:[^|]-(|.-)]]", "")
return mw.text.trim(wikitext) ~= ""
end

if data.infoColor and data.backgroundColor and contrast { data.infoColor, data.backgroundColor, error = 0 } < 4.5 then
legible = false
end

-- For bold text >= 14pt, requirement is only 3.
local idContrastThreshold = 4.5
local id2ContrastThreshold = 4.5
if (data.idFontSize or 0) >= 14 then idContrastThreshold = 3 end
if (data.id2FontSize or 0) >= 14 then id2ContrastThreshold = 3 end

if data.showId and data.idColor and data.idBackgroundColor and contrast { data.idColor, data.idBackgroundColor, error = 0 } < idContrastThreshold then
if has_text(data.id or "") then legible = false end
end

if data.showId2 and data.id2Color and data.id2BackgroundColor and contrast { data.id2Color, data.id2BackgroundColor, error = 0 } < id2ContrastThreshold then
if has_text(data.id2 or "") then legible = false end
end

if not legible then
root:wikitext('[[Category:Userboxes with insufficient color contrast]]')
end

return templateStyles .. tostring(root)
end

function p.categories(args, page)
-- Gets categories from [[Module:Category handler]].
-- The page parameter makes the function act as though the module was being called from that page.
-- It is included for testing purposes.
local cats = {}
cats[#cats + 1] = args.usercategory
cats[#cats + 1] = args.usercategory2
cats[#cats + 1] = args.usercategory3
cats[#cats + 1] = args.usercategory4
cats[#cats + 1] = args.usercategory5

-- Get the title object
local title
if page then
title = mw.title.new(page)
else
title = mw.title.getCurrentTitle()
end

-- Build category handler arguments.
local chargs = {}
chargs.page = page
chargs.nocat = args.nocat
chargs.main = '[[Category:Pages with templates in the wrong namespace]]'
if args.notcatsubpages then
chargs.subpage = 'no'
end

-- User namespace.
local user = ''
for i, cat in ipairs(cats) do
user = user .. makeCat(cat)
end
chargs.user = user

return categoryHandler(chargs)
end

return p

Template:Userbox

Minervaproject — Fri, 25 Sep 2026 08:28:27 GMT

Created page with "{{#invoke:userbox|userbox}}{{template other|__EXPECTUNUSEDTEMPLATE__}}<noinclude> {{documentation}}  </noinclude>"

New page

{{#invoke:userbox|userbox}}{{template other|__EXPECTUNUSEDTEMPLATE__}}<noinclude>
{{documentation}}

</noinclude>

Template:User Short descriptions

Minervaproject — Fri, 25 Sep 2026 08:28:13 GMT

Created page with "{{userbox | border-c = #bcbcac | id = File:Farm-Fresh quill.png | id-c = #f8f9f8 | info = This user is a participant in'''WikiProject Short descriptions'''. | info-c = #f8f9f8 | info-s = 8 | info-op = text-align:center | usercategory = WikiProject Short descriptions participants | nocat = {{{nocat|}}} }}<noinclude> {{Documentation}} </noinclude>"

New page

{{userbox
| border-c = #bcbcac
| id = [[File:Farm-Fresh quill.png]]
| id-c = #f8f9f8
| info = This user is a participant in'''[[Wikipedia:WikiProject Short descriptions|WikiProject Short descriptions]]'''.
| info-c = #f8f9f8
| info-s = 8
| info-op = text-align:center
| usercategory = WikiProject Short descriptions participants
| nocat = {{{nocat|}}}
}}<noinclude>
{{Documentation}}
</noinclude>

Template:Shortdesc there

Minervaproject — Fri, 25 Sep 2026 08:27:41 GMT

Created page with "<noinclude></noinclude><includeonly>{{subst:#if:{{{1|}}} |{{subst:includeonly|{{Short description|{{{1}}}{{subst:#switch:{{subst:lc:{{{2|}}}}} |noreplace |nr={{subst:!}}noreplace | }}}}}}{{subst:#if:{{{note|a}}} |{{subst:#ifeq:{{subst:lc:{{{note}}}}}|none | |{{subst:html com..."

New page

<noinclude></noinclude><includeonly>{{subst:#if:{{{1|}}}
|{{subst:includeonly|{{Short description|{{{1}}}{{subst:#switch:{{subst:lc:{{{2|}}}}}
|noreplace
|nr={{subst:!}}noreplace
|
}}}}}}{{subst:#if:{{{note|a}}}
|{{subst:#ifeq:{{subst:lc:{{{note}}}}}|none
|
|{{subst:html comment|{{{note|For transclusion only}}}}}}}
|}}
|}}</includeonly><noinclude>
{{Documentation}}
</noinclude>

Template:Shortdesc here

Minervaproject — Fri, 25 Sep 2026 08:27:24 GMT

Created page with "<noinclude></noinclude><includeonly>{{subst:#if:{{{1|}}} |{{subst:noinclude|{{Short description|{{{1}}}{{subst:#switch:{{subst:lc:{{{2|}}}}} |noreplace |nr={{subst:!}}noreplace | }}}}}}{{subst:#if:{{{note|a}}} |{{subst:#ifeq:{{subst:lc:{{{note}}}}}|none | |{{subst:html comme..."

New page

<noinclude></noinclude><includeonly>{{subst:#if:{{{1|}}}
|{{subst:noinclude|{{Short description|{{{1}}}{{subst:#switch:{{subst:lc:{{{2|}}}}}
|noreplace
|nr={{subst:!}}noreplace
|
}}}}}}{{subst:#if:{{{note|a}}}
|{{subst:#ifeq:{{subst:lc:{{{note}}}}}|none
|
|{{subst:html comment|{{{note|For this page only}}}}}}}
|}}
|}}</includeonly><noinclude>
{{Documentation}}
</noinclude>

Module:Ustring

Minervaproject — Fri, 25 Sep 2026 08:25:02 GMT

Created page with "require('strict') return setmetatable({}, { __index = function(t, k) local what = mw.ustring[k] if type(what) ~= "function" then return what end return function(frame) local fargs = frame.args local fargsused = { tag = true } local args = {} local str_i = 1 while fargs['s' .. str_i] do fargsused['s' .. str_i] = true args[str_i] = fargs['s' .. str_i] str_i = str_i + 1 end for i, v in ipairs(fargs) do fargsused[i] = true..."

New page

require('strict')
return setmetatable({}, {
__index = function(t, k)
local what = mw.ustring[k]
if type(what) ~= "function" then
return what
end
return function(frame)
local fargs = frame.args
local fargsused = { tag = true }
local args = {}
local str_i = 1
while fargs['s' .. str_i] do
fargsused['s' .. str_i] = true
args[str_i] = fargs['s' .. str_i]
str_i = str_i + 1
end
for i, v in ipairs(fargs) do
fargsused[i] = true
args[i + str_i - 1] = tonumber(v) or v:gsub("^\\", "", 1)
end
if not fargs.tag then
return (what(unpack(args))) -- Outside parens truncate to first result avoiding tail call
end
local tagargs = {}
for x, y in pairs(fargs) do
if not fargsused[x] then tagargs[x] = y end
end
return frame:extensionTag{name = fargs.tag, content = what(unpack(args)), args = tagargs}
end
end
})

Template:Str sub old

Minervaproject — Fri, 25 Sep 2026 08:24:10 GMT

Created page with "<includeonly>{{{{{|safesubst:}}}#invoke:String|sublength|s={{{1}}}|i={{{2|0}}}|len={{{3|0}}}}}</includeonly><noinclude> {{documentation}} </noinclude>"

New page

<includeonly>{{{{{|safesubst:}}}#invoke:String|sublength|s={{{1}}}|i={{{2|0}}}|len={{{3|0}}}}}</includeonly><noinclude>
{{documentation}}
</noinclude>

Template:Wikidata entity link

Minervaproject — Fri, 25 Sep 2026 08:11:27 GMT

Created page with "<includeonly>{{#if:{{{1|}}} | {{#switch:{{padleft:|1|{{uc:{{{1}}}}}}} | Q | P = [[d:Special:EntityPage/{{uc:{{{1}}}}}|{{replace|{{#invoke:wd|label|{{uc:{{{1}}}}}}}|'|'}} ({{uc:{{{1}}}}})]] | #default = [[d:Special:EntityPage/Q{{uc:{{{1}}}}}|{{replace|{{#invoke:wd|label|Q{{uc:{{{1}}}}}}}|'|'}} (Q{{uc:{{{1|}}}}})]] }} | {{#if:{{#invoke:wd|label|raw}} | d:Special:EntityPage/{{#invoke:wd|label|raw}}|{{#invoke:wd|label}} <small..."

New page

<includeonly>{{#if:{{{1|}}}
| {{#switch:{{padleft:|1|{{uc:{{{1}}}}}}}
| Q | P = [[d:Special:EntityPage/{{uc:{{{1}}}}}|{{replace|{{#invoke:wd|label|{{uc:{{{1}}}}}}}|'|'}} ({{uc:{{{1}}}}})]]
| #default = [[d:Special:EntityPage/Q{{uc:{{{1}}}}}|{{replace|{{#invoke:wd|label|Q{{uc:{{{1}}}}}}}|'|'}} (Q{{uc:{{{1|}}}}})]]
}}
| {{#if:{{#invoke:wd|label|raw}}
| [[d:Special:EntityPage/{{#invoke:wd|label|raw}}|{{#invoke:wd|label}} ({{#invoke:wd|label|raw}})]]
| (no entity)
}}
}}</includeonly><noinclude>{{Documentation}}</noinclude>

Template:Q

Minervaproject — Fri, 25 Sep 2026 08:11:14 GMT

Redirected page to Template:Wikidata entity link

New page

#REDIRECT [[Template:Wikidata entity link]]

{{Redirect category shell|
{{R from move}}
{{R mentioned in hatnote}}
{{R from template shortcut}}
}}
[[Category:Wikidata templates]]

Template:Short description/test

Minervaproject — Fri, 25 Sep 2026 08:10:41 GMT

Created page with "{{nowiki2|1={{#invoke:WikidataIB|getDescription|{{{1|}}}|qid={{{qid|}}}}}}}<noinclude> {{documentation}}</noinclude>"

New page

{{nowiki2|1={{#invoke:WikidataIB|getDescription|{{{1|}}}|qid={{{qid|}}}}}}}<noinclude>
{{documentation}}</noinclude>

Module:Is infobox in lead/doc

Minervaproject — Fri, 25 Sep 2026 08:10:02 GMT

Created page with " {{high use|risk}} '''Module:Is infobox in lead''' checks if a given infobox is in the lead, is also the only infobox in the lead, and that there aren't two of that same infobox in the article. If that is the case, it returns <code>true</code>, and if not returns nothing. This is designed for use by infoboxes that automatically generate sho..."

New page

{{high use|risk}}

'''Module:Is infobox in lead''' checks if a given infobox is in the lead, is also the only infobox in the lead, and that there aren't two of that same infobox in the article. If that is the case, it returns <code>true</code>, and if not returns nothing.

This is designed for use by infoboxes that automatically generate short descriptions, to make sure they only generate a short description if they are the lead infobox.

== Usage ==
<code><nowiki>{{#invoke:Is infobox in lead|main|[Ii]nfobox [Ff]oo [Bb]ar}}</nowiki></code>

It does not detect redirects which do not match the parameter. Redirects can be handled with an extra invocation per redirect pattern, e.g.:

<code><nowiki>{{#invoke:Is infobox in lead|main|[Ii]nfobox [Ss]ong}}{{#invoke:Is infobox in lead|main|[Ii]nfobox [Ss]ingle}}</nowiki></code>

Redirects can be found with [{{fullurl:Special:WhatLinksHere|hidetrans=1&hidelinks=1&target=Template%3AInfobox+(enter+real+name+of+infobox+here)}} WhatLinksHere].
<includeonly>{{#ifeq:{{SUBPAGENAME}}|sandbox | |

[[Category:Infobox modules]]
}}</includeonly><noinclude>
[[Category:Module documentation pages]]
</noinclude>

Module:Is infobox in lead

Minervaproject — Fri, 25 Sep 2026 08:09:39 GMT

Created page with "local p = {} function p.main (frame) return p._main (frame.args[1]) end function p._main (searchString) local content = mw.title.getCurrentTitle():getContent() local offset = string.find(content, "==", 1 , true) if offset then local lead = string.sub(content, 1, offset-1) if (string.find(lead, searchString)) then lead = lead :gsub( "{{%s-[Ii]nfobox%s-mapframe", "") --don't check for infobox mapframe :gsub( "{{%s-[Ii]nfobo[^}]-%|%s-embed%s-=%s-yes", "..."

New page

local p = {}

function p.main (frame)
return p._main (frame.args[1])
end

function p._main (searchString)
local content = mw.title.getCurrentTitle():getContent()
local offset = string.find(content, "==", 1 , true)
if offset then
local lead = string.sub(content, 1, offset-1)
if (string.find(lead, searchString)) then
lead = lead
:gsub( "{{%s-[Ii]nfobox%s-mapframe", "") --don't check for infobox mapframe
:gsub( "{{%s-[Ii]nfobo[^}]-%|%s-embed%s-=%s-yes", "") --don't check for embeded infoboxes
:gsub( "{{%s-[Ii]nfobo[^}]-%|%s-child%s-=%s-yes", "") --don't check for child infoboxes
local iter = string.gmatch(lead, "{{%s-[Ii]nfobox")
iter()
if not iter() then --if able to find two infoboxes in the lead, then don't return true
local iter2 = string.gmatch(content, searchString)
iter2()
if not iter2() then --if able to find two of the specific infobox in the article, then don't return true
return true
end
end
end
end
end

return p

Template:Annotated link

Minervaproject — Fri, 25 Sep 2026 08:09:03 GMT

Created page with "<includeonly>{{ {{{|safesubst:}}}#invoke:Annotated link | main | wikidata = {{{ wikidata |}}} | not_wikidata_for_links_starting_with = List of # Index of # Glossary of # Outline of # Timeline of # History of | not_wikidata_descriptions_including = wikimedia # mediawiki # wikipedia # list # index # glossary # outline # overview | space_cat = {{{ space_cat | {{{ space-cat |}}} }}} | not_single_word = organization # organisation # term | none_is_valid = yes | none..."

New page

<includeonly>{{ {{{|safesubst:}}}#invoke:Annotated link | main

| wikidata = {{{ wikidata |}}}
| not_wikidata_for_links_starting_with = List of # Index of # Glossary of # Outline of # Timeline of # History of
| not_wikidata_descriptions_including = wikimedia # mediawiki # wikipedia # list # index # glossary # outline # overview

| space_cat = {{{ space_cat | {{{ space-cat |}}} }}}
| not_single_word = organization # organisation # term

| none_is_valid = yes
| none_is_nil = yes

| name = {{{ 1 | {{{ name | {{{ title |}}} }}} }}}
| display = {{{ 2 | {{{ display | {{{ disp |}}} }}} }}}
| dash = {{{ 3 | {{{ dash | {{{ comma |}}} }}} }}}

| template_link = {{{ template_link | {{{ template-link | {{{ tl |}}} }}} }}}

| link_lang = {{{ link_lang | {{{ link-lang | {{{ ll |}}} }}} }}}
| link_lang_italic = {{{ link_lang_italic | {{{ link-lang-italic | {{{ lli |}}} }}} }}}
| link_lang_nocat = {{{ link_lang_nocat | {{{ link-lang-nocat | {{{ llnc |}}} }}} }}}
| link_lang_size = {{{ link_lang_size | {{{ link-lang-size | {{{ lls |}}} }}} }}}
| link_lang_cat = {{{ link_lang_cat | {{{ link-lang-cat | {{{ llc |}}} }}} }}}
| link_lang_rtl = {{{ link_lang_rtl | {{{ link-lang-rtl | {{{ llr |}}} }}} }}}

| quote = {{{ quote | {{{ quote_link | {{{ quote-link | {{{ ql |}}} }}} }}} }}}

| abbr = {{{ abbr | {{{ abbreviation |}}} }}}
| abbr_title = {{{ abbr_title | {{{ abbr-title | {{{ abbreviation_title | {{{ abbreviation-title | {{{ at |}}} }}} }}} }}} }}}

| aka = {{{ aka |}}}
| aka_lang = {{{ aka_lang | {{{ aka-lang | {{{ al |}}} }}} }}}
| aka_lang_italic = {{{ aka_lang_italic | {{{ aka-lang-italic | {{{ ali |}}} }}} }}}
| aka_lang_nocat = {{{ aka_lang_nocat | {{{ aka-lang-nocat | {{{ alnc |}}} }}} }}}
| aka_lang_size = {{{ aka_lang_size | {{{ aka-lang-size | {{{ als |}}} }}} }}}
| aka_lang_cat = {{{ aka_lang_cat | {{{ aka-lang-cat | {{{ alc |}}} }}} }}}
| aka_lang_rtl = {{{ aka_lang_rtl | {{{ aka-lang-rtl | {{{ alr |}}} }}} }}}

| wedge = {{{ wedge | {{{ insert | {{{ extra |}}} }}} }}}
| wedge_lang = {{{ wedge_lang | {{{ wedge-lang | {{{ insert_lang | {{{ insert-lang | {{{ extra_lang | {{{ extra-lang | {{{ wl |}}} }}} }}} }}} }}} }}} }}}
| wedge_lang_italic = {{{ wedge_lang_italic | {{{ wedge-lang-italic | {{{ insert_lang_italic | {{{ insert-lang-italic | {{{ extra_lang_italic | {{{ extra-lang-italic | {{{ wli |}}} }}} }}} }}} }}} }}} }}}
| wedge_lang_nocat = {{{ wedge_lang_nocat | {{{ wedge-lang_nocat | {{{ insert_lang_nocat | {{{ insert-lang-nocat | {{{ extra_lang_nocat | {{{ extra-lang-nocat | {{{ wlnc |}}} }}} }}} }}} }}} }}} }}}
| wedge_lang_size = {{{ wedge_lang_size | {{{ wedge-lang-size | {{{ insert_lang_size | {{{ insert-lang-size | {{{ extra_lang_size | {{{ extra-lang-size | {{{ wls |}}} }}} }}} }}} }}} }}} }}}
| wedge_lang_cat = {{{ wedge_lang_cat | {{{ wedge-lang-cat | {{{ insert_lang_cat | {{{ insert-lang-cat | {{{ extra_lang_cat | {{{ extra-lang-cat | {{{ wlc |}}} }}} }}} }}} }}} }}} }}}
| wedge_lang_rtl = {{{ wedge_lang_rtl | {{{ wedge-lang-rtl | {{{ insert_lang_rtl | {{{ insert-lang-rtl | {{{ extra_lang_rtl | {{{ extra-lang-rtl | {{{ wlr |}}} }}} }}} }}} }}} }}} }}}

| desc_first_letter_case = {{{ desc_first_letter_case | {{{ desc-first-letter-case | {{{ desc_case | {{{ desc-case | {{{ case | {{{ dflc |}}} }}} }}} }}} }}} }}}

| only = {{{ only |}}}
| prefer = {{{ prefer |}}}
| fallback = {{{ fallback |}}}

| desc_lang_italic = {{{ desc_lang_italic | {{{ desc-lang-italic | {{{ dli |}}} }}} }}}
| desc_lang_nocat = {{{ desc_lang_nocat | {{{ desc-lang-nocat | {{{ dlnc |}}} }}} }}}
| desc_lang_size = {{{ desc_lang_size | {{{ desc-lang-size | {{{ dls |}}} }}} }}}
| desc_lang_cat = {{{ desc_lang_cat | {{{ desc-lang-cat | {{{ dlc |}}} }}} }}}
| desc_lang_rtl = {{{ desc_lang_rtl | {{{ desc-lang-rtl | {{{ dlr |}}} }}} }}}
| desc_lang_no = {{{ desc_lang_no | {{{ desc-lang-no | {{{ dlno |}}} }}} }}}

}}</includeonly><noinclude>{{documentation}}</noinclude>

Template:Source parameter

Minervaproject — Fri, 25 Sep 2026 08:08:24 GMT

Created page with "{{SAFESUBST:<noinclude />#ifeq:{{SAFESUBST:<noinclude />Yesno|{{{nested|no}}}}}|yes||<{{{tag|code}}}>}}{{{{{{1<noinclude>|foo</noinclude>}}}{{SAFESUBST:<noinclude />#ifeq:{{{2}}}|{{{2|}}} ||}}{{{2|}}}}}}{{SAFESUBST:<noinclude />#ifeq:{{SAFESUBST:<noinclude />Yesno|{{{nested|no}}}}}|yes||</{{{tag|code}}}>}}<noinclude> {{Documentation}}  </noinclude>"

New page

{{SAFESUBST:<noinclude />#ifeq:{{SAFESUBST:<noinclude />Yesno|{{{nested|no}}}}}|yes||<{{{tag|code}}}>}}{{{{{{1<noinclude>|foo</noinclude>}}}{{SAFESUBST:<noinclude />#ifeq:{{{2}}}|{{{2|}}} ||}}{{{2|}}}}}}{{SAFESUBST:<noinclude />#ifeq:{{SAFESUBST:<noinclude />Yesno|{{{nested|no}}}}}|yes||</{{{tag|code}}}>}}<noinclude>
{{Documentation}}

</noinclude>

Template:Param

Minervaproject — Fri, 25 Sep 2026 08:08:08 GMT

Redirected page to Template:Source parameter

New page

#REDIRECT [[Template:Source parameter]]

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

Template:--

Minervaproject — Fri, 25 Sep 2026 08:07:38 GMT

Redirected page to Template:Em dash

New page

#REDIRECT [[Template:Em dash]]

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

Template:Short description/doc

Minervaproject — Fri, 25 Sep 2026 07:55:53 GMT

Created page with "<noinclude> {{pp|small=yes}} </noinclude> {{Documentation subpage}}  {{High risk}} {{cascade-protected template}} {{Warning|{{strong|Please do not use redirects or shortcuts for this template}}, as they cause problems with the short description editing gadget and other maintenance tools.}} {{Lua|Module:Check for..."

New page

<noinclude>
{{pp|small=yes}}
</noinclude>
{{Documentation subpage}}

{{High risk}}
{{cascade-protected template}}
{{Warning|{{strong|Please do not use redirects or shortcuts for this template}}, as they cause problems with the [[Wikipedia:Shortdesc helper|short description editing gadget]] and other maintenance tools.}}
{{Lua|Module:Check for unknown parameters|Module:String|Module:SDcat}}

'''[[Template:Short description]]''' is used to add a [[Wikipedia:Short description|short description]] (which can be edited from within Wikipedia) to a Wikipedia page. These descriptions may appear in Wikipedia searches and elsewhere, and [[WP:SDPURPOSE|help users identify the desired article]].

== Usage ==
{{tld|Short description|''Write your short description here''}}

This should be limited to about 40 characters, as explained at [[WP:SDFORMAT]], along with the other guidance at [[WP:SDCONTENT]].

If the page's title is sufficiently descriptive that a [[WP:SDNONE|short description is not needed]], use the following:

{{tld|Short description|none}}

== Parameters ==
{{TemplateData header|noheader=1}}
<templatedata>
{
"description": {
"en": "Creates a short description for a Wikipedia page, which is displayed in search results and other locations.",
"es": "Crea una breve descripción, para un artículo de Wikipedia, que se utiliza en el Editor Visual para proporcionar contexto en los wikilinks (wikienlaces)."
},
"params": {
"1": {
"label": {
"en": "Description",
"es": "Descripción"
},
"description": {
"en": "The short description of the article or 'none'. It should be limited to about 40 characters.",
"es": "La descripción corta del artículo"
},
"example": {
"en": "Endangered species of South American fish",
"es": "La enciclopedia en línea que cualquiera puede editar"
},
"required": true,
"type": "content"
},
"2": {
"label": {
"en": "No replace?",
"es": "2"
},
"description": {
"en": "Should be unused or 'noreplace'. Templates with noreplace will not replace a short description defined by an earlier template. Mainly for use within transcluded templates.",
"es": "Se anula una descripción corta si se transcluye. Debe estar sin usar o con 'noreplace' (que significar no reemplazar)."
},
"example": {
"es": "noreplace"
},
"required": false,
"type": "string",
"autovalue": "noreplace",
"suggestedvalues": [
"noreplace"
]
},
"pagetype": {
"type": "string",
"description": {
"en": "The type of page. This puts it in the appropriate category - Things with short description. Normally unneeded, since handled through namespace detection.",
"es": "El tipo de página. La coloca en la categoría apropiada - Cosas con descripción corta"
},
"example": "Redirect, Disambiguation page",
"required": false
}
},
"format": "{{_|_ = _}}\n"
}
</templatedata>

== About writing good short descriptions ==
This page is about the short description {{em|template}}; it does not provide guidelines for writing a good short description. If you plan to use this template, you should make sure you read and follow the detailed guidance at [[WP:HOWTOSD]]. General information can be found at [[Wikipedia:Short description]].

== Template information ==
Eventually all articles should have a short description:
* by directly using this template, in which case the short description will be unique to the article
* transcluded in another template, such as a disambiguation template, where a generic short description is adequate for a large class of pages
* where the short description is assembled from data in an infobox

Automatically generated descriptions within templates should set the second parameter as {{code|noreplace}} so they do not override any short descriptions specifically added to the transcluding article.

Short descriptions are not normally needed for non-article pages, such as redirects, but can be added if useful.

If the article title alone is sufficient to ensure reliable identification of the desired article, a null value of {{tnull|Short description|none}} may be used.

Short descriptions do not necessarily serve the same function as the Wikidata description for an item and they do not have to be the same, but some overlap is expected in many cases. Some Wikidata descriptions may be unsuitable, and if imported must be checked for relevance, accuracy and fitness for purpose. Responsibility for such imports lies with the importer. {{crossref|(See also [[d:Help:Description|Wikidata:Help:Description]].)}}

=== Example ===
At [[Oxygen therapy]], add the following at the very top of the article, above everything else:
* {{tld|Short description|Use of oxygen as medical treatment}}

== Testing ==
For testing purposes, the display of this template can be enabled by adding a line to your [[Special:MyPage/common.css]]:
* <syntaxhighlight lang="CSS" inline>.shortdescription { display:block !important; }</syntaxhighlight>
This can be easily removed or disabled when testing is finished.

If you want to {{em|always}} see short descriptions, you may prefer a more utilitarian layout, such as:

<syntaxhighlight lang="CSS">
.shortdescription {
display:block !important;
white-space: pre-wrap;
}
.shortdescription::before {
content: "\A[Short description:\0020";
}
.shortdescription::after {
content: "]\A";
}
</syntaxhighlight>
There is a test version of this template available as [[Template:Short description/test]] which displays its text by default.
* {{tld|Short description/test}} displays the short description if supplied
* {{tld|Short description/test}} displays nothing if <code>none</code> is supplied
* {{tld|Short description/test}} displays the description from Wikidata if <code>wikidata</code> is supplied.

Taking {{Q|Q1096878}} as an example:
* <code><nowiki>{{short description/test|Underwater diving where breathing is from equipment independent of the surface}}</nowiki></code> → {{short description/test|Underwater diving where breathing is from equipment independent of the surface }}
* <code><nowiki>{{short description/test|none}}</nowiki></code> → {{short description/test|none}}
* <code><nowiki>{{short description/test|wikidata}}</nowiki></code> → {{short description/test|wikidata|qid=Q1096878}}

===Pagetype parameter===
If {{param|Pagetype}} is '''not''' set, then this template adds the article to a category based on the namespace:
* {{clc|Articles with short description}}
* {{clc|Redirects with short description}} {{--}} for redirects in any namespace

If {{param|Pagetype}} '''is''' set, then this template adds the article to a category matching the parameter. For example:
* {{cl|Redirects with short description}} {{--}} {{code|pagetype {{=}} Redirect }}

== Redirects ==

While there are currently [{{fullurl:Special:WhatLinksHere/Template:Short_description|hidetrans=1&hidelinks=1&limit=500}} redirects to this template], {{Strong|they must not be used}}, for the reasons below:

* Other templates and gadgets attempt to extract short descriptions from pages by explicitly searching for the {{tl|Short description}} template.
* For example, {{tl|Annotated link}} searches for the template in its uppercase "Short description" and lowercase form "short description"; either form is acceptable.
* Infoboxes often check the article for an existing short description template before setting thier own short description.

See the related [[Wikipedia:Redirects for discussion/Log/2021 July 20#Aliases for Short description template|2021 RfD]].

{{Strong|Do not}} start the template with a space: {{code|<nowiki> {{ Short description...</nowiki>}} or use an underscore: {{code|<nowiki> {{Short_description...</nowiki>}}. While these do create a valid short description, they will prevent searches for the {{code|<nowiki>{{Short description...</nowiki>}} text.

==Tracking categories==
* {{clc|Templates that generate short descriptions}}
* {{clc|Modules that create a short description}}
* {{clc|Short description matches Wikidata}}
* {{clc|Short description is different from Wikidata}}
* {{clc|Short description with empty Wikidata description}}

== Maintenance categories ==
* {{clc|Pages using short description with unknown parameters}}
* {{clc|Articles with long short description}}
* {{clc|Pages with lower-case short description}}

== See also ==

* {{tlx|Auto short description}}
* {{tlx|Annotated link}}
* {{tlx|laal}} – displays an article's pagelinks alongside its short description
* [[Module:Is infobox in lead]]
* [[Wikipedia:Short descriptions]] – background information
* [[Wikipedia:WikiProject Short descriptions]] – project to add Short descriptions to all articles

<includeonly>{{Sandbox other||

[[Category:Short description templates]]
[[Category:Templates that add a tracking category]]
[[Category:Templates that generate short descriptions]]
}}</includeonly>

Module:Transclusion count/data/C

Minervaproject — Fri, 25 Sep 2026 07:48:55 GMT

Created page with "return { ["C"] = 803000, ["C-Class"] = 17000, ["C-SPAN"] = 13000, ["C-cmn"] = 2800, ["C-pl"] = 51000, ["C."] = 354000, ["CAN"] = 20000, ["CANelec"] = 18000, ["CANelec/gain"] = 3500, ["CANelec/hold"] = 6800, ["CANelec/source"] = 11000, ["CANelec/top"] = 9100, ["CANelec/total"] = 9600, ["CAS"] = 3800, ["CAS_Registry_Number"] = 3800, ["CBB_Yearly_Record_End"] = 3500, ["CBB_Yearly_Record_Entry"] = 3600, ["CBB_Yearly_Record_Start"] = 3400, ["CBB_Yearly_Record_Subhead"] = 4200..."

Show changes

Template:Protected due to vandalism

Minervaproject — Fri, 25 Sep 2026 07:47:26 GMT

Created page with "<includeonly>{{#invoke:Protected page|main}}</includeonly><noinclude> {{documentation}}  </noinclude>"

New page

<includeonly>{{#invoke:Protected page|main}}</includeonly><noinclude>
{{documentation}}

</noinclude>

Module:Message box/

Minervaproject — Fri, 25 Sep 2026 07:44:54 GMT

Created page with "require('strict') local getArgs local yesno = require('Module:Yesno') local lang = mw.language.getContentLanguage() local CONFIG_MODULE = 'Module:Message box/configuration' local DEMOSPACES = {talk = 'tmbox', image = 'imbox', file = 'imbox', category = 'cmbox', article = 'ambox', main = 'ambox'} -------------------------------------------------------------------------------- -- Helper functions ---------------------------------------------------------------------------..."

New page

require('strict')
local getArgs
local yesno = require('Module:Yesno')
local lang = mw.language.getContentLanguage()

local CONFIG_MODULE = 'Module:Message box/configuration'
local DEMOSPACES = {talk = 'tmbox', image = 'imbox', file = 'imbox', category = 'cmbox', article = 'ambox', main = 'ambox'}

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

local function getTitleObject(...)
-- 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, ...)
if success then
return title
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
table.insert(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
table.insert(nums, tonumber(num))
end
end
table.sort(nums)
return nums
end

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

local MessageBox = {}
MessageBox.__index = MessageBox

function MessageBox.new(boxType, args, cfg)
args = args or {}
local obj = {}

-- Set the title object and the namespace.
obj.title = getTitleObject(args.page) or mw.title.getCurrentTitle()

-- Set the config for our box type.
obj.cfg = cfg[boxType]
if not obj.cfg then
local ns = obj.title.namespace
-- boxType is "mbox" or invalid input
if args.demospace and args.demospace ~= '' then
-- implement demospace parameter of mbox
local demospace = string.lower(args.demospace)
if DEMOSPACES[demospace] then
-- use template from DEMOSPACES
obj.cfg = cfg[DEMOSPACES[demospace]]
elseif string.find( demospace, 'talk' ) then
-- demo as a talk page
obj.cfg = cfg.tmbox
else
-- default to ombox
obj.cfg = cfg.ombox
end
elseif ns == 0 then
obj.cfg = cfg.ambox -- main namespace
elseif ns == 6 then
obj.cfg = cfg.imbox -- file namespace
elseif ns == 14 then
obj.cfg = cfg.cmbox -- category namespace
else
local nsTable = mw.site.namespaces[ns]
if nsTable and nsTable.isTalk then
obj.cfg = cfg.tmbox -- any talk namespace
else
obj.cfg = cfg.ombox -- other namespaces or invalid input
end
end
end

-- Set the arguments, and remove all blank arguments except for the ones
-- listed in cfg.allowBlankParams.
do
local newArgs = {}
for k, v in pairs(args) do
if v ~= '' then
newArgs[k] = v
end
end
for i, param in ipairs(obj.cfg.allowBlankParams or {}) do
newArgs[param] = args[param]
end
obj.args = newArgs
end

-- Define internal data structure.
obj.categories = {}
obj.classes = {}
-- For lazy loading of [[Module:Category handler]].
obj.hasCategories = false

return setmetatable(obj, MessageBox)
end

function MessageBox:addCat(ns, cat, sort)
if not cat then
return nil
end
if sort then
cat = string.format('[[Category:%s|%s]]', cat, sort)
else
cat = string.format('[[Category:%s]]', cat)
end
self.hasCategories = true
self.categories[ns] = self.categories[ns] or {}
table.insert(self.categories[ns], cat)
end

function MessageBox:addClass(class)
if not class then
return nil
end
table.insert(self.classes, class)
end

function MessageBox:setParameters()
local args = self.args
local cfg = self.cfg

-- Get type data.
self.type = args.type
local typeData = cfg.types[self.type]
self.invalidTypeError = cfg.showInvalidTypeError
and self.type
and not typeData
typeData = typeData or cfg.types[cfg.default]
self.typeClass = typeData.class
self.typeImage = typeData.image
self.typeImageNeedsLink = typeData.imageNeedsLink

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

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

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

-- Add attributes, classes and styles.
self.id = args.id
self.name = args.name
if self.name then
self:addClass('box-' .. string.gsub(self.name,' ','_'))
end
if yesno(args.plainlinks) ~= false then
self:addClass('plainlinks')
end
if self.below then
self:addClass('mbox-with-below')
end
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

-- Set image classes.
self.imageRightClass = args.imagerightclass or args.imageclass
self.imageLeftClass = args.imageleftclass or args.imageclass

-- 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
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)
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 = {}
table.insert(issues, sect)
table.insert(issues, issue)
table.insert(issues, text)
self.issue = table.concat(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
if self.isSmall then
local talkLink = talkArgIsTalkPage and talk or (talkTitle.prefixedText .. (talk == '#' and '' or '#') .. talk)
talkText = string.format('([[%s|talk]])', talkLink)
else
talkText = 'Relevant discussion may be found on'
if talkArgIsTalkPage then
talkText = string.format(
'%s [[%s|%s]].',
talkText,
talk,
talkTitle.prefixedText
)
else
talkText = string.format(
'%s the [[%s' .. (talk == '#' and '' or '#') .. '%s|talk page]].',
talkText,
talkTitle.prefixedText,
talk
)
end
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 = string.format(" (%s)", date)
end
self.info = args.info
if yesno(args.removalnotice) then
self.removalNotice = cfg.removalNotice
end
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

-- General image settings.
self.imageCellDiv = not self.isSmall and cfg.imageCellDiv
self.imageEmptyCell = cfg.imageEmptyCell

-- 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 = string.format('[[File:%s|%s%s|alt=]]', self.typeImage
or 'Information icon4.svg', imageSize, self.typeImageNeedsLink and "" or "|link=" )
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

-- set templatestyles
self.base_templatestyles = cfg.templatestyles
self.templatestyles = args.templatestyles
end

function MessageBox:setMainspaceCategories()
local args = self.args
local cfg = self.cfg

if not cfg.allowMainspaceCategories then
return nil
end

local nums = {}
for _, prefix in ipairs{'cat', 'category', 'all'} do
args[prefix .. '1'] = args[prefix]
nums = union(nums, getArgNums(args, prefix))
end

-- 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(nums) 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 = string.format('%s %s %s', mainCat, preposition, date)
self:addCat(0, catTitle)
catTitle = getTitleObject('Category:' .. catTitle)
if not catTitle or not catTitle.exists then
self:addCat(0, 'Articles with invalid date parameter in template')
end
elseif mainCat and (not date or date == '') then
self:addCat(0, mainCat)
end
if allCat then
self:addCat(0, allCat)
end
end
end

function MessageBox:setTemplateCategories()
local args = self.args
local cfg = self.cfg

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

-- Add template error categories.
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(10, templateCat, templateSort)
end
end

function MessageBox:setAllNamespaceCategories()
-- Set categories for all namespaces.
if self.invalidTypeError then
local allSort = (self.title.namespace == 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
end

function MessageBox:setCategories()
if self.title.namespace == 0 then
self:setMainspaceCategories()
elseif self.title.namespace == 10 then
self:setTemplateCategories()
end
self:setAllNamespaceCategories()
end

function MessageBox:renderCategories()
if not self.hasCategories then
-- No categories added, no need to pass them to Category handler so,
-- if it was invoked, it would return the empty string.
-- So we shortcut and return the empty string.
return ""
end
-- Convert category tables to strings and pass them through
-- [[Module:Category handler]].
return require('Module:Category handler')._main{
main = table.concat(self.categories[0] or {}),
template = table.concat(self.categories[10] or {}),
all = table.concat(self.categories.all or {}),
nocat = self.args.nocat,
page = self.args.page
}
end

function MessageBox:exportDiv()
local root = mw.html.create()

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

local frame = mw.getCurrentFrame()
root:wikitext(frame:extensionTag{
name = 'templatestyles',
args = { src = self.base_templatestyles },
})
-- Add support for a single custom templatestyles sheet. Undocumented as
-- need should be limited and many templates using mbox are substed; we
-- don't want to spread templatestyles sheets around to arbitrary places
if self.templatestyles then
root:wikitext(frame:extensionTag{
name = 'templatestyles',
args = { src = self.templatestyles },
})
end

-- Create the box.
local mbox = root:tag('div')
mbox:attr('id', self.id or nil)
for i, class in ipairs(self.classes or {}) do
mbox:addClass(class or nil)
end
mbox
:cssText(self.style or nil)

if self.attrs then
mbox:attr(self.attrs)
end

local flex_container
if self.below then
-- we need to wrap the flex components (`image(right)` and `text`) in their
-- own container div to support the `below` parameter
flex_container = mw.html.create('div')
flex_container:addClass('mbox-flex')
else
-- the mbox itself is the parent, so we need no HTML flex_container
flex_container = mw.html.create()
end

-- Add the left-hand image.
if self.imageLeft then
local imageLeftCell = flex_container:tag('div'):addClass('mbox-image')
imageLeftCell
:addClass(self.imageLeftClass)
:wikitext(self.imageLeft or nil)
end

-- Add the text.
local textCell = flex_container:tag('div'):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 or nil)
local textCellDiv = textCell:tag('div')
textCellDiv
:addClass('mbox-text-span')
:wikitext(self.issue or nil)
if (self.talk or self.fix) then
textCellDiv:tag('span')
:addClass('hide-when-compact')
:wikitext(self.talk and (' ' .. self.talk) or nil)
:wikitext(self.fix and (' ' .. self.fix) or nil)
end
textCellDiv:wikitext(self.date and (' ' .. self.date) or nil)
if self.info and not self.isSmall then
textCellDiv
:tag('span')
:addClass('hide-when-compact')
:wikitext(self.info and (' ' .. self.info) or nil)
end
if self.removalNotice then
textCellDiv:tag('span')
:addClass('hide-when-compact')
:tag('i')
:wikitext(string.format(" (%s)", self.removalNotice))
end
else
-- Default text formatting - anything goes.
textCell
:cssText(self.textstyle or nil)
:wikitext(self.text or nil)
end

-- Add the right-hand image.
if self.imageRight then
local imageRightCell = flex_container:tag('div'):addClass('mbox-imageright')
imageRightCell
:addClass(self.imageRightClass)
:wikitext(self.imageRight or nil)
end

mbox:node(flex_container)

-- Add the below row.
if self.below then
mbox:tag('div')
:addClass('mbox-text mbox-below')
:cssText(self.textstyle or nil)
:wikitext(self.below or nil)
end

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

-- Add categories.
root:wikitext(self:renderCategories() or nil)

return tostring(root)
end

function MessageBox:export()

local root = mw.html.create()

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

local frame = mw.getCurrentFrame()
root:wikitext(frame:extensionTag{
name = 'templatestyles',
args = { src = self.base_templatestyles },
})
-- Add support for a single custom templatestyles sheet. Undocumented as
-- need should be limited and many templates using mbox are substed; we
-- don't want to spread templatestyles sheets around to arbitrary places
if self.templatestyles then
root:wikitext(frame:extensionTag{
name = 'templatestyles',
args = { src = self.templatestyles },
})
end

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

if self.attrs then
boxTable:attr(self.attrs)
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'):addClass('mbox-image-div')
end
imageLeftCell
:addClass(self.imageLeftClass)
:wikitext(self.imageLeft or nil)
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')
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 or nil)
local textCellDiv = textCell:tag('div')
textCellDiv
:addClass('mbox-text-span')
:wikitext(self.issue or nil)
if (self.talk or self.fix) then
textCellDiv:tag('span')
:addClass('hide-when-compact')
:wikitext(self.talk and (' ' .. self.talk) or nil)
:wikitext(self.fix and (' ' .. self.fix) or nil)
end
textCellDiv:wikitext(self.date and (' ' .. self.date) or nil)
if self.info and not self.isSmall then
textCellDiv
:tag('span')
:addClass('hide-when-compact')
:wikitext(self.info and (' ' .. self.info) or nil)
end
if self.removalNotice then
textCellDiv:tag('span')
:addClass('hide-when-compact')
:tag('i')
:wikitext(string.format(" (%s)", self.removalNotice))
end
else
-- Default text formatting - anything goes.
textCell
:cssText(self.textstyle or nil)
:wikitext(self.text or nil)
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'):addClass('mbox-image-div')
end
imageRightCell
:addClass(self.imageRightClass)
:wikitext(self.imageRight or nil)
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 or nil)
:wikitext(self.below or nil)
end

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

-- Add categories.
root:wikitext(self:renderCategories() or nil)

return tostring(root)
end

--------------------------------------------------------------------------------
-- Exports
--------------------------------------------------------------------------------

local p, mt = {}, {}

function p._exportClasses()
-- For testing.
return {
MessageBox = MessageBox
}
end

function p.main(boxType, args, cfgTables)
local box = MessageBox.new(boxType, args, cfgTables or mw.loadData(CONFIG_MODULE))
box:setParameters()
box:setCategories()
-- DIV MIGRATION CONDITIONAL
if box.cfg.div_structure then
return box:exportDiv()
end
-- END DIV MIGRATION CONDITIONAL
return box:export()
end

function mt.__index(t, k)
return function (frame)
if not getArgs then
getArgs = require('Module:Arguments').getArgs
end
return t.main(k, getArgs(frame, {trim = false, removeBlanks = false}))
end
end

return setmetatable(p, mt)

Module:Documentation/

Minervaproject — Fri, 25 Sep 2026 07:42:53 GMT

Created page with "-- This module implements {{documentation}}. -- Get required modules. local getArgs = require('Module:Arguments').getArgs -- Get the config table. local cfg = mw.loadData('Module:Documentation/config') local p = {} -- Often-used functions. local ugsub = mw.ustring.gsub local format = mw.ustring.format ---------------------------------------------------------------------------- -- Helper functions -- -- These are defined as local functions, but are made available in..."

Show changes

Template:Module link expanded

Minervaproject — Fri, 25 Sep 2026 07:41:04 GMT

Created page with "<includeonly><code>{{{{{{{|safesubst:}}}#invoke:Separated entries|main|[[Module:{{{1}}}{{{section|}}}|#invoke:{{{1}}}]]|{{{2|''function''}}}|separator=|}}}}</code></includeonly><noinclude>{{documentation}}</noinclude>"

New page

<includeonly><code>{{{{{{{|safesubst:}}}#invoke:Separated entries|main|[[Module:{{{1}}}{{{section|}}}|#invoke:{{{1}}}]]|{{{2|''function''}}}|separator=|}}}}</code></includeonly><noinclude>{{documentation}}</noinclude>

Template:Mlx

Minervaproject — Fri, 25 Sep 2026 07:40:48 GMT

Redirected page to Template:Module link expanded

New page

#REDIRECT [[Template:Module link expanded]]

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

Module:Transclusion count/data/P

Minervaproject — Tue, 22 Sep 2026 17:58:28 GMT

Created page with "return { ["P"] = 6400, ["P-1"] = 4800, ["P-phrases"] = 4300, ["P."] = 4000, ["P1"] = 234000, ["P2"] = 516000, ["PAGENAMEBASE"] = 1910000, ["PAGENAMEU"] = 55000, ["PAK"] = 3500, ["PD-US"] = 8600, ["PD-US-1923-abroad"] = 5400, ["PD-US-expired"] = 5000, ["PD-US-expired-abroad"] = 8700, ["PD-US-no_notice"] = 2300, ["PD-art"] = 3300, ["PD-ineligible-USonly"] = 7700, ["PD-notice"] = 26000, ["PD-old-100"] = 3200, ["PD-self"] = 31000, ["PD-textlogo"] = 6200, ["PDB_Gallery"] = 29..."

New page

return {
["P"] = 6400,
["P-1"] = 4800,
["P-phrases"] = 4300,
["P."] = 4000,
["P1"] = 234000,
["P2"] = 516000,
["PAGENAMEBASE"] = 1910000,
["PAGENAMEU"] = 55000,
["PAK"] = 3500,
["PD-US"] = 8600,
["PD-US-1923-abroad"] = 5400,
["PD-US-expired"] = 5000,
["PD-US-expired-abroad"] = 8700,
["PD-US-no_notice"] = 2300,
["PD-art"] = 3300,
["PD-ineligible-USonly"] = 7700,
["PD-notice"] = 26000,
["PD-old-100"] = 3200,
["PD-self"] = 31000,
["PD-textlogo"] = 6200,
["PDB_Gallery"] = 2900,
["PER"] = 3500,
["PHI"] = 2700,
["PHL"] = 3700,
["PH_census"] = 2000,
["PLANTS"] = 4300,
["PM20"] = 3300,
["PMID"] = 6500,
["PNsign"] = 2100,
["POL"] = 68000,
["POR"] = 5600,
["POTD/Day"] = 2900,
["POTD_archive"] = 2600,
["POTD_archive/footer"] = 2600,
["POTD_default"] = 12000,
["POTD_image"] = 3900,
["POTD_image1"] = 2600,
["POTD_image2"] = 2600,
["POTD_navigation"] = 7900,
["POTD_texttitle"] = 2600,
["POTDlink"] = 8300,
["POV"] = 3200,
["POW"] = 2600,
["PR/header"] = 3100,
["PR/heading"] = 7200,
["PRI"] = 2200,
["PRT"] = 6500,
["PR_link"] = 119000,
["PS"] = 3100,
["Pad"] = 51000,
["Paddle_Steamer"] = 3100,
["Page"] = 4400,
["Page_list"] = 15000,
["Page_name_sub"] = 52000,
["Page_needed"] = 24000,
["Page_tabs"] = 4100,
["Page_tabs/styles.css"] = 4100,
["Pagelinks"] = 75000,
["Pagelist"] = 15000,
["Pagetype"] = 11400000,
["Paid"] = 17000,
["Pakistani_English"] = 4000,
["Para"] = 2970000,
["Parabr"] = 3800,
["Paragraph_break"] = 2160000,
["Param_value"] = 153000,
["Param_value/styles.css"] = 153000,
["Parameter"] = 3120000,
["Parameter_names_example"] = 2700,
["ParmPart"] = 15000,
["Partial"] = 5600,
["Partial_minor_planet_designation"] = 5700,
["Partly_done"] = 4300,
["Party_color"] = 83000,
["Party_color_cell"] = 6900,
["Party_index_link"] = 3300,
["Party_name_with_color"] = 7400,
["Party_name_with_colour"] = 4200,
["Party_shading/Democratic"] = 19000,
["Party_shading/Independent"] = 3400,
["Party_shading/Republican"] = 18000,
["Party_stripe"] = 18000,
["Pass"] = 3300,
["Pb"] = 2130000,
["Pd-notice"] = 2200,
["Pedigree"] = 4400,
["Peer_review/heading"] = 10000,
["Peer_review_links"] = 3300,
["Peer_review_tools"] = 9600,
["Penalty_shoot-out"] = 6000,
["Pending"] = 6500,
["Pending_DYK_American_hooks"] = 5300,
["Pending_DYK_biographies"] = 11000,
["Pending_changes–protected"] = 4400,
["Pending_film"] = 2900,
["Pending_films_key"] = 2600,
["Pengoal"] = 13000,
["Penmiss"] = 15000,
["Percentage"] = 18000,
["Performance_key"] = 2800,
["Performance_key/styles.css"] = 2800,
["Period_color"] = 28000,
["Period_end"] = 26000,
["Period_id"] = 29000,
["Period_start"] = 29000,
["Personal_attack_removed"] = 2200,
["PeruTasks"] = 19000,
["Phab"] = 8100,
["Phabricator"] = 8400,
["Phanerozoic_250px"] = 25000,
["PharmNavFootnote"] = 5600,
["Philippine_census_reference"] = 2000,
["Philippine_name"] = 4300,
["Photo"] = 2200,
["Photo_montage"] = 5000,
["Photo_requested"] = 108000,
["Photograph_requested"] = 4700,
["Photomontage"] = 4400,
["Photoreq"] = 2900,
["Picture_of_the_day"] = 8300,
["Pie_chart"] = 8500,
["Pie_chart/styles.css"] = 8500,
["Ping"] = 286000,
["Pipe"] = 97000,
["Place_name_disambiguation"] = 40000,
["Plain_link"] = 120000,
["Plain_list"] = 169000,
["Plain_text"] = 109000,
["Plainlink"] = 30000,
["Plainlist"] = 378000,
["Plainlist/styles.css"] = 3130000,
["Player"] = 3900,
["Player2"] = 2900,
["Please_check_ISSN"] = 16000,
["Plural"] = 108000,
["Pluralize_from_text"] = 2890000,
["Pn"] = 2900,
["Poem_quote"] = 4000,
["Poemquote"] = 2700,
["Politician_icon"] = 35000,
["Politician_icon2"] = 35000,
["Politics_sidebar_below"] = 19000,
["Politics_sidebar_title"] = 19000,
["Polluted_category"] = 2500,
["Polparty"] = 31000,
["Pop_density"] = 10000,
["Population_Germany"] = 14000,
["Portal"] = 10800000,
["Portal-Class"] = 8100,
["Portal-inline"] = 246000,
["Portal_and_project"] = 263000,
["Portal_bar"] = 186000,
["Portal_box"] = 2100,
["Portalbar"] = 9900,
["Portuguese_name"] = 10000,
["Possible"] = 4000,
["Possibly_empty_category"] = 70000,
["Post-nominals"] = 63000,
["Post-nominals/AUS"] = 8500,
["Post-nominals/CAN"] = 10000,
["Post-nominals/GBR"] = 33000,
["Post-nominals/NZL"] = 4500,
["Postnominals"] = 11000,
["Pp"] = 8700,
["Pp-book-cover"] = 52000,
["Pp-extended"] = 11000,
["Pp-move"] = 10000,
["Pp-pc"] = 3700,
["Pp-protected"] = 13000,
["Pp-semi"] = 6900,
["Pp-semi-indef"] = 4700,
["Pp-template"] = 4400,
["Pp-vandalism"] = 2700,
["Precision"] = 6000,
["Preferences"] = 18000,
["Preferences/section"] = 3400,
["PresFoot"] = 3300,
["PresHead"] = 3900,
["PresRow"] = 3900,
["Press"] = 5800,
["Preview_warning"] = 488000,
["Primary_source_inline"] = 8300,
["Primary_sources"] = 33000,
["Principal_rank"] = 655000,
["Prisoner_of_war"] = 2600,
["Prl"] = 119000,
["ProCyclingStats"] = 2400,
["ProQuest"] = 36000,
["Professional_wrestling_profiles"] = 3200,
["Professional_wrestling_results_table"] = 3200,
["Profit"] = 3600,
["Progress_box"] = 19000,
["Project-Class"] = 13000,
["Project_other"] = 18000,
["Promotional"] = 18000,
["Proper_name"] = 2800,
["Prose"] = 3300,
["Protected_due_to_vandalism"] = 2900,
["Protected_page"] = 25000,
["Protected_page_maintenance_message"] = 42000,
["Protection_padlock"] = 3700,
["Proxy_block"] = 2200,
["Pso"] = 5100,
["Purge"] = 571000,
["Purge_button"] = 19000,
["Purge_button/styles.css"] = 19000,
["Module:POTD_titletext"] = 2500,
["Module:Page"] = 123000,
["Module:PageLinks"] = 75000,
["Module:Page_tabs"] = 4100,
["Module:Pagelist"] = 15000,
["Module:Pagetype"] = 19100000,
["Module:Pagetype/config"] = 19100000,
["Module:Pagetype/disambiguation"] = 13300000,
["Module:Pagetype/rfd"] = 17200000,
["Module:Pagetype/setindex"] = 13600000,
["Module:Pagetype/softredirect"] = 17800000,
["Module:ParameterCount"] = 1760000,
["Module:Parameter_names_example"] = 2700,
["Module:Parameter_validation"] = 166000,
["Module:Parameter_validation/default_config"] = 166000,
["Module:Party_name_with_color"] = 14000,
["Module:Percentage"] = 18000,
["Module:Person_date"] = 1790000,
["Module:Person_height"] = 284000,
["Module:Person_length"] = 7700,
["Module:Person_weight"] = 85000,
["Module:Phone_size"] = 2200,
["Module:Photo_montage"] = 5000,
["Module:Piechart"] = 8500,
["Module:Piechart/cuts.json"] = 8500,
["Module:Plain_text"] = 1890000,
["Module:Pn"] = 4800,
["Module:Political_party"] = 151000,
["Module:Political_party/A"] = 27000,
["Module:Political_party/B"] = 20000,
["Module:Political_party/C"] = 49000,
["Module:Political_party/D"] = 59000,
["Module:Political_party/E"] = 7000,
["Module:Political_party/F"] = 15000,
["Module:Political_party/G"] = 22000,
["Module:Political_party/H"] = 7600,
["Module:Political_party/I"] = 63000,
["Module:Political_party/J"] = 10000,
["Module:Political_party/K"] = 6400,
["Module:Political_party/L"] = 48000,
["Module:Political_party/M"] = 15000,
["Module:Political_party/N"] = 39000,
["Module:Political_party/O"] = 7100,
["Module:Political_party/P"] = 34000,
["Module:Political_party/R"] = 58000,
["Module:Political_party/S"] = 38000,
["Module:Political_party/T"] = 15000,
["Module:Political_party/U"] = 22000,
["Module:Political_party/V"] = 8000,
["Module:Political_party/W"] = 15000,
["Module:Political_party/Y"] = 2400,
["Module:Pop_density"] = 10000,
["Module:PopulationFromWikidata"] = 15000,
["Module:Portal"] = 11300000,
["Module:Portal-inline"] = 251000,
["Module:Portal/images/a"] = 2060000,
["Module:Portal/images/aliases"] = 361000,
["Module:Portal/images/b"] = 3580000,
["Module:Portal/images/c"] = 2330000,
["Module:Portal/images/d"] = 121000,
["Module:Portal/images/e"] = 599000,
["Module:Portal/images/f"] = 1020000,
["Module:Portal/images/g"] = 710000,
["Module:Portal/images/h"] = 551000,
["Module:Portal/images/i"] = 1300000,
["Module:Portal/images/j"] = 350000,
["Module:Portal/images/k"] = 89000,
["Module:Portal/images/l"] = 537000,
["Module:Portal/images/m"] = 776000,
["Module:Portal/images/n"] = 844000,
["Module:Portal/images/o"] = 465000,
["Module:Portal/images/other"] = 272000,
["Module:Portal/images/p"] = 987000,
["Module:Portal/images/q"] = 3300,
["Module:Portal/images/r"] = 443000,
["Module:Portal/images/s"] = 2010000,
["Module:Portal/images/t"] = 866000,
["Module:Portal/images/u"] = 1430000,
["Module:Portal/images/v"] = 350000,
["Module:Portal/images/w"] = 214000,
["Module:Portal/images/y"] = 39000,
["Module:Portal/images/z"] = 6500,
["Module:Portal/styles.css"] = 10800000,
["Module:Portal_bar"] = 207000,
["Module:Portal_bar/styles.css"] = 206000,
["Module:PrevalenceData"] = 8300,
["Module:Professional_wrestling_profiles"] = 3200,
["Module:Professional_wrestling_results_table"] = 3200,
["Module:Progress_box"] = 19000,
["Module:Progress_box/config"] = 19000,
["Module:Progress_box/styles.css"] = 19000,
["Module:Protect"] = 126000,
["Module:Protected_edit_request"] = 60000,
["Module:Protected_page"] = 75000,
["Module:Protected_page/config"] = 75000,
["Module:Protection_banner"] = 22000,
["Module:Purge"] = 594000,
}

Template:Infobox podcast

Minervaproject — Tue, 22 Sep 2026 17:56:43 GMT

← Older revision		Revision as of 19:56, 22 September 2026
Line 1:		Line 1:
	{{Main other\|{{~~Short description~~\|1=Podcast\|2=noreplace}}}}<!--		{{Main other\|{{Short_description\|1=Podcast\|2=noreplace}}}}<!--
	--->{{Infobox		--->{{Infobox
	\| italic title = {{{italic title\|{{{italic_title\|<noinclude>no</noinclude>}}}}}}		\| italic title = {{{italic title\|{{{italic_title\|<noinclude>no</noinclude>}}}}}}

Template:Short description

Minervaproject — Tue, 22 Sep 2026 17:51:09 GMT

← Older revision		Revision as of 19:51, 22 September 2026
Line 1:		Line 1:
	{{#ifeq:{{lc:{{{1\|}}}}}\|none\|{{SHORTDESC:\|{{{2\|}}}}}<nowiki/><!--Prevents whitespace issues when used with adjacent newlines-->\|<div class="shortdescription nomobile noexcerpt noprint searchaux" style="display:none">{{{1\|}}}{{SHORTDESC:{{{1\|}}}\|{{{2\|}}}}}</div>}}<includeonly>{{#ifeq:{{{pagetype}}}\|Disambiguation pages\|\|{{#ifeq:{{pagetype \|defaultns = all \|user=exclude}}\|exclude\|\|{{#ifeq:{{#switch: {{NAMESPACENUMBER}} \| 2 \| 3 \| 4 \| 5 \| 6 \| 7 \| 10 \| 11 \| 12 \| 13 \| 14 \| 15 \| 100 \| 101 \| 118 \| 119 \| 828 \| 829 \| = exclude\|#default=}}\|exclude\|\|[[Category:{{{pagetype\|{{pagetype \|defaultns = extended \|plural=y}}}}} with short description]]}}}}}}</includeonly><!-- Start tracking		{{#ifeq:{{lc:{{{1\|}}}}}\|none\|{{SHORTDESC:\|{{{2\|}}}}}<nowiki/><!--Prevents whitespace issues when used with adjacent newlines-->\|<div class="shortdescription nomobile noexcerpt noprint searchaux" style="display:none">{{{1\|}}}{{SHORTDESC:{{{1\|}}}\|{{{2\|}}}}}</div>}}<includeonly>{{#ifeq:{{{pagetype}}}\|Disambiguation pages\|\|{{#ifeq:{{pagetype \|defaultns = all \|user=exclude}}\|exclude\|\|{{#ifeq:{{#switch: {{NAMESPACENUMBER}} \| 2 \| 3 \| 4 \| 5 \| 6 \| 7 \| 10 \| 11 \| 12 \| 13 \| 14 \| 15 \| 100 \| 101 \| 118 \| 119 \| 828 \| 829 \| = exclude\|#default=}}\|exclude\|\|[[Category:{{{pagetype\|{{pagetype \|defaultns = extended \|plural=y}}}}} with short description]]}}}}}}</includeonly><!-- Start tracking
	-->{{#invoke:Check for unknown parameters\|check\|unknown={{Main other\|[[Category:Pages using short description with unknown parameters\|_VALUE_{{PAGENAME}}]]}}\|preview=Page using [[Template:Short description]] with unknown parameter "_VALUE_"\|ignoreblank=y\| 1 \| 2 \| pagetype \| bot \|plural }}<!---->{{#ifexpr: {{#invoke:~~Strong~~\|len\|{{{1\|}}}}}>100 \| [[Category:{{{pagetype\|{{pagetype \|defaultns = extended \|plural=y}}}}} with long short description]]}}<!----><includeonly>{{#if:{{{1\|}}}\|\|[[Category:Pages with empty short description]]}}</includeonly><!---->{{Short description/lowercasecheck\|{{{1\|}}}}}<!---->{{Main other \|{{SDcat \|sd={{{1\|}}} }} }}<noinclude>		-->{{#invoke:Check for unknown parameters\|check\|unknown={{Main other\|[[Category:Pages using short description with unknown parameters\|_VALUE_{{PAGENAME}}]]}}\|preview=Page using [[Template:Short description]] with unknown parameter "_VALUE_"\|ignoreblank=y\| 1 \| 2 \| pagetype \| bot \|plural }}<!--
			-->{{#ifexpr: {{#invoke:String\|len\|{{{1\|}}}}}>100 \| [[Category:{{{pagetype\|{{pagetype \|defaultns = extended \|plural=y}}}}} with long short description]]}}<!--
			--><includeonly>{{#if:{{{1\|}}}\|\|[[Category:Pages with empty short description]]}}</includeonly><!--
			-->{{Short description/lowercasecheck\|{{{1\|}}}}}<!--
			-->{{Main other \|{{SDcat \|sd={{{1\|}}} }} }}<noinclude>
	{{Documentation}}		{{Documentation}}
	</noinclude>		</noinclude>

Module:Submit an edit request/config/doc

Minervaproject — Tue, 22 Sep 2026 17:50:15 GMT

Created page with "{{used in system}} This module provides configuration data for Module:Submit an edit request. Please see the module comments for a description of what each message does. <includeonly>{{#ifeq:{{SUBPAGENAME}}|sandbox||  }}</includeonly>"

New page

{{used in system}}
This module provides configuration data for [[Module:Submit an edit request]]. Please see the module comments for a description of what each message does.

<includeonly>{{#ifeq:{{SUBPAGENAME}}|sandbox||


}}</includeonly>

Module:Submit an edit request/config

Minervaproject — Tue, 22 Sep 2026 17:49:49 GMT

Created page with "-- This module contains configuration data for Module:Submit an edit request. return { -------------------------------------------------------------------------------- -- Messages -------------------------------------------------------------------------------- -- The default display value for edit requests. ['default-display-value'] = 'Submit an edit request', -- The template that stores the edit request preload text ['preload-template'] = 'Template:Submit an edi..."

New page

-- This module contains configuration data for [[Module:Submit an edit request]].

return {

--------------------------------------------------------------------------------
-- Messages
--------------------------------------------------------------------------------

-- The default display value for edit requests.
['default-display-value'] = 'Submit an edit request',

-- The template that stores the edit request preload text
['preload-template'] = 'Template:Submit an edit request/preload',

-- The section heading that is generated when a user clicks on an edit request
-- link. $1 is the protection level text, e.g. "Semi-protected" or
-- "Template-protected". $2 is the current date, in the format specified by the
-- "preload-title-date-format" message.
['preload-title-text'] = '$1 edit request on $2',

-- The date format for the automatically-generated section heading. The format
-- must be valid input for the #time parser function.
['preload-title-date-format'] = 'j F Y',

-- What do do with the generated section header if another header with the same section already exists
-- $1 is the original section header. $2 is an automatically generated number, starting at 2 and increasing
-- by one until a unique header is found.
['preload-title-dedup-suffix'] = '$1 ($2)',

-- The names of pages (and their subpages) that make up the content of the main page for this wiki
['main-page-content'] = {
['Wikipedia:Today\'s featured article'] = true,
['Template:In the news'] = true,
['Template:Did you know'] = true,
['Wikipedia:Selected anniversaries'] = true,
['Template:POTD protected'] = true,
['Wikipedia:Today\'s featured list'] = true
},

-- The page used to request changes to things on the Main Page.
['main-page-request-page'] = 'Wikipedia:Main Page/Errors',

-- The page used to request edits to protected talk pages.
['protected-talk-page-request-page'] = 'Wikipedia:Requests for page protection/Edit',

-- The names of the templates to be used as wrappers for the "link" and "button"
-- functions. These are passed as arguments to the "wrappers" option of
-- [[Module:Arguments]].
['link-wrapper-template'] = 'Template:Submit an edit request/link',
['button-wrapper-template'] = 'Template:Submit an edit request',

--------------------------------------------------------------------------------
-- Protection level config
--------------------------------------------------------------------------------

protectionLevels = {

--[[
-- These settings are for the different protection levels which the module can
-- output edit request links for.
--
-- editintro:
-- The template to use as the edit intro users see when they click on an edit
-- request link.
--
-- request-template:
-- The name of the edit request template for that protection level. Do not
-- include the "Template:" text.
--
-- protectionlevel:
-- The name of the protection level, used for formatting the automatically-
-- generated section headings.
--]]

-- Semi-protection
semi = {
editintro = 'Template:Edit semi-protected/editintro',
requestTemplate = 'edit semi-protected',
levelText = 'Semi-protected',
},

-- Extended-confirmed-protection
extended = {
editintro = 'Template:Edit extended-protected/editintro',
requestTemplate = 'edit extended-protected',
levelText = 'Extended-confirmed-protected',
},

-- Template-protection
template = {
editintro = 'Template:Edit template-protected/editintro',
requestTemplate = 'edit template-protected',
levelText = 'Template-protected',
},

-- Full protection
full = {
editintro = 'Template:Edit fully-protected/editintro',
requestTemplate = 'edit fully-protected',
levelText = 'Protected',
},

-- Interface-protection
interface = {
editintro = 'Template:Edit interface-protected/editintro',
requestTemplate = 'edit interface-protected',
levelText = 'Interface-protected',
},

}

}

Module:Submit an edit request

Minervaproject — Tue, 22 Sep 2026 17:49:27 GMT

Created page with "-- This module implements {{Submit an edit request}}. local CONFIG_MODULE = 'Module:Submit an edit request/config' -- Load necessary modules local mRedirect = require('Module:Redirect') local cfg = mw.loadData(CONFIG_MODULE) local effectiveProtectionLevel = require('Module:Effective protection level')._main local escape = require("Module:String")._escapePattern local lang = mw.language.getContentLanguage() local p = {} local validLevels = { semi = 'semi', extended..."

New page

-- This module implements {{Submit an edit request}}.

local CONFIG_MODULE = 'Module:Submit an edit request/config'

-- Load necessary modules
local mRedirect = require('Module:Redirect')
local cfg = mw.loadData(CONFIG_MODULE)
local effectiveProtectionLevel = require('Module:Effective protection level')._main
local escape = require("Module:String")._escapePattern
local lang = mw.language.getContentLanguage()

local p = {}

local validLevels = {
semi = 'semi',
extended = 'extended',
template = 'template',
full = 'full',
interface = 'interface',
manual = 'manual'
}

local function message(key, ...)
local params = {...}
local msg = cfg[key]
if #params < 1 then
return msg
else
return mw.message.newRawMessage(msg):params(params):plain()
end
end

local function validateLevel(level)
return level and validLevels[level] or 'full'
end

local function getLevelInfo(level, field)
return cfg.protectionLevels[level][field]
end

local function resolveRedirect(page)
return mRedirect.luaMain(page)
end

local function isProtected(page)
local action = mw.title.new(page).exists and 'edit' or 'create'
return effectiveProtectionLevel(action, page) ~= '*'
end

function p.makeRequestUrl(level, titleObj)
titleObj = titleObj or mw.title.getCurrentTitle()
local basePage = titleObj.basePageTitle.fullText
if cfg['main-page-content'][basePage] then
return tostring(mw.uri.fullUrl(message('main-page-request-page')))
end

local talkPageName = titleObj.talkPageTitle
if talkPageName == nil then
return tostring(mw.uri.fullUrl(message('protected-talk-page-request-page')))
end
talkPageName = resolveRedirect(talkPageName.prefixedText)
if isProtected(talkPageName) then
return tostring(mw.uri.fullUrl(message('protected-talk-page-request-page')))
end
level = validateLevel(level)
if level == 'manual' then
return tostring(mw.uri.fullUrl(talkPageName, {
action = 'edit',
section = 'new'
}))
end
local sectionname = message(
'preload-title-text',
getLevelInfo(level, 'levelText'),
lang:formatDate(message('preload-title-date-format'))
)
local content = mw.title.new(talkPageName):getContent()
if content and content:find("== *" .. escape(sectionname) .. " *==") then
local dedup = 2
while true do
local newname = message("preload-title-dedup-suffix", sectionname, dedup)
if not content:find("== *" .. escape(newname) .. " *==") then
sectionname = newname
break
end
dedup = dedup + 1
end
end
local url = mw.uri.fullUrl(talkPageName, {
action = 'edit',
editintro = getLevelInfo(level, 'editintro'),
preload = message('preload-template'),
preloadtitle = sectionname,
section = 'new'
})
url = tostring(url)

-- Add the preload parameters. @TODO: merge this into the mw.uri.fullUrl
-- query table once [[phab:T93059]] is fixed.
local function encodeParam(key, val)
return string.format('&%s=%s', mw.uri.encode(key), mw.uri.encode(val))
end
url = url .. encodeParam('preloadparams[]', getLevelInfo(level, 'requestTemplate'))
url = url .. encodeParam('preloadparams[]', titleObj.prefixedText)

return url
end

function p._link(args)
return string.format(
'[%s %s]',
p.makeRequestUrl(args.type),
args.display or message('default-display-value')
)
end

function p._button(args)
return require('Module:Clickable button').main{
[1] = args.display or message('default-display-value'),
url = p.makeRequestUrl(args.type),
class = 'mw-ui-progressive'
}
end

local function makeInvokeFunc(func, wrapper)
return function (frame)
local args = require('Module:Arguments').getArgs(frame, {
wrappers = {wrapper}
})
return func(args)
end
end

p.link = makeInvokeFunc(p._link, message('link-wrapper-template'))
p.button = makeInvokeFunc(p._button, message('button-wrapper-template'))

return p

Module:SDcat

Minervaproject — Tue, 22 Sep 2026 17:48:41 GMT

Created page with "--SDcat Module to check whether local short description matches that on Wikidata -- local p = {} ------------------------------------------------------------------------------- -- setCat has the qid of a Wikidata entity passed as |qid= (it defaults to the associated qid of the current article if omitted) and the local short description passed as |sd= It returns a category if there is an associated Wikidata entity. It returns one of the following tracking categor..."

New page

--[[
SDcat
Module to check whether local short description matches that on Wikidata
--]]

local p = {}

-------------------------------------------------------------------------------
--[[
setCat has the qid of a Wikidata entity passed as |qid=
(it defaults to the associated qid of the current article if omitted)
and the local short description passed as |sd=
It returns a category if there is an associated Wikidata entity.
It returns one of the following tracking categories, as appropriate:
* Category:Short description matches Wikidata (case-insensitive)
* Category:Short description is different from Wikidata
* Category:Short description with empty Wikidata description
For testing purposes, a link prefix |lp= may be set to ":" to make the categories visible.
--]]

-- function exported for use in other modules
-- (local short description, Wikidata entity-ID, link prefix)
p._setCat = function(sdesc, itemID, lp)
if not mw.wikibase then return nil end
if itemID == "" then itemID = nil end
-- Wikidata description field
local wdesc = (mw.wikibase.getDescription(itemID) or ""):lower()
if wdesc == "" then
return "[[" .. lp .. "Category:Short description with empty Wikidata description]]"
elseif wdesc == sdesc then
return "[[" .. lp .. "Category:Short description matches Wikidata]]"
else
return "[[" .. lp .. "Category:Short description is different from Wikidata]]"
end
end

-- function exported for call from #invoke
p.setCat = function(frame)
local args
if frame.args.sd then
args = frame.args
else
args = frame:getParent().args
end
-- local short description
local sdesc = mw.text.trim(args.sd or ""):lower()
-- Wikidata entity-ID
local itemID = mw.text.trim(args.qid or "")
-- link prefix, strip quotes
local lp = mw.text.trim(args.lp or ""):gsub('"', '')
return p._setCat(sdesc, itemID, lp)
end

return p

Module:Transclusion count/data/S

Minervaproject — Tue, 22 Sep 2026 17:46:12 GMT

Created page with "return { ["S"] = 4300, ["S-aca"] = 6700, ["S-ach"] = 17000, ["S-aft"] = 230000, ["S-aft/check"] = 231000, ["S-aft/filter"] = 231000, ["S-bef"] = 235000, ["S-bef/check"] = 235000, ["S-bef/filter"] = 235000, ["S-break"] = 6600, ["S-bus"] = 2100, ["S-civ"] = 2900, ["S-dip"] = 6000, ["S-end"] = 262000, ["S-gov"] = 8600, ["S-hon"] = 4000, ["S-hou"] = 9800, ["S-inc"] = 13000, ["S-legal"] = 9900, ["S-line_label"] = 2000, ["S-mil"] = 13000, ["S-new"] = 17000, ["S-non"] = 11000,..."

New page

return {
["S"] = 4300,
["S-aca"] = 6700,
["S-ach"] = 17000,
["S-aft"] = 230000,
["S-aft/check"] = 231000,
["S-aft/filter"] = 231000,
["S-bef"] = 235000,
["S-bef/check"] = 235000,
["S-bef/filter"] = 235000,
["S-break"] = 6600,
["S-bus"] = 2100,
["S-civ"] = 2900,
["S-dip"] = 6000,
["S-end"] = 262000,
["S-gov"] = 8600,
["S-hon"] = 4000,
["S-hou"] = 9800,
["S-inc"] = 13000,
["S-legal"] = 9900,
["S-line_label"] = 2000,
["S-mil"] = 13000,
["S-new"] = 17000,
["S-non"] = 11000,
["S-npo"] = 4200,
["S-off"] = 43000,
["S-par"] = 52000,
["S-par/en"] = 3300,
["S-par/gb"] = 3300,
["S-par/uk"] = 12000,
["S-par/us-hs"] = 12000,
["S-par/us-sen"] = 2100,
["S-ppo"] = 15000,
["S-prec"] = 3200,
["S-reg"] = 22000,
["S-rel"] = 19000,
["S-roy"] = 2800,
["S-sports"] = 12000,
["S-start"] = 254000,
["S-ttl"] = 242000,
["S-ttl/check"] = 242000,
["S-vac"] = 7800,
["SAU"] = 2100,
["SCO"] = 3800,
["SDcat"] = 6830000,
["SECOND"] = 2300,
["SGP"] = 2900,
["SIA"] = 2500,
["SLL"] = 2000,
["SLO"] = 4900,
["SMS"] = 6900,
["SMU"] = 2500,
["SPI_archive_notice"] = 85000,
["SPIarchive_notice"] = 82000,
["SPIcat"] = 3800,
["SPIclose"] = 3300,
["SPIpriorcases"] = 78000,
["SR/Olympics_profile"] = 2200,
["SRB"] = 4400,
["SS"] = 22000,
["SSPa"] = 2600,
["STN"] = 11000,
["SUBJECTSPACE_formatted"] = 45000,
["SUI"] = 9700,
["SVG"] = 2600,
["SVG-Logo"] = 26000,
["SVG-Res"] = 24000,
["SVG-logo"] = 14000,
["SVK"] = 8800,
["SVN"] = 5900,
["SWE"] = 14000,
["Salts_by_element"] = 2300,
["Sandbox_other"] = 477000,
["Saturday"] = 2800,
["Saved_book"] = 52000,
["Sc"] = 2900,
["Scholia"] = 3700,
["School_block"] = 13000,
["School_disambiguation"] = 3500,
["Schoolblock"] = 6900,
["Schooldis"] = 2700,
["Schoolip"] = 12000,
["Scientist_icon"] = 16000,
["Scientist_icon2"] = 16000,
["Sclass"] = 34000,
["Sclass2"] = 11000,
["Screen_reader-only"] = 109000,
["Screen_reader-only/styles.css"] = 149000,
["Script"] = 7700,
["Script/Arabic"] = 4100,
["Script/Hebrew"] = 4900,
["Script/Nastaliq"] = 15000,
["Script/doc/id-unk"] = 3200,
["Script/doc/id-unk/core"] = 3200,
["Script/doc/id-unk/is-iso-alpha4"] = 3200,
["Script/doc/id-unk/name-to-alpha4"] = 3200,
["Script/styles.css"] = 3400,
["Script/styles_arabic.css"] = 4100,
["Script/styles_hebrew.css"] = 4900,
["Sdash"] = 4000,
["Search_box"] = 74000,
["Search_link"] = 27000,
["Section_link"] = 167000,
["Section_sizes"] = 4400,
["See"] = 8900,
["See_also"] = 219000,
["Seealso"] = 8100,
["Seiner_Majestät_Schiff"] = 6900,
["Seiner_Majestät_Unterseeboot"] = 2500,
["Select_skin"] = 5500,
["Selected"] = 2000,
["Selected_article"] = 2500,
["Selected_picture"] = 2400,
["Self"] = 45000,
["Self-published_inline"] = 4700,
["Self-published_source"] = 6100,
["Self-reference"] = 2200,
["Self-reference_tool"] = 8200,
["Semi-protected_indefinitely"] = 4800,
["Sent_off"] = 17000,
["Sentoff"] = 6300,
["Separated_entries"] = 2900,
["Sequence"] = 4100,
["Series_overview"] = 10000,
["Serif"] = 5000,
["Set_category"] = 38000,
["Set_index_article"] = 6400,
["Sets_taxobox_colour"] = 3300,
["Sfn"] = 211000,
["SfnRef"] = 166000,
["Sfn_whitelist"] = 2600,
["Sfnm"] = 6000,
["Sfnp"] = 24000,
["Sfnref"] = 19000,
["Sfrac"] = 5200,
["Sfrac/styles.css"] = 5200,
["SharedIPEDU"] = 3300,
["Shared_IP"] = 10000,
["Shared_IP_corp"] = 4100,
["Shared_IP_edu"] = 186000,
["Shared_IP_gov"] = 2300,
["Sharedip"] = 3000,
["Sharedipedu"] = 3800,
["Sherdog"] = 2700,
["Ship"] = 42000,
["Ship_index"] = 7600,
["Shipboxflag"] = 22000,
["Shipboxflag/core"] = 22000,
["Shipwrecks_navbox_footer"] = 11000,
["Shipwrecks_navbox_footer/link"] = 11000,
["Short_description"] = 6970000,
["Short_description/lowercasecheck"] = 6970000,
["Shortcut"] = 22000,
["Should_be_SVG"] = 7900,
["Shy"] = 2200,
["Sic"] = 39000,
["Side_box"] = 1250000,
["Sidebar"] = 320000,
["Sidebar_games_events"] = 43000,
["Sidebar_person"] = 4800,
["Sidebar_person/styles.css"] = 6300,
["Sidebar_with_collapsible_lists"] = 83000,
["Sigfig"] = 4000,
["Significant_figures"] = 5600,
["Significant_figures/rnd"] = 5300,
["Signpost-subscription"] = 2100,
["Signpost-subscription/styles.css"] = 2100,
["Signpost/item"] = 49000,
["Signpost/item/core"] = 49000,
["Signpost/snippet-nopic"] = 3400,
["Signpost/snippet/styles.css"] = 3700,
["Sildb_prim"] = 2200,
["Silver02"] = 18000,
["Silver2"] = 46000,
["Silver_medal"] = 6700,
["Silver_medal_icon"] = 60000,
["Similar_names"] = 3400,
["Single+double"] = 11000,
["Single+space"] = 17000,
["Single-innings_cricket_match"] = 4100,
["Single_chart"] = 43000,
["Single_namespace"] = 339000,
["Single_source"] = 3000,
["Singlechart"] = 12000,
["Singles"] = 49000,
["Sister-inline"] = 224000,
["Sister-inline/styles.css"] = 224000,
["Sister_project"] = 1130000,
["Sister_project/styles.css"] = 1130000,
["Sister_project_links"] = 14000,
["Skip_to_talk"] = 12000,
["Skip_to_talk/styles.css"] = 12000,
["Sky"] = 3300,
["Sky/styles.css"] = 3300,
["Slink"] = 65000,
["Slovak_municipality"] = 3000,
["Slovak_municipality/geo"] = 2800,
["Small"] = 653000,
["Small_Solar_System_bodies"] = 3600,
["Smallcaps"] = 22000,
["Smallcaps/styles.css"] = 23000,
["Smalldiv"] = 44000,
["Smaller"] = 79000,
["Smiley"] = 54000,
["Snd"] = 615000,
["Snds"] = 6500,
["Soccer_icon"] = 124000,
["Soccer_icon2"] = 124000,
["Soccer_icon4"] = 3500,
["Soccerbase"] = 13000,
["Soccerbase_season"] = 8100,
["Soccerway"] = 84000,
["Sock"] = 56000,
["Sock_list"] = 11000,
["Sockcat"] = 2000,
["Sockmaster"] = 10000,
["Sockpuppet"] = 287000,
["Sockpuppet/altmaster"] = 3700,
["Sockpuppet/categorise"] = 287000,
["SockpuppetCheckuser"] = 5500,
["Sockpuppet_category"] = 52000,
["Sockpuppet_category/confirmed"] = 28000,
["Sockpuppet_category/suspected"] = 24000,
["Sockpuppetcheckuser"] = 3600,
["Sockpuppeteer"] = 29000,
["Soft_hyphen"] = 2300,
["Soft_redirect"] = 6500,
["Soft_redirect_protection"] = 10000,
["Softredirect"] = 3300,
["Solar_luminosity"] = 5200,
["Solar_mass"] = 6600,
["Solar_radius"] = 5300,
["Soldier_icon"] = 3900,
["Soldier_icon2"] = 3900,
["Songs_category"] = 9600,
["Songs_category/core"] = 9600,
["Sort"] = 123000,
["Sort_under"] = 2200,
["Sort_under/styles.css"] = 2200,
["Sortname"] = 64000,
["Source-attribution"] = 9300,
["Source_assess"] = 2700,
["Source_assess_table"] = 2700,
["Source_attribution"] = 39000,
["Source_check"] = 927000,
["Sourcecheck"] = 927000,
["Sources"] = 3600,
["Sources_exist"] = 4400,
["South_America_topic"] = 2700,
["Sp"] = 165000,
["Space"] = 130000,
["Space+apostrophe+s"] = 27000,
["Space+double"] = 7300,
["Space+single"] = 15000,
["Spaced_en_dash"] = 649000,
["Spaced_en_dash_space"] = 6600,
["Spaced_ndash"] = 22000,
["Spaces"] = 737000,
["Spain_metadata_Wikidata"] = 7400,
["Spamlink"] = 14000,
["Species_Latin_name_abbreviation_disambiguation"] = 2400,
["Species_list"] = 25000,
["Speciesbox"] = 395000,
["Speciesbox/checkgenus"] = 393000,
["Speciesbox/getGenus"] = 396000,
["Speciesbox/getSpecies"] = 395000,
["Speciesbox/name"] = 395000,
["Speciesbox/parameterCheck"] = 395000,
["Speciesbox/trim"] = 395000,
["Specieslist"] = 9300,
["Split_article"] = 4200,
["Spnd"] = 4800,
["Spoken_Wikipedia"] = 2200,
["Sport_icon"] = 16000,
["Sport_icon2"] = 17000,
["SportsYearCatUSstate"] = 6700,
["Sports_club_or_team_people_category_header"] = 14000,
["Sports_club_or_team_people_category_header/category1"] = 14000,
["Sports_club_or_team_people_category_header/club_name"] = 14000,
["Sports_links"] = 82000,
["Sports_reference"] = 5100,
["Squad_maintenance"] = 3800,
["Sronly"] = 49000,
["Srt"] = 7300,
["Stack"] = 30000,
["Stack/styles.css"] = 42000,
["Stack_begin"] = 12000,
["Stack_end"] = 12000,
["StaleIP"] = 3600,
["StandardEbooks"] = 2500,
["Standings_table_end"] = 64000,
["Standings_table_entry"] = 25000,
["Standings_table_entry/record"] = 64000,
["Standings_table_start"] = 64000,
["Standings_table_start/colheader"] = 64000,
["Standings_table_start/colspan"] = 64000,
["Standings_table_start/styles.css"] = 64000,
["Starbox_astrometry"] = 5700,
["Starbox_begin"] = 5800,
["Starbox_catalog"] = 5700,
["Starbox_character"] = 5700,
["Starbox_detail"] = 5600,
["Starbox_end"] = 5800,
["Starbox_image"] = 4100,
["Starbox_observe"] = 5800,
["Starbox_reference"] = 5700,
["Start-Class"] = 18000,
["Start-date"] = 2300,
["Start_and_end_dates"] = 3800,
["Start_box"] = 5500,
["Start_date"] = 549000,
["Start_date_and_age"] = 189000,
["Start_date_and_years_ago"] = 4000,
["Start_date_text"] = 3900,
["Start_of_course_timeline"] = 5800,
["Start_of_course_week"] = 6000,
["Start_tab"] = 6700,
["Startflatlist"] = 163000,
["Startplainlist"] = 2300,
["Static_IP"] = 5000,
["Static_row_numbers"] = 2900,
["Static_row_numbers/styles.css"] = 2900,
["Station"] = 22000,
["Station_link"] = 19000,
["Stdinchicite"] = 10000,
["Steady"] = 20000,
["Sticky_header"] = 9800,
["Sticky_header/styles.css"] = 27000,
["Stl"] = 17000,
["Stn"] = 11000,
["Stn_art_lnk"] = 2200,
["Stnlnk"] = 35000,
["Stop"] = 2000,
["Store_norske_leksikon"] = 2500,
["Storm_colour"] = 5800,
["Storm_name"] = 2400,
["Storm_path"] = 2200,
["Stortingetbio"] = 2100,
["StoryTeleplay"] = 3200,
["Str_count"] = 166000,
["Str_endswith"] = 236000,
["Str_find"] = 283000,
["Str_index"] = 15000,
["Str_left"] = 316000,
["Str_len"] = 169000,
["Str_letter"] = 184000,
["Str_letter/trim"] = 21000,
["Str_number"] = 7200,
["Str_number/trim"] = 226000,
["Str_rep"] = 299000,
["Str_right"] = 7200,
["Str_startswith"] = 2900,
["Str_trim"] = 4200,
["Str_≠_len"] = 49000,
["Str_≤_len"] = 2900,
["Str_≥_len"] = 106000,
["Strfind_short"] = 5400,
["Strike"] = 2300,
["Strikethrough"] = 20000,
["String_split"] = 5400,
["Strip_tags"] = 41000,
["Strong"] = 217000,
["Structurae"] = 2100,
["Stub-Class"] = 18000,
["Stub_Category"] = 14000,
["Stub_category"] = 21000,
["Stub_documentation"] = 42000,
["Student_editor"] = 27000,
["Student_sandbox"] = 4300,
["Student_table_row"] = 7200,
["Students_table"] = 7200,
["Su"] = 4800,
["Su-census1989"] = 4600,
["Sub"] = 4600,
["Subinfobox_bodystyle"] = 75000,
["Subject_bar"] = 21000,
["Suboff"] = 7500,
["Subon"] = 7600,
["Subpage_other"] = 412000,
["Subscription_required"] = 35000,
["Subsidebar_bodystyle"] = 6400,
["Subst_only"] = 5500,
["Substituted_comment"] = 19000,
["Succession_box"] = 119000,
["Succession_box/check"] = 119000,
["Succession_links"] = 219000,
["Summer_Olympics_by_year_category_navigation"] = 2600,
["Summer_Olympics_by_year_category_navigation/core"] = 2600,
["Sunday"] = 2800,
["Sup"] = 95000,
["Suppress_categories"] = 6600,
["Surname"] = 81000,
["Swiss_metadata_Wikidata"] = 2900,
["Swiss_populations"] = 2400,
["Swiss_populations_NC"] = 3000,
["Swiss_populations_YM"] = 2300,
["Swiss_populations_ref"] = 2400,
["Switcher"] = 8500,
["Sz"] = 2500,
["Module:SDcat"] = 6830000,
["Module:SPI_archive_notice"] = 39000,
["Module:SST"] = 13000,
["Module:SST/hosts"] = 13000,
["Module:SST/registry"] = 276000,
["Module:SST/shards/sets/COLLEDGE_SHIPS_RN"] = 3000,
["Module:SST/shards/sets/TALBERT_BARRINGTON_ATLAS"] = 2100,
["Module:Science_redirect"] = 323000,
["Module:Science_redirect/conf"] = 323000,
["Module:Section_link"] = 167000,
["Module:Section_sizes"] = 6000,
["Module:See_also_if_exists"] = 96000,
["Module:Self"] = 45000,
["Module:Self/license_migration_data.json"] = 23000,
["Module:Self/styles.css"] = 45000,
["Module:Separated_entries"] = 2840000,
["Module:Series_overview"] = 10000,
["Module:Settlement_Wikidata"] = 52000,
["Module:Settlement_short_description"] = 729000,
["Module:Shortcut"] = 29000,
["Module:Shortcut/config"] = 29000,
["Module:Shortcut/styles.css"] = 29000,
["Module:Side_box"] = 1290000,
["Module:Side_box/styles.css"] = 1290000,
["Module:Sidebar"] = 436000,
["Module:Sidebar/configuration"] = 436000,
["Module:Sidebar/styles.css"] = 442000,
["Module:Sidebar_games_events"] = 43000,
["Module:Sidebar_games_events/styles.css"] = 43000,
["Module:Singles"] = 49000,
["Module:Sister_project_links"] = 22000,
["Module:Sister_project_links/bar/styles.css"] = 7300,
["Module:Sister_project_links/config"] = 22000,
["Module:Sister_project_links/styles.css"] = 14000,
["Module:Sister_project_logo"] = 1360000,
["Module:Sister_project_logo/data"] = 1360000,
["Module:Slovak_municipality"] = 3000,
["Module:Sock_list"] = 11000,
["Module:Sort"] = 156000,
["Module:Sort_title"] = 40000,
["Module:Sortkey"] = 105000,
["Module:Split_article"] = 4200,
["Module:Spoken_Wikipedia"] = 2200,
["Module:Spoken_Wikipedia/configuration"] = 2200,
["Module:Spoken_Wikipedia/styles.css"] = 2200,
["Module:Sports_career"] = 21000,
["Module:Sports_color"] = 79000,
["Module:Sports_color/baseball"] = 36000,
["Module:Sports_color/basketball"] = 19000,
["Module:Sports_color/ice_hockey"] = 3400,
["Module:Sports_color/international_football"] = 43000,
["Module:Sports_rbr_table"] = 15000,
["Module:Sports_rbr_table/styles.css"] = 15000,
["Module:Sports_reference"] = 5100,
["Module:Sports_results"] = 19000,
["Module:Sports_results/styles.css"] = 12000,
["Module:Sports_table"] = 74000,
["Module:Sports_table/Volleyball"] = 2500,
["Module:Sports_table/WDL"] = 64000,
["Module:Sports_table/WDL_OT"] = 4000,
["Module:Sports_table/WL"] = 5600,
["Module:Sports_table/WL_OT"] = 3100,
["Module:Sports_table/argcheck"] = 74000,
["Module:Sports_table/styles.css"] = 74000,
["Module:Sports_table/sub"] = 74000,
["Module:Sports_table/totalscheck"] = 53000,
["Module:Stock_tickers/NYSE"] = 2000,
["Module:Storm_categories"] = 5900,
["Module:Storm_categories/categories"] = 5900,
["Module:Storm_categories/colors"] = 5900,
["Module:Storm_categories/icons"] = 5900,
["Module:String"] = 14200000,
["Module:String2"] = 2090000,
["Module:Su"] = 14000,
["Module:Subject_bar"] = 21000,
["Module:Suppress_categories"] = 6600,
["Module:Switcher"] = 8500,
}

Module:Toolbar

Minervaproject — Tue, 22 Sep 2026 17:45:52 GMT

Created page with "-- This module implements {{toolbar}}. local mArguments -- Lazily initialise Module:Arguments local mTableTools = require('Module:TableTools') local yesno = require('Module:Yesno') local p = {} function p.main(frame) mArguments = require('Module:Arguments') local args = mArguments.getArgs(frame) return p._main(args) end function p._main(args) local toolbarItems = p.makeToolbarItems(args) if not toolbarItems then -- Return the blank string if no arguments w..."

New page

-- This module implements {{toolbar}}.

local mArguments -- Lazily initialise [[Module:Arguments]]
local mTableTools = require('Module:TableTools')
local yesno = require('Module:Yesno')

local p = {}

function p.main(frame)
mArguments = require('Module:Arguments')
local args = mArguments.getArgs(frame)
return p._main(args)
end

function p._main(args)
local toolbarItems = p.makeToolbarItems(args)
if not toolbarItems then
-- Return the blank string if no arguments were specified, rather than
-- returning empty brackets.
return ''
elseif yesno(args.span) == false then
return string.format(
'(%s)',
toolbarItems
)
else
return string.format(
'(%s)',
type(args.class) == 'string' and ' ' .. args.class or '',
type(args.style) == 'string' and string.format(' style="%s"', args.style) or '',
toolbarItems
)
end
end

function p.makeToolbarItems(args)
local nums = mTableTools.numKeys(args)
local sep = (args.separator or 'pipe') .. '-separator'
sep = mw.message.new(sep):plain()
local ret = {}
for i, v in ipairs(nums) do
ret[#ret + 1] = mw.ustring.gsub(args[v], "%[%[::+(.-)%]%]", "[[:%1]]")
end
if #ret > 0 then
return table.concat(ret, sep)
else
return nil
end
end

return p

Module:String/doc

Minervaproject — Tue, 22 Sep 2026 17:45:25 GMT

Created page with "{{Used in system}} {{Module rating|protected}} {{cascade-protected template|page=module}} {{Lmd|String}} This module is intended to provide access to basic string functions. Most of the functions provided here can be invoked with named parameters, unnamed parameters, or a mixture. If named parameters are used, Mediawiki will automatically remove any leading or trailing whitespace from the parameter. Depending on the intended use, it may be advantageous to either prese..."

New page

{{Used in system}}
{{Module rating|protected}}
{{cascade-protected template|page=module}}
{{Lmd|String}}

This module is intended to provide access to basic string functions.

Most of the functions provided here can be invoked with named parameters, unnamed parameters, or a mixture. If named parameters are used, Mediawiki will automatically remove any leading or trailing whitespace from the parameter. Depending on the intended use, it may be advantageous to either preserve or remove such whitespace.

== Global options ==

; ignore_errors
: If set to 'true' or 1, any error condition will result in an empty string being returned rather than an error message.
; error_category
: If an error occurs, specifies the name of a category to include with the error message. The default category is {{clc|Errors reported by Module String}}.
; no_category
: If set to 'true' or 1, no category will be added if an error is generated.

Unit tests for this module are available at [[Module:String/testcases]].

== Functions ==

=== count ===

Counts the number of times a given pattern appears in the arguments that get passed on to this module. Counts disjoint matches only.

Usage:
: <code><nowiki>{{#invoke:</nowiki>String|count|''source_str''|''pattern_string''|''plain_flag''<nowiki>}}</nowiki></code>

OR

: <code><nowiki>{{#invoke:</nowiki>String|count|source= ''source_string'' |pattern= ''pattern_string''|plain= ''plain_flag'' <nowiki>}}</nowiki></code>
Parameters:
; source_string
: The string to count occurrences in
; pattern
: The string or pattern to count occurrences of within source
; plain
: Boolean flag indicating that pattern should be understood as plain text and not as a [[mw:Extension:Scribunto/Lua reference manual#Ustring patterns|Scribunto ustring pattern]] (a unicode-friendly [[w:Lua|Lua]]-style [[w:regular expression|regular expression]]); defaults to true

Examples:
* Count of 'a': <code><nowiki>"{{#invoke:String|count|aabbcc|a}}"</nowiki></code> → "{{#invoke:String|count|aabbcc|a}}"
* Count occurrences of 'aba': <code><nowiki>"{{#invoke:String|count|ababababab|aba}}"</nowiki></code> → "{{#invoke:String|count|ababababab|aba}}"
* Count of "either 'a' or 'c' ":<code><nowiki>"{{#invoke:String|count|aabbcc|[ac]|plain=false}}"</nowiki></code> → "{{#invoke:String|count|aabbcc|[ac]|plain=false}}"
* Count of "not 'a' ": <code><nowiki>"{{#invoke:String|count|aaabaaac|[^a]|plain=false}}"</nowiki></code> → "{{#invoke:String|count|aaabaaac|[^a]|plain=false}}"
* Count of "starts with 'a' ": <code><nowiki>"{{#invoke:String|count|aaabaaac|^a|plain=false}}"</nowiki></code> → "{{#invoke:String|count|aaabaaac|^a|plain=false}}"

=== endswith ===

{{for|the startswith function|Module:String2#startswith}}
Usage:
: <code><nowiki>{{#invoke:</nowiki>String|endswith|''source_str''|''search_string''<nowiki>}}</nowiki></code>

OR

: <code><nowiki>{{#invoke:</nowiki>String|endswith|source= ''source_string'' |pattern= ''search_string''<nowiki>}}</nowiki></code>
Returns "yes" if the source string ends with the search string. Use named parameters to have the strings trimmed before use. Despite the parameter name, ''search_string'' is not a Lua pattern, it is interpreted literally.

* <code><nowiki>"{{#invoke:String|endswith|xxxyyy|y}}"</nowiki></code> → "{{#invoke:String|endswith|xxxyyy|y}}"
* <code><nowiki>"{{#invoke:String|endswith|xxxyyy|z}}"</nowiki></code> → "{{#invoke:String|endswith|xxxyyy|z}}"

=== escapePattern ===

In a [[:mw:LUAREF#Patterns|Lua pattern]], changes a ''class character'' into a ''literal character''. For example: in a pattern, character <code>.</code> catches "any character"; escapePattern will convert it to <code>%.</code>, catching just the literal character ".".

Usage:
* <code><nowiki>{{#invoke:String|escapePattern|</nowiki>''pattern_string''<nowiki>}}</nowiki></code>

Parameters:

; pattern_string
: The pattern string to escape

Examples:

* <code><nowiki>"{{#invoke:String|escapePattern|A.D.}}"</nowiki></code> → "{{#invoke:String|escapePattern|A.D.}}"
* <code><nowiki>"{{#invoke:String|escapePattern|10%}}"</nowiki></code> → "{{#invoke:String|escapePattern|10%}}"

=== find ===

This function allows one to search for a target string or pattern within another string.

Usage:

: <code><nowiki>{{#invoke:</nowiki>String|find|''source_string''|''target_string''|''start_index''|''plain_flag''<nowiki>}}</nowiki></code>

OR

: <code><nowiki>{{#invoke:</nowiki>String|find|source= ''source_string'' |target= ''target_string'' |start= ''start_index'' |plain= ''plain_flag'' <nowiki>}}</nowiki></code>

Parameters:

; source
: The string to search
; target
: The string or pattern to find within source
; start
: The index within the source string to start the search, defaults to 1
; plain
: Boolean flag indicating that target should be understood as plain text and not as a [[mw:Extension:Scribunto/Lua reference manual#Ustring patterns|Scribunto ustring pattern]] (a unicode-friendly [[w:Lua|Lua]]-style [[w:regular expression|regular expression]]); defaults to true

This function returns the first index >= "start" where "target" can be found within "source". Indices are 1-based. If "target" is not found, then this function returns 0. If either "source" or "target" are missing / empty, this function also returns 0.

This function should be safe for UTF-8 strings.

Examples:
* <code><nowiki>{{#invoke:String|find|abc123def|12}}</nowiki></code> → {{#invoke:String|find|abc123def|12}}
* <code><nowiki>{{#invoke:String|find|source=abc123def|target=12}}</nowiki></code> → {{#invoke:String|find|source=abc123def|target=12}}
* <code><nowiki>{{#invoke:String|find|source=abc123def|target=pqr}}</nowiki></code> → {{#invoke:String|find|source=abc123def|target=pqr}}
* <code><nowiki>{{#invoke:String|find| abc123def |123}}</nowiki></code> → {{#invoke:String|find| abc123def |123}}
* <code><nowiki>{{#invoke:String|find|source= abc123def |target= 123 }}</nowiki></code> → {{#invoke:String|find|source= abc123def |target= 123 }}
* <code><nowiki>{{#invoke:String|find|source=abc123def|target=%d |start=3 |plain=false }}</nowiki></code> → {{#invoke:String|find|source=abc123def|target=%d |start=3 |plain=false }}

When using unnamed parameters, preceding and trailing spaces are kept and counted:
* <code><nowiki>{{#invoke:String|find| abc123def |c|false}}</nowiki></code> → {{#invoke:String|find| abc123def |c|false}}
* <code><nowiki>{{#invoke:String|find|source= abc123def |target=c|plain=false}}</nowiki></code> → {{#invoke:String|find|source= abc123def |target=c|plain=false}}
* <code><nowiki>{{#invoke:string|find|abc 123 def|%s|plain=false}}</nowiki></code> → {{#invoke:string|find|abc 123 def|%s|plain=false}}

Testing for the presence of a string:
* <code>{{pf|ifexpr|<nowiki>{{#invoke:string|find|haystack|needle}}</nowiki>|Found needle|Didn't find needle}}</code> → {{#ifexpr:{{#invoke:string|find|haystack|needle}}|Found needle|Didn't find needle}}

=== findpagetext ===

The findpagetext function returns the position of a piece of text in the wikitext source of a page. It takes up to four parameters:
* First positional parameter or |text is the text to be searched for.
* Optional parameter |title is the page title, defaults to the current page.
* Optional parameter |plain is either true for a plain search (default), or false for a [[mw:Extension:Scribunto/Lua reference manual #Patterns|Lua pattern]] search.
* Optional parameter |nomatch is the value returned when no match is found; default is nothing.

; Examples
: <code><nowiki>{{#invoke:String |findpagetext |text=Youghiogheny}}</nowiki></code> → {{#invoke:String |findpagetext |text=Youghiogheny}}
: <code><nowiki>{{#invoke:String |findpagetext |text=Youghiogheny |nomatch=not found}}</nowiki></code> → {{#invoke:String |findpagetext |text=Youghiogheny |nomatch=not found}}
: <code><nowiki>{{#invoke:String |findpagetext |text=Youghiogheny |title=Boston Bridge |nomatch=not found}}</nowiki></code> → {{#invoke:String |findpagetext |text=Youghiogheny |title=Boston Bridge |nomatch=not found}}
: <code><nowiki>{{#invoke:String |findpagetext |text=river |title=Boston Bridge |nomatch=not found}}</nowiki></code> → {{#invoke:String |findpagetext |text=river |title=Boston Bridge |nomatch=not found}}
: <code><nowiki>{{#invoke:String |findpagetext |text=[Rr]iver |title=Boston Bridge |plain=false |nomatch=not found}}</nowiki></code> → {{#invoke:String |findpagetext |text=[Rr]iver |title=Boston Bridge |plain=false |nomatch=not found}}
: <code><nowiki>{{#invoke:String |findpagetext |text=%[%[ |title=Boston Bridge |plain=f |nomatch=not found}}</nowiki></code> → {{#invoke:String |findpagetext |text=%[%[ |title=Boston Bridge |plain=f |nomatch=not found}}
: <code><nowiki>{{#invoke:String |findpagetext |text=%{%{[Cc]oord |title=Boston Bridge |plain=f |nomatch=not found}}</nowiki></code> → {{#invoke:String |findpagetext |text=%{%{coord |title=Boston Bridge |plain=f |nomatch=not found}}
The search is case-sensitive, so Lua pattern matching is needed to find <code>river</code> or <code>River</code>. The last example finds <code><nowiki>{{coord</nowiki></code> and <code><nowiki>{{Coord</nowiki></code>. The penultimate example finds a wiki-link.

The [[Template:Findpagetext]] is a convenience wrapper for this function.

=== join ===

Joins all strings passed as arguments into one string, treating the first argument as a separator.

Usage:
: <code><nowiki>{{#invoke:</nowiki>String|join|''separator''|''string1''|''string2''|...<nowiki>}}</nowiki></code>
Parameters:
; separator
: String that separates each string being joined together
: Note that leading and trailing spaces are ''not'' stripped from the separator.
; string1/string2/...
: Strings being joined together
Examples:
* <code><nowiki>"{{#invoke:String|join|x|foo|bar|baz}}"</nowiki></code> → "{{#invoke:String|join|x|foo|bar|baz}}"
* <code><nowiki>"{{#invoke:String|join||a|b|c|d|e|f|g}}"</nowiki></code> → "{{#invoke:String|join||a|b|c|d|e|f|g}}"
* <code><nowiki>"{{#invoke:String|join|,|a|b|c|d|e|f|g}}"</nowiki></code> → "{{#invoke:String|join|,|a|b|c|d|e|f|g}}"
* <code><nowiki>"{{#invoke:String|join|, |a|b|c|d|e|f|g}}"</nowiki></code> → "{{#invoke:String|join|, |a|b|c|d|e|f|g}}"
* <code><nowiki>"{{#invoke:String|join| – |a|b|c|d|e|f|g}}"</nowiki></code> → "{{#invoke:String|join| – |a|b|c|d|e|f|g}}"
The preceding example uses the html entity &ndash; but the unicode character also works.

=== len ===

This function returns the length of the target string.

Usage:

: <code><nowiki>{{#invoke:</nowiki>String|len|''target_string''<nowiki>}}</nowiki></code>

OR

: <code><nowiki>{{#invoke:</nowiki>String|len|s= ''target_string'' <nowiki>}}</nowiki></code>

Parameters:

; s
: The string whose length to report

Examples:

* <code><nowiki>{{#invoke:String|len| abcdefghi }}</nowiki></code> → {{#invoke:String|len| abcdefghi }}
* <code><nowiki>{{#invoke:String|len|s= abcdefghi }}</nowiki></code> → {{#invoke:String|len|s= abcdefghi }}

=== match ===

This function returns a substring from the source string that matches a specified pattern.

Usage:

: <code><nowiki>{{#invoke:</nowiki>String|match|''source_string''|''pattern_string''|''start_index''|''match_number''|''plain_flag''|''nomatch_output''<nowiki>}}</nowiki></code>

OR

: <code><nowiki>{{#invoke:</nowiki>String|match|s= ''source_string'' |pattern= ''pattern_string'' |start= ''start_index'' |match= ''match_number'' |plain= ''plain_flag'' |nomatch= ''nomatch_output'' <nowiki>}}</nowiki></code>

Parameters:

; s
: The string to search
; pattern
: The pattern or string to find within the string
; start
: The index within the source string to start the search. The first character of the string has index 1. Defaults to 1.
; match
: In some cases it may be possible to make multiple matches on a single string. This specifies which match to return, where the first match is match= 1. If a negative number is specified then a match is returned counting from the last match. Hence match = -1 is the same as requesting the last match. Defaults to 1.
; plain
: Boolean flag indicating that pattern should be understood as plain text and not as a [[mw:Extension:Scribunto/Lua reference manual#Ustring patterns|Scribunto ustring pattern]] (a unicode-friendly [[w:Lua|Lua]]-style [[w:regular expression|regular expression]]). Defaults to false (to change: <code>plain=true</code>)
; nomatch
: If no match is found, output the "nomatch" value rather than an error.
; ignore_errors
: If no match is found and ignore_errors=true, output an empty string rather than an error.

If the match_number or start_index are out of range for the string being queried, then this function generates an error. An error is also generated if no match is found.
If one adds the parameter ignore_errors=true, then the error will be suppressed and an empty string will be returned on any failure.

For information on constructing [[w:Lua|Lua]] patterns, a form of [[w:regular expression|regular expression]], see:

* [[mw:Special:MyLanguage/Extension:Scribunto/Lua reference manual#Patterns|Scribunto patterns]]
* [[mw:Special:MyLanguage/Extension:Scribunto/Lua reference manual#Ustring patterns|Scribunto Unicode string patterns]]

Examples:
* <code><nowiki>{{#invoke:String|match| abc123def456 |%d+}}</nowiki></code> → {{#invoke:String|match| abc123def456 |%d+}}
* <code><nowiki>{{#invoke:String|match|s= abc123def456 |pattern= %d+ }}</nowiki></code> → {{#invoke:String|match|s= abc123def456 |pattern= %d+ }}
* <code><nowiki>{{#invoke:String|match| abc123def456 |%d+|6}}</nowiki></code> → {{#invoke:String|match| abc123def456 |%d+|6}}
* <code><nowiki>{{#invoke:String|match|s= abc123def456 |pattern= %d+ |start= 6 }}</nowiki></code> → {{#invoke:String|match|s= abc123def456 |pattern= %d+ |start= 6 }}
* <code><nowiki>{{#invoke:String|match|s= abc123def456 |pattern= %d+ |start= 6 |match= 2 }}</nowiki></code> → {{#invoke:String|match|s= abc123def456 |pattern= %d+ |start= 6 |match= 2 }}
* <code><nowiki>{{#invoke:String|match|s= abc123%d+ |pattern= %d+ }}</nowiki></code> → {{#invoke:String|match|s= abc123%d+ |pattern= %d+ }}
* <code><nowiki>{{#invoke:String|match|s= abc123%d+ |pattern= %d+ |plain= true }}</nowiki></code> → {{#invoke:String|match|s= abc123%d+ |pattern= %d+ |plain= true }}
* <code><nowiki>{{#invoke:String|match|s= abc |pattern= %d }}</nowiki></code> → {{#invoke:String|match|s= abc |pattern= %d |no_category=true}}
* <code><nowiki>{{#invoke:String|match|s= abc |pattern= %d |nomatch= No numeric characters in string }}</nowiki></code> → {{#invoke:String|match|s= abc |pattern= %d |nomatch= No numeric characters in string }}
* <code><nowiki>{{#invoke:String|match|s= abc |pattern= %d |ignore_errors= true }}</nowiki></code> → {{#invoke:String|match|s= abc |pattern= %d |ignore_errors= true }}
* <code><nowiki>{{#invoke:String|match|s= 0012001200 |pattern= 0*(%d*) }}</nowiki></code> → {{#invoke:String|match|s= 0012001200 |pattern= 0*(%d*) }}

=== pos ===

This function returns a single character from the target string at position pos.

Usage:

: <code><nowiki>{{#invoke:</nowiki>String|pos|''target_string''|''index_value''<nowiki>}}</nowiki></code>

OR

: <code><nowiki>{{#invoke:</nowiki>String|pos|target= ''target_string'' |pos= ''index_value'' <nowiki>}}</nowiki></code>

Parameters:

; target
: The string to search
; pos
: The index for the character to return

The first character has an index value of 1.

If one requests a negative value, this function will select a character by counting backwards
from the end of the string. In other words pos = -1 is the same as asking for the last character.

A requested value of zero, or a value greater than the length of the string returns an error.

Examples:

* <code><nowiki>{{#invoke:String|pos| abcdefghi | 4 }}</nowiki></code> → {{#invoke:String|pos| abcdefghi | 4 }}
* <code><nowiki>{{#invoke:String|pos|target= abcdefghi |pos= 4 }}</nowiki></code> → {{#invoke:String|pos|target= abcdefghi |pos= 4 }}

=== rep ===

Repeats a string ''n'' times. A simple function to pipe string.rep to templates.

Usage:

: <code><nowiki>{{#invoke:</nowiki>String|rep|''source''|''count''<nowiki>}}</nowiki></code>

Parameters:

; source
: The string to repeat
; count
: The number of repetitions.

Examples:

* <code><nowiki>"{{#invoke:String|rep|hello|3}}"</nowiki></code> → "{{#invoke:String|rep|hello|3}}"
* <code><nowiki>"{{#invoke:String|rep| hello | 3 }}"</nowiki></code> → "{{#invoke:String|rep| hello | 3 }}"

=== replace (gsub) ===

{{notice|text=Note that by default the pattern is understood as plain text as the {{var|plain flag}} {{nowrap|{{para|plain}}}} defaults to {{pval|true}}. To use a [[mw:Extension:Scribunto/Lua reference manual#Ustring patterns|Scribunto mw.ustring pattern]] you must set it to {{pval|false}}.}}

This function allows one to replace a target string or pattern within another string. To Lua programmers: this function works internally by calling <code>[[mw:Extension:Scribunto/Lua_reference_manual#mw.ustring.gsub|mw.ustring.gsub]]</code>.

Usage:

: <code><nowiki>{{#invoke:</nowiki>String|replace|''source_str''|''pattern_string''|''replace_string''|''replacement_count''|''plain_flag''<nowiki>}}</nowiki></code>

OR

: <code><nowiki>{{#invoke:</nowiki>String|replace|source= ''source_string'' |pattern= ''pattern_string'' |replace= ''replace_string'' |count= ''replacement_count'' |plain= ''plain_flag'' <nowiki>}}</nowiki></code>

Parameters:

; source
: The string to search
; pattern
: The string or pattern to find within source
; replace
: The replacement text
; count
: The number of occurrences to replace; defaults to all
; plain
: Boolean flag indicating whether the pattern should be understood as plain text or as a [[mw:Extension:Scribunto/Lua reference manual#Ustring patterns|Scribunto ustring pattern]] (a unicode-friendly [[w:Lua|Lua]]-style [[w:regular expression|regular expression]]). Defaults to <code>true</code>. Pass parameter {{para|plain|false}} to use regular expressions.

Examples:

* <code><nowiki>"{{#invoke:String|replace| abc123def456 |123|XYZ}}"</nowiki></code> → "{{#invoke:String|replace| abc123def456 |123|XYZ}}"
* <code><nowiki>"{{#invoke:String|replace|source= abc123def456 |pattern= 123 |replace= XYZ }}"</nowiki></code> → "{{#invoke:String|replace|source= abc123def456 |pattern= 123 |replace= XYZ }}"
* <code><nowiki>"{{#invoke:String|replace| abc123def456 |%d+|XYZ|1|false}}"</nowiki></code> → "{{#invoke:String|replace| abc123def456 |%d+|XYZ|1|false}}"
* <code><nowiki>"{{#invoke:String|replace|source= abc123def456 |pattern= %d+ |replace= XYZ |count=1 |plain= false }}"</nowiki></code> → "{{#invoke:String|replace|source= abc123def456 |pattern= %d+ |replace= XYZ |count=1 |plain= false }}"
* <code><nowiki>"{{#invoke:String|replace|source= abc123def456 |pattern= %d+ |replace= XYZ |plain= false }}"</nowiki></code> → "{{#invoke:String|replace|source= abc123def456 |pattern= %d+ |replace= XYZ |plain= false }}"
* <code><nowiki>{{#invoke:String|replace|source= 0012001200 |pattern= ^0* |plain= false }}</nowiki></code> → {{#invoke:String|replace|source= 0012001200 |pattern= ^0* |plain= false }}

=== str_find ===

This function duplicates the behavior of {{tl|str_find}}, including all of its quirks. This is provided in order to support existing templates, but is NOT RECOMMENDED for new code and templates. New code is recommended to use the "find" function instead.

Returns the first index in "source" that is a match to "target". Indexing is 1-based, and the function returns -1 if the "target" string is not present in "source".

Important Note: If the "target" string is empty / missing, this function returns a value of "1", which is generally unexpected behavior, and must be accounted for separately.

Usage:

: <code><nowiki>{{#invoke:</nowiki>String|str_find|''source_string''|''target_string''<nowiki>}}</nowiki></code>

OR

: <code><nowiki>{{#invoke:</nowiki>String|str_find|source= ''source_string'' |target= ''target_string'' <nowiki>}}</nowiki></code>

Parameters:

; source
: The string to search
; target
: The string to find within source

Examples:
* <code><nowiki>{{#invoke:String|str_find| abc123def }}</nowiki></code> → {{#invoke:String|str_find| abc123def }}
* <code><nowiki>{{#invoke:String|str_find|source= abc123def }}</nowiki></code> → {{#invoke:String|str_find|source= abc123def }}
* <code><nowiki>{{#invoke:String|str_find| abc123def |123}}</nowiki></code> → {{#invoke:String|str_find| abc123def |123}}
* <code><nowiki>{{#invoke:String|str_find|source= abc123def |target= 123 }}</nowiki></code> → {{#invoke:String|str_find|source= abc123def |target= 123 }}
* <code><nowiki>{{#invoke:String|str_find| abc123def |not}}</nowiki></code> → {{#invoke:String|str_find| abc123def |not}}

=== sub ===

This function returns a substring of the target string at specified inclusive, one-indexed indices.

Usage:

: <code><nowiki>{{#invoke:</nowiki>String|sub|''target_string''|''start_index''|''end_index''<nowiki>}}</nowiki></code>

OR

: <code><nowiki>{{#invoke:</nowiki>String|sub|s= ''target_string'' |i= ''start_index'' |j= ''end_index'' <nowiki>}}</nowiki></code>

Parameters:

; s
: The string to return a subset of
; i
: The first index of the substring to return, defaults to 1.
; j
: The last index of the string to return, defaults to the last character.

The first character of the string is assigned an index of 1. If either i or j is a negative value, it is interpreted the same as selecting a character by counting from the end of the string. Hence, a value of -1 is the same as selecting the last character of the string.

If the requested indices are out of range for the given string, an error is reported. To avoid error messages, use {{ml|ustring|sub}} instead.

Examples:

* <code><nowiki>"{{#invoke:String|sub| abcdefghi }}"</nowiki></code> → "{{#invoke:String|sub| abcdefghi }}"
* <code><nowiki>"{{#invoke:String|sub|s= abcdefghi }}"</nowiki></code> → "{{#invoke:String|sub|s= abcdefghi }}"
* <code><nowiki>"{{#invoke:String|sub| abcdefghi | 3 }}"</nowiki></code> → "{{#invoke:String|sub| abcdefghi | 3 }}"
* <code><nowiki>"{{#invoke:String|sub|s= abcdefghi |i= 3 }}"</nowiki></code> → "{{#invoke:String|sub|s= abcdefghi |i= 3 }}"
* <code><nowiki>"{{#invoke:String|sub| abcdefghi | 3 | 4 }}"</nowiki></code> → "{{#invoke:String|sub| abcdefghi | 3 | 4 }}"
* <code><nowiki>"{{#invoke:String|sub|s= abcdefghi |i= 3 |j= 4 }}"</nowiki></code> → "{{#invoke:String|sub|s= abcdefghi |i= 3 |j= 4 }}"

=== sublength ===

This function implements the features of {{tl|str sub old}} and is kept in order to maintain these older templates. It returns a substring of the target string starting at a specified index and of a specified length.

Usage:

: <code><nowiki>{{#invoke:</nowiki>String|sublength|s= ''target_string'' |i= ''start_index'' |len= ''length'' <nowiki>}}</nowiki></code>

Parameters:

; s
: The string
; i
: The starting index of the substring to return. The first character of the string is assigned an index of 0.
; len
: The length of the string to return, defaults to the last character.

Examples:

* <code><nowiki>{{#invoke:String|sublength|s= abcdefghi }}</nowiki></code> → {{#invoke:String|sublength|s= abcdefghi }}
* <code><nowiki>{{#invoke:String|sublength|s= abcdefghi |i= 3 }}</nowiki></code> → {{#invoke:String|sublength|s= abcdefghi |i= 3 }}
* <code><nowiki>{{#invoke:String|sublength|s= abcdefghi |i= 3 |len= 4 }}</nowiki></code> → {{#invoke:String|sublength|s= abcdefghi |i= 3 |len= 4 }}

== See also==
* {{mfl|MultiReplace|main}}

{{String handling templates}}
<includeonly>{{Sandbox other||
[[Category:Modules that add a tracking category]]
[[Category:Modules that manipulate strings|*]]
[[Category:Template metamodules]]
}}</includeonly>

Module:PageLinks

Minervaproject — Tue, 22 Sep 2026 17:44:53 GMT

Created page with "local ToolbarBuilder = require('Module:Toolbar') local p = {} -- Page object local trackingCategories = {} -- Table for storing the tracking categories. local demo -- Define a custom error message for this module. local function err(msg, section) local help if section then help = ' (help)' else help = '' end local cat if demo == 'yes' then cat = '' else cat = 'Category:PageLinks transclusions with errors' en..."

New page

local ToolbarBuilder = require('Module:Toolbar')

local p = {} -- Page object
local trackingCategories = {} -- Table for storing the tracking categories.
local demo

-- Define a custom error message for this module.
local function err(msg, section)
local help
if section then
help = ' ([[Template:Page-multi#' .. section .. '|help]])'
else
help = ''
end
local cat
if demo == 'yes' then
cat = ''
else
cat = '[[Category:PageLinks transclusions with errors]]'
end
return '[[Template:Page-multi|Page-multi]] error: ' .. msg
.. help .. '.' .. cat
end

----------------------------------------------------------------------------------------------
-- To add more link types, write a function that produces an individual link, and put --
-- it at the bottom of the list below. Then, add a link code for your function to the --
-- "linktypes" table. Try and make the code three letters or less.
--
-- If you want more helper strings, you can define them in the generatePageDataStrings --
-- function below. --
----------------------------------------------------------------------------------------------

----------------------------------------------------------------------------------------------
-- LINK FUNCTIONS START --
----------------------------------------------------------------------------------------------

local function makePageLink()
return p.fullText and '[[:' .. p.fullText .. '|' .. p.fullText .. ']]' or ''
end

local function makeTalkLink()
return '[[' .. tostring(p.talkPageTitle) .. '|talk]]'
end

local function makeTalkOrSubjectLink()
if p.isTalkPage then
return '[[:' .. tostring(p.subjectPageTitle) .. '|subject]]'
else
return '[[' .. tostring(p.talkPageTitle) .. '|talk]]'
end
end

local function makeWhatLinksHereLink()
return '[[Special:WhatLinksHere/' .. p.fullText .. '|links]]'
end

local function makeRelatedChangesLink()
return '[[Special:RelatedChanges/' .. p.fullText .. '|related]]'
end

local function makeEditLink()
return '[[Special:EditPage/' .. p.fullText .. '|edit]]'
end

local function makeHistoryLink()
return '[[Special:PageHistory/' .. p.fullText .. '|history]]'
end

local function makeWatchLink()
return '[' .. p:fullUrl( 'action=watch' ) .. ' watch]'
end

local function makeTargetLogsLink()
local url = mw.uri.fullUrl( 'Special:Log', 'page=' .. mw.uri.encode(p.fullText) )
return '[' .. tostring(url) .. ' logs]'
end

local function makeEditFilterLogLink()
local url = mw.uri.fullUrl( 'Special:AbuseLog', 'wpSearchTitle=' .. mw.uri.encode(p.fullText) )
return '[' .. tostring(url) .. ' abuse filter log]'
end

local function makePageViewsLink(args)
local endDate, startDate = "", ""

if args.date then
local date = string.gsub(args.date,"-","")
date = os.time{year=string.sub(date,1,4), month=string.sub(date,5,6), day=string.sub(date,7,8)}
endDate = os.date("%Y-%m-%d", date - (1*86400))
startDate = os.date("%Y-%m-%d", date - (30*86400))
else
endDate = os.date("%Y-%m-%d")
startDate = os.date("%Y-%m-%d", os.time() - (60*86400))
end

local project = string.sub(mw.site.server,3)
local url = mw.uri.encode(p.fullText, "WIKI")
local urlargs = '?start=' .. startDate .. '&end=' .. endDate .. '&project=' .. project .. '&pages=' .. tostring(url)

return '[https://pageviews.toolforge.org/' .. urlargs .. ' stats]'
end

local function makeHistory500Link()
local url = p:fullUrl( 'action=history&limit=500' );
return '[' .. url .. ' long history]'
end

----------------------------------------------------------------------------------------------
-- LINK FUNCTIONS END --
-- To enable new link functions, add the code to the "linktypes" table directly below. --
----------------------------------------------------------------------------------------------

local linktypes = {
t = makeTalkLink,
ts = makeTalkOrSubjectLink,
wlh = makeWhatLinksHereLink,
rc = makeRelatedChangesLink,
edit = makeEditLink,
h = makeHistoryLink,
w = makeWatchLink,
tl = makeTargetLogsLink,
efl = makeEditFilterLogLink,
['vlm-sgs'] = makePageViewsLink,
pv = makePageViewsLink,
h500 = makeHistory500Link,
}

local function getLink(linktype, args)
local func = linktypes[linktype]
if func then
return func(args)
else
return err('"' .. linktype .. '" is not a valid link code', 'Not a valid link code')
end
end

local function makeToolbar(args)
local targs = {}
local numArgsExist = false
for k, v in pairs(args) do
if type(k) == 'number' and p then
numArgsExist = true
targs[k] = getLink(v, args)
end
end
targs.style = args.small and 'font-size: 90%;'
targs.separator = args.separator or 'dot'
targs.class = 'lx'

if numArgsExist == false then
return nil -- Don't return a toolbar if no numeric arguments exist. -- this bit looks odd
else
return ToolbarBuilder.main(targs)
end
end

local function generatePageDataStrings(args)
-- If the page name is absent or blank, return an error and a tracking category.
if args.page == '' or not args.page then
return err('no page detected')
end
local noError
noError, p = pcall(mw.title.new, args.page)
if not noError then
return err('pcall mw.title failed')
end
if args.exists and (not p or p['id'] == 0) then
return err('page not found')
end
end

local function generateTrackingCategories()
if demo == 'yes' then
return ''
else
return table.concat(trackingCategories)
end
end

-- This function generates a table of all available link types, with their previews.
-- It is used in the module documentation.
local function getLinkTable(args)
demo = args.demo -- Set the demo variable.
-- Generate the page data strings and return any errors.
local dataStringError = generatePageDataStrings(args)
if dataStringError then
return dataStringError
end
-- Build a table of all of the links.
local header_row = mw.html.create('tr')
:tag('th'):wikitext('Code'):done()
:tag('th'):wikitext('Preview'):done()
local result = mw.html.create('table')
:addClass('wikitable'):addClass('plainlinks'):addClass('sortable')
:node(header_row)
for code, _ in pairs(linktypes) do
local row = mw.html.create('tr')
:tag('th'):wikitext(code):done()
:tag('td'):wikitext(getLink(code, args)):done()
result:node(row)
end
return tostring(result)
end

local function getSingleLink(args)
demo = args.demo -- Set the demo variable.
-- Generate the page data strings and return any errors.
local dataStringError = generatePageDataStrings(args)
if dataStringError then
return dataStringError
end

local linktype = args[1]
if not linktype then
return err('no link type specified')
end
local result = getLink(linktype, args)
result = result .. generateTrackingCategories()
return result
end

local function getLinksToolbar(args)
demo = args.demo -- Set the demo variable.
-- Generate the page data strings and return any errors.
local dataStringError = generatePageDataStrings(args)
if dataStringError then
return dataStringError
end

-- Build the template output.
local result = makeToolbar(args) -- Get the toolbar contents.
result = (result or '') .. generateTrackingCategories()
return result
end

local function getLinks(args)
local result = getLinksToolbar(args)

if result then
if args.sup then
result = '' .. result .. ''
end
result = ' ' .. result
else
result = '' -- If there are no links specified, don't return the toolbar at all.
end
if args.nopage then
result = '' .. result .. ''
else
if p then
result = '' .. makePageLink() .. result .. ''
else
result = '[[' .. args.page .. ']]' .. result .. ''
end
end

return result
end

local function getExampleLinks(args)
-- This function enables example output without having to specify any
-- parameters to #invoke.
args.demo = 'yes'
args.page = 'Example'
return getLinks(args)
end

local function makeWrapper(func)
return function (frame)
-- If called via #invoke, use the args passed into the invoking template.
-- Otherwise, for testing purposes, 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

-- Strip whitespace, and treat blank arguments as nil.
-- 'page', and 'separator' have different behaviour depending on
-- whether they are blank or nil, so keep them as they are.
local args = {}
for k, v in pairs(origArgs) do
v = mw.text.trim(v)
if v ~= '' or k == 'page' or k == 'separator' then
args[k] = v
end
end

return func(args)
end
end

return {
main = makeWrapper(getLinks),
single = makeWrapper(getSingleLink),
toolbar = makeWrapper(getLinksToolbar),
linktable = makeWrapper(getLinkTable),
example = makeWrapper(getExampleLinks)
}

Module:Namespace detect

Minervaproject — Tue, 22 Sep 2026 17:43:45 GMT

Created page with "-- -------------------------------------------------------------------------------- -- -- -- NAMESPACE DETECT -- -- -- -- This module implements the {{namespace detect}} template in Lua, with a -- -- few improvements: all namespaces and all namespace aliases are..."

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:Hatnote list

Minervaproject — Tue, 22 Sep 2026 17:43:26 GMT

Created page with "-------------------------------------------------------------------------------- -- 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}}, {{redirect}}, and their variants. Also introd..."

New page

--------------------------------------------------------------------------------
-- 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}}, {{redirect}}, and their variants. Also introduced --
-- are andList & orList helpers for formatting lists with those conjunctions. --
--------------------------------------------------------------------------------

local mArguments --initialize lazily
local mFormatLink = require('Module:Format link')
local mHatnote = require('Module:Hatnote')
local libraryUtil = require('libraryUtil')
local checkType = libraryUtil.checkType
local p = {}

--------------------------------------------------------------------------------
-- 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 = "and",
separator = ",",
altSeparator = ";",
space = " ",
formatted = false
}

--Searches display text only
local function searchDisp(haystack, needle)
return string.find(
string.sub(haystack, (string.find(haystack, '|') or 0) + 1), needle
)
end

-- 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 = mFormatLink.formatPages(
{categorizeMissing = mHatnote.missingTargetCat}, list
)
end
-- Set the separator; if any item contains it, use the alternate separator
local separator = options.separator
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 conjunction = s .. options.conjunction .. s
if #list == 2 and searchDisp(list[1], "§") or #list > 2 then
conjunction = separator .. conjunction
end
-- Return the formatted string
return mw.text.listToText(list, separator .. s, conjunction)
end

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

-- Stringifies lists with "and" or "or"
function p.andList (...) return p.conjList("and", ...) end
function p.orList (...) return p.conjList("or", ...) end

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

--default options table used across the forSee family of functions
local forSeeDefaultOptions = {
andKeyword = 'and',
title = mw.title.getCurrentTitle().text,
otherText = 'other uses',
forSeeForm = 'For %s, see %s.',
}

--Collapses duplicate punctuation at end of string, ignoring italics and links
local function punctuationCollapse (text)
return text:match("[.?!]('?)%1(%]?)%2%.$") and text:sub(1, -2) or text
end

-- Structures arguments into a table for stringification, & options
function p.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
-- If there is extra text, and no arguments are given, give nil value
-- to not produce default of "For other uses, see foo (disambiguation)"
if options.extratext and i > maxArg then return nil end
-- 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 p.forSeeTableToString (forSeeTable, options)
-- Type-checks and defaults
checkType("forSeeTableToString", 1, forSeeTable, "table", true)
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 = {}
if forSeeTable then
for k, v in pairs(forSeeTable) do
local useStr = v.use or options.otherText
local pagesStr =
p.andList(v.pages, true) or
mFormatLink._formatLink{
categorizeMissing = mHatnote.missingTargetCat,
link = mHatnote.disambiguate(options.title)
}
local forSeeStr = string.format(options.forSeeForm, useStr, pagesStr)
forSeeStr = punctuationCollapse(forSeeStr)
table.insert(strList, forSeeStr)
end
end
if options.extratext then table.insert(strList, punctuationCollapse(options.extratext..'.')) end
-- Return the concatenated list
return table.concat(strList, ' ')
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 p._forSee (args, from, options)
local forSeeTable = p.forSeeArgsToTable(args, from, options)
return p.forSeeTableToString(forSeeTable, options)
end

-- As _forSee, but uses the frame.
function p.forSee (frame, from, options)
mArguments = require('Module:Arguments')
return p._forSee(mArguments.getArgs(frame), from, options)
end

return p

Module:Format link

Minervaproject — Tue, 22 Sep 2026 17:43:06 GMT

Created page with "-------------------------------------------------------------------------------- -- 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. -------------------------------------------------------------------------------- local libraryUtil = require(..."

New page

--------------------------------------------------------------------------------
-- 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.
--------------------------------------------------------------------------------
local libraryUtil = require('libraryUtil')
local checkType = libraryUtil.checkType
local checkTypeForNamedArg = libraryUtil.checkTypeForNamedArg
local mArguments -- lazily initialise [[Module:Arguments]]
local mError -- lazily initialise [[Module:Error]]
local yesno -- lazily initialise [[Module:Yesno]]

local p = {}

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

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

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

local function maybeItalicize(s, shouldItalicize)
-- Italicize s if s is a string and the shouldItalicize parameter is true.
if s and shouldItalicize then
return '' .. s .. ''
else
return s
end
end

local function parseLink(link)
-- Parse a link and return a table with the link's components.
-- These components are:
-- - link: the link, stripped of any initial colon (always present)
-- - page: the page name (may be nil)
-- - section: the section name (may be nil)
-- - display: the display text, if manually entered after a pipe (may be nil)
link = removeInitialColon(link)

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

-- Find the page, if it exists.
-- For links like [[#Bar]], the page will be nil.
local preHash, postHash = link:match('^(.-)#(.*)$')
local page
if not preHash then
-- We have a link like [[Foo]].
page = link
elseif preHash ~= '' then
-- We have a link like [[Foo#Bar]].
page = preHash
end

-- Find the section, if it exists.
local section
if postHash and postHash ~= '' then
section = postHash
end

return {
link = link,
page = page,
section = section,
display = display,
}
end

local function formatDisplay(parsed, options)
-- Formats a display string based on a parsed link table (matching the
-- output of parseLink) and an options table (matching the input options for
-- _formatLink).
local page = maybeItalicize(parsed.page, options.italicizePage)
local section = maybeItalicize(parsed.section, options.italicizeSection)
if (not section) then
return page
elseif (not page) then
return mw.ustring.format('§ %s', section)
else
return mw.ustring.format('%s § %s', page, section)
end
end

local function missingArgError(target)
mError = require('Module:Error')
return mError.error{message =
'Error: no link or target specified! ([[' .. target .. '#Errors|help]])'
}
end

--------------------------------------------------------------------------------
-- Main functions
--------------------------------------------------------------------------------

function p.formatLink(frame)
-- The formatLink export function, for use in templates.
yesno = require('Module:Yesno')
local args = getArgs(frame)
local link = args[1] or args.link
local target = args[3] or args.target
if not (link or target) then
return missingArgError('Template:Format link')
end

return p._formatLink{
link = link,
display = args[2] or args.display,
target = target,
italicizePage = yesno(args.italicizepage),
italicizeSection = yesno(args.italicizesection),
categorizeMissing = args.categorizemissing
}
end

function p._formatLink(options)
-- The formatLink export function, for use in modules.
checkType('_formatLink', 1, options, 'table')
local function check(key, expectedType) --for brevity
checkTypeForNamedArg(
'_formatLink', key, options[key], expectedType or 'string', true
)
end
check('link')
check('display')
check('target')
check('italicizePage', 'boolean')
check('italicizeSection', 'boolean')
check('categorizeMissing')

-- Normalize link and target and check that at least one is present
if options.link == '' then options.link = nil end
if options.target == '' then options.target = nil end
if not (options.link or options.target) then
return missingArgError('Module:Format link')
end

local parsed = parseLink(options.link)
local display = options.display or parsed.display
local catMissing = options.categorizeMissing
local category = ''

-- Find the display text
if not display then display = formatDisplay(parsed, options) end

-- Handle the target option if present
if options.target then
local parsedTarget = parseLink(options.target)
parsed.link = parsedTarget.link
parsed.page = parsedTarget.page
end

-- Test if page exists if a diagnostic category is specified
if catMissing and (mw.ustring.len(catMissing) > 0) then
local title = nil
if parsed.page then title = mw.title.new(parsed.page) end
if title and (not title.isExternal) then
local success, exists = pcall(function() return title.exists end)
if success and not exists then
category = mw.ustring.format('[[Category:%s]]', catMissing)
end
end
end

-- Prepend colon if appropriate
local colon = parsed.page and ":" or ""

-- Format the result as a link
if parsed.link == display then
return mw.ustring.format('[[%s%s]]%s', colon, parsed.link, category)
else
return mw.ustring.format('[[%s%s|%s]]%s', colon, parsed.link, display, category)
end
end

--------------------------------------------------------------------------------
-- Derived convenience functions
--------------------------------------------------------------------------------

function p.formatPages(options, pages)
-- Formats an array of pages using formatLink and the given options table,
-- and returns it as an array. Nil values are not allowed.
local ret = {}
for i, page in ipairs(pages) do
ret[i] = p._formatLink{
link = page,
categorizeMissing = options.categorizeMissing,
italicizePage = options.italicizePage,
italicizeSection = options.italicizeSection
}
end
return ret
end

return p

Module:For

Minervaproject — Tue, 22 Sep 2026 17:42:47 GMT

Created page with "local mArguments --initialize lazily local mHatlist = require('Module:Hatnote list') local mHatnote = require('Module:Hatnote') local yesNo = require('Module:Yesno') local p = {} --Implements {{For}} from the frame --uses capitalized "For" to avoid collision with Lua reserved word "for" function p.For (frame) mArguments = require('Module:Arguments') return p._For(mArguments.getArgs(frame)) end --Implements {{For}} but takes a manual arguments table function p._For (a..."

New page

local mArguments --initialize lazily
local mHatlist = require('Module:Hatnote list')
local mHatnote = require('Module:Hatnote')
local yesNo = require('Module:Yesno')
local p = {}

--Implements {{For}} from the frame
--uses capitalized "For" to avoid collision with Lua reserved word "for"
function p.For (frame)
mArguments = require('Module:Arguments')
return p._For(mArguments.getArgs(frame))
end

--Implements {{For}} but takes a manual arguments table
function p._For (args)
local use = args[1]
if (not use) then
return mHatnote.makeWikitextError(
'no context parameter provided. Use {{other uses}} for "other uses" hatnotes.',
'Template:For#Errors',
args.category
)
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
local title = mw.title.getCurrentTitle()
local skipCat = title.isTalkPage or title.namespace == 2 --don't categorise talk pages and userspace
local oddCat = skipCat and '' or '[[Category:Hatnote templates using unusual parameters]]'
local category = yesNo(args.category)
return mHatnote._hatnote(
mHatlist.forSeeTableToString({{use = use, pages = pages}}),
{selfref = args.selfref}
) .. (
(use == 'other uses') and ((category == true) or (category == nil)) and
oddCat or ''
)
end

return p

Template:String handling templates

Minervaproject — Tue, 22 Sep 2026 17:42:26 GMT

Redirected page to Template:String-handling templates

New page

#redirect [[Template:String-handling templates]]

Template:String-handling templates

Minervaproject — Tue, 22 Sep 2026 17:42:06 GMT

Created page with "{{#invoke:Navbox with collapsible groups|navbox | name = String-handling templates | state = {{{state|expanded}}} | bodyclass = plainlist | title = String-handling templates (help page) | selected = {{{selected|{{{expanded|{{{1|}}}}}}}}}  | abbr1 = sub | sect1 = Substring (select chunk of string by its position) | content1 = {{Aligned table |fullwidth=on |style=text-align: left; |..."

New page

{{#invoke:Navbox with collapsible groups|navbox
| name = String-handling templates
| state = {{{state|expanded}}}
| bodyclass = plainlist
| title = String-handling templates [[Help:Manipulating_strings|(help page)]]
| selected = {{{selected|{{{expanded|{{{1|}}}}}}}}}


| abbr1 = sub
| sect1 = Substring (select chunk of string by its position)
| content1 = {{Aligned table |fullwidth=on |style=text-align: left; |col1width=50%;
| {{Aligned table |style=padding-right: 2em;
|col1style=width: 12em; text-align: right; padding-right: 0.75em;
| {{tl|str sub new}} | Select a substring based on starting and ending index counted in either direction.
| {{tl|str left}} | Keep the first N characters of a string, or duplicate it to N characters.
| {{tl|str crop}} | Return all but the last N characters of a string.
| {{tl|str index}} | Return the N-th character of a string.
}}
| {{Aligned table
|col1style=width: 12em; text-align: right; padding-right: 0.75em;
| {{tl|str right}} | Return substring starting at N-th character to end of string.
| {{tl|str rightc}} | Return the last N characters of a string; or a given value if empty.
| {{tl|str sub old}} | Return substring of given length starting at N-th character.
}} }}

| abbr2 = trim
| sect2 = Trimming (select/remove chunk of string by character type)
| content2 =
{{Aligned table |fullwidth=on |style=text-align: left; |col1width=50%;
| {{Aligned table |style=padding-right: 2em;
|col1style=width: 12em; text-align: right; padding-right: 0.75em;
| {{tl|trim}} | Trim any leading or trailing whitespace
| {{tl|str letter/trim}} | Trim down to the beginning letters.
| {{tl|str number/trim}} | Trim down to the beginning numbers.
| {{tl|trim brackets}} | Trim any leading or trailing square brackets.
| {{tl|trim quotes}} | Trim leading or trailing matching quotes.
| {{tl|trim leading}} | Trim up to six instances of specified <prefix>.
}}
| {{Aligned table
|col1style=width: 12em; text-align: right; padding-right: 0.75em;
| {{tl|string split}} | Extract a short string from a long string.
| {{tl|first word}} | Trim down to the first space.
| {{tl|remove first word}} | Remove anything before the first space.
| {{tl|last word}} | Trim down from the last space.
| {{tl|remove last word}} | Remove anything after the last space.
}} }}

| abbr3 = specific
| group3 = Select/remove specific item from string
| content3 =
{{Aligned table |fullwidth=on |style=text-align:left; |col1width=50%;
| {{Aligned table |style=padding-right: 2em;
|col1style=width: 12em; text-align: right; padding-right: 0.75em;
| {{tl|delink}}, {{tl|trim brackets}} | Removes wikilink brackets (wikicode); ''all'' or ''outer only''.
| {{tl|Plain text}} | Removes wikicode (formatting and brackets)
| {{tl|PAGENAMEBASE}} | Trim off any parenthesis text at the end of a string (disambiguation).
| {{tl|title disambig text}} | Returns text in parentheses at the end of a string (disambiguation).
}}
| {{Aligned table
|col1style=width: 12em; text-align: right; padding-right: 0.75em;
| {{tl|title year}} | Returns the 3-or-4-digit year from a pagename, if any.
| {{tl|title decade}} | Returns the 4-digit decade from a pagename (e.g. "1740" from "Foo 1740s bar"), if any.
| {{tl|title number}} | Returns any number from a pagename.
| {{tl|WikiProjectbasename}} | Removes "WikiProject" from a pagename.
}} }}


| abbr4 = IRL
| sect4 = Insertion, replacement, and length
| content4 =
{{Aligned table |style=margin: 0 auto 0; text-align: left;
| 
{{Aligned table |style=padding-right: 2em;
|col1style=text-align: right; padding-right: 0.75em;
| {{tl|loop}} | Repeat character string a specified number of times.
| {{tl|replace}} | Returns the string, after replacing ''all'' occurrences of a specified string with another string.
| {{tl|str rep}} | Returns the string, after replacing the first occurrence of a specified string with another string.
| {{tl|digits}} | Returns the string, after removing all characters that are not digits 0–9
| {{tl|Nowiki}} | Displays wikitext as plain text.
}}
| 
{{Aligned table
|col1style=text-align: right; padding-right: 0.75em;
| {{tl|str len}} | Returns a string's length.
| {{tl|str ≥ len}} | Check if a string is "longer or equally long" or "shorter" than a given length.
| {{tl|str ≤ len}} | Check if a string is "shorter or equally long" or "longer" than a given length.
| {{tl|str ≠ len}} | Check if a string is "not equal" or "equal" to a given length.
}} }}


| abbr5 = anlys/tech
| sect5 = Analysis and searching
| content5 =
{{Aligned table |style=margin: 0 auto 0; text-align: left;
| 
{{Aligned table |style=padding-right: 2em;
|col1style=text-align: right; padding-right: 0.75em;
| {{tl|str startswith}} {{tl|str endswith}} | Check if a string starts or ends with a given string.
| {{tl|str find}}, {{tl|strfind short}} |style2.2=vertical-align:middle;| Returns the numerical location of a given string in a string.
| {{tl|str count}} | Count the number of occurrences of a pattern within a string.
| {{tl|string count in page}} | Count the number of occurrences of a string within a given page's wikitext.
}}
| 
{{Aligned table
|col1style=text-align: right; padding-right: 0.75em;
| {{tl|Array}} | Array item manipulation and retrieval.
| {{tl|a or an}} | Takes a noun and produces the appropriate indefinite article, based on whether the first letter is a vowel.
| {{tl|in string}} | Returns optional string when given string is not found
| {{tl|Isnumeric}} | Returns number when true, blank when not numeric.
| {{tl|str letter}} | Returns the number of letters that begin a string.
| {{tl|str number}} | Returns the number of numbers that begin a string.
}} }}
|state1=<noinclude>expanded</noinclude>
|state2=<noinclude>expanded</noinclude>
|state3=<noinclude>expanded</noinclude>
|state4=<noinclude>expanded</noinclude>
|state5=<noinclude>expanded</noinclude>
|state6=expanded
|group6=Modules and built-in functions
|list6={{div col|style=text-align:left}}
* [[:Module:String]], [[:Module:String2]], [[:Module:Ustring]], [[Module:Text]], [[:Template:Navbox wikitext-handling templates|wikitext handling]]: modules that together contain most necessary string functions.
* [[mw:Help:Magic words|Magic words]]: About <code><nowiki>{{padleft:|}}</nowiki></code>, <code><nowiki>{{lc:|}}</nowiki></code>, <code><nowiki>{{formatnum:|}}</nowiki></code> etc.
* [[mw:Help:Extension:ParserFunctions|ParserFunctions]]: About <code><nowiki>{{#titleparts:|}}, {{#expr:|}}, {{#ifeq:|}}, </nowiki></code> etc.{{div col end}}

| belowclass = hlist
| below =
* [[:Category:String manipulation templates]]
** [[:c:Category:String manipulation templates|Commons]]
** [[:mw:Category:String manipulation templates|MediaWiki]]
** [[:m:Category:String manipulation templates|Meta-Wiki]]
** [[:d:Category:String manipulation templates|Wikidata]]
* [[:Category:Modules that manipulate strings]]
| tracking = no 

}}<noinclude>{{documentation}}</noinclude>

Template:Pf

Minervaproject — Tue, 22 Sep 2026 17:41:48 GMT

Redirected page to Template:ParserFunction

New page

#REDIRECT [[Template:ParserFunction]]

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