Messageboxes Export

<mediawiki xmlns="http://www.mediawiki.org/xml/export-0.10/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.mediawiki.org/xml/export-0.10/ http://www.mediawiki.org/xml/export-0.10.xsd" version="0.10" xml:lang="en">
  <siteinfo>
    <sitename>Wikipedia</sitename>
    <dbname>enwiki</dbname>
    <base>https://en.wikipedia.org/wiki/Main_Page</base>
    <generator>MediaWiki 1.38.0-wmf.21</generator>
    <case>first-letter</case>
    <namespaces>
      <namespace key="-2" case="first-letter">Media</namespace>
      <namespace key="-1" case="first-letter">Special</namespace>
      <namespace key="0" case="first-letter" />
      <namespace key="1" case="first-letter">Talk</namespace>
      <namespace key="2" case="first-letter">User</namespace>
      <namespace key="3" case="first-letter">User talk</namespace>
      <namespace key="4" case="first-letter">Wikipedia</namespace>
      <namespace key="5" case="first-letter">Wikipedia talk</namespace>
      <namespace key="6" case="first-letter">File</namespace>
      <namespace key="7" case="first-letter">File talk</namespace>
      <namespace key="8" case="first-letter">MediaWiki</namespace>
      <namespace key="9" case="first-letter">MediaWiki talk</namespace>
      <namespace key="10" case="first-letter">Template</namespace>
      <namespace key="11" case="first-letter">Template talk</namespace>
      <namespace key="12" case="first-letter">Help</namespace>
      <namespace key="13" case="first-letter">Help talk</namespace>
      <namespace key="14" case="first-letter">Category</namespace>
      <namespace key="15" case="first-letter">Category talk</namespace>
      <namespace key="100" case="first-letter">Portal</namespace>
      <namespace key="101" case="first-letter">Portal talk</namespace>
      <namespace key="118" case="first-letter">Draft</namespace>
      <namespace key="119" case="first-letter">Draft talk</namespace>
      <namespace key="710" case="first-letter">TimedText</namespace>
      <namespace key="711" case="first-letter">TimedText talk</namespace>
      <namespace key="828" case="first-letter">Module</namespace>
      <namespace key="829" case="first-letter">Module talk</namespace>
      <namespace key="2300" case="first-letter">Gadget</namespace>
      <namespace key="2301" case="first-letter">Gadget talk</namespace>
      <namespace key="2302" case="case-sensitive">Gadget definition</namespace>
      <namespace key="2303" case="case-sensitive">Gadget definition talk</namespace>
    </namespaces>
  </siteinfo>
  <page>
    <title>Module:Message box</title>
    <ns>828</ns>
    <id>40574910</id>
    <revision>
      <id>1027212344</id>
      <parentid>970994177</parentid>
      <timestamp>2021-06-06T18:51:34Z</timestamp>
      <contributor>
        <username>Izno</username>
        <id>2927383</id>
      </contributor>
      <comment>per tper</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="18348" xml:space="preserve">-- This is a meta-module for producing message box templates, including
-- {{mbox}}, {{ambox}}, {{imbox}}, {{tmbox}}, {{ombox}}, {{cmbox}} and {{fmbox}}.

-- Load necessary modules.
require('Module:No globals')
local getArgs
local yesno = require('Module:Yesno')

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

-- Define constants
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

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

    -- 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
    for _, class in ipairs(cfg.classes or {}) do
        self:addClass(class)
    end
    if self.isSmall then
        self:addClass(cfg.smallClass or 'mbox-small')
    end
    self:addClass(self.typeClass)
    self:addClass(args.class)
    self.style = args.style
    self.attrs = args.attrs

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

    -- Find if we are on the template page or not. This functionality is only
    -- used if useCollapsibleTextFields is set, or if both cfg.templateCategory
    -- and cfg.templateCategoryRequireName are set.
    self.useCollapsibleTextFields = cfg.useCollapsibleTextFields
    if self.useCollapsibleTextFields
        or cfg.templateCategory
        and cfg.templateCategoryRequireName
    then
        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)
                    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#%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(" &lt;span class='date-container'&gt;''(&lt;span class='date'&gt;%s&lt;/span&gt;)''&lt;/span&gt;", 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

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

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

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

    -- Right image settings.
    local imageRight = self.isSmall and args.smallimageright or args.imageright
    if not (cfg.imageRightNone and imageRight == 'none') then
        self.imageRight = imageRight
    end
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 &gt; 0 then
                templateCat = templateErrorCategory
                templateSort = tostring(count)
            end
            if self.categoryNums and #self.categoryNums &gt; 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: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 &lt;code&gt;%s[[Template:%s|%s]]%s&lt;/code&gt; has been incorrectly substituted.',
                mw.text.nowiki('{{'), self.name, self.name, mw.text.nowiki('}}')
            ))
    end

    -- Create the box table.
    local boxTable = root:tag('table')
    boxTable:attr('id', self.id 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'):css('width', '52px')
        end
        imageLeftCell: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')
            :cssText(self.imageEmptyCellStyle or nil)
    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'):css('width', '52px')
        end
        imageRightCell
            :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')
            :css('text-align', 'center')
            :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()
    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)</text>
      <sha1>kshc0gmfnt1xkzycgdb25urt4m770p1</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Message box/configuration</title>
    <ns>828</ns>
    <id>40627038</id>
    <revision>
      <id>948472514</id>
      <parentid>948472513</parentid>
      <timestamp>2020-04-01T06:12:44Z</timestamp>
      <contributor>
        <username>MusikAnimal</username>
        <id>14882394</id>
      </contributor>
      <minor/>
      <comment>1 revision imported</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="6141" xml:space="preserve">--------------------------------------------------------------------------------
--                          Message box configuration                         --
--                                                                            --
-- This module contains configuration data for [[Module:Message box]].        --
--------------------------------------------------------------------------------

return {
    ambox = {
        types = {
            speedy = {
                class = 'ambox-speedy',
                image = 'Ambox warning pn.svg'
            },
            delete = {
                class = 'ambox-delete',
                image = 'Ambox warning pn.svg'
            },
            content = {
                class = 'ambox-content',
                image = 'Ambox important.svg'
            },
            style = {
                class = 'ambox-style',
                image = 'Edit-clear.svg'
            },
            move = {
                class = 'ambox-move',
                image = 'Merge-split-transwiki default.svg'
            },
            protection = {
                class = 'ambox-protection',
                image = 'Semi-protection-shackle-keyhole.svg'
            },
            notice = {
                class = 'ambox-notice',
                image = 'Information icon4.svg'
            }
        },
        default                     = 'notice',
        allowBlankParams            = {'talk', 'sect', 'date', 'issue', 'fix', 'subst', 'hidden'},
        allowSmall                  = true,
        smallParam                  = 'left',
        smallClass                  = 'mbox-small-left',
        substCheck                  = true,
        classes                     = {'metadata', 'ambox'},
        imageEmptyCell              = true,
        imageCheckBlank             = true,
        imageSmallSize              = '20x20px',
        imageCellDiv                = true,
        useCollapsibleTextFields    = true,
        imageRightNone              = true,
        sectionDefault              = 'article',
        allowMainspaceCategories    = true,
        templateCategory            = 'Article message templates',
            templateCategoryRequireName = true,
        templateErrorCategory       = 'Article message templates with missing parameters',
        templateErrorParamsToCheck  = {'issue', 'fix', 'subst'},
        removalNotice               = '[[Help:Maintenance template removal|Learn how and when to remove this template message]]'
    },

    cmbox = {
        types = {
            speedy = {
                class = 'cmbox-speedy',
                image = 'Ambox warning pn.svg'
            },
            delete = {
                class = 'cmbox-delete',
                image = 'Ambox warning pn.svg'
            },
            content = {
                class = 'cmbox-content',
                image = 'Ambox important.svg'
            },
            style = {
                class = 'cmbox-style',
                image = 'Edit-clear.svg'
            },
            move = {
                class = 'cmbox-move',
                image = 'Merge-split-transwiki default.svg'
            },
            protection = {
                class = 'cmbox-protection',
                image = 'Semi-protection-shackle-keyhole.svg'
            },
            notice = {
                class = 'cmbox-notice',
                image = 'Information icon4.svg'
            }
        },
        default              = 'notice',
        showInvalidTypeError = true,
        classes              = {'cmbox'},
        imageEmptyCell       = true
    },

    fmbox = {
        types = {
            warning = {
                class = 'fmbox-warning',
                image = 'Ambox warning pn.svg'
            },
            editnotice = {
                class = 'fmbox-editnotice',
                image = 'Information icon4.svg'
            },
            system = {
                class = 'fmbox-system',
                image = 'Information icon4.svg'
            }
        },
        default              = 'system',
        showInvalidTypeError = true,
        classes              = {'fmbox'},
        imageEmptyCell       = false,
        imageRightNone       = false
    },

    imbox = {
        types = {
            speedy = {
                class = 'imbox-speedy',
                image = 'Ambox warning pn.svg'
            },
            delete = {
                class = 'imbox-delete',
                image = 'Ambox warning pn.svg'
            },
            content = {
                class = 'imbox-content',
                image = 'Ambox important.svg'
            },
            style = {
                class = 'imbox-style',
                image = 'Edit-clear.svg'
            },
            move = {
                class = 'imbox-move',
                image = 'Merge-split-transwiki default.svg'
            },
            protection = {
                class = 'imbox-protection',
                image = 'Semi-protection-shackle-keyhole.svg'
            },
            license = {
                class = 'imbox-license licensetpl',
                image = 'Imbox license.png' -- @todo We need an SVG version of this
            },
            featured = {
                class = 'imbox-featured',
                image = 'Cscr-featured.svg'
            },
            notice = {
                class = 'imbox-notice',
                image = 'Information icon4.svg'
            }
        },
        default              = 'notice',
        showInvalidTypeError = true,
        classes              = {'imbox'},
        imageEmptyCell       = true,
        below                = true,
        templateCategory     = 'File message boxes'
    },

    ombox = {
        types = {
            speedy = {
                class = 'ombox-speedy',
                image = 'Ambox warning pn.svg'
            },
            delete = {
                class = 'ombox-delete',
                image = 'Ambox warning pn.svg'
            },
            content = {
                class = 'ombox-content',
                image = 'Ambox important.svg'
            },
            style = {
                class = 'ombox-style',
                image = 'Edit-clear.svg'
            },
            move = {
                class = 'ombox-move',
                image = 'Merge-split-transwiki default.svg'
            },
            protection = {
                class = 'ombox-protection',
                image = 'Semi-protection-shackle-keyhole.svg'
            },
            notice = {
                class = 'ombox-notice',
                image = 'Information icon4.svg'
            }
        },
        default              = 'notice',
        showInvalidTypeError = true,
        classes              = {'ombox'},
        allowSmall           = true,
        imageEmptyCell       = true,
        imageRightNone       = true
    },

    tmbox = {
        types = {
            speedy = {
                class = 'tmbox-speedy',
                image = 'Ambox warning pn.svg'
            },
            delete = {
                class = 'tmbox-delete',
                image = 'Ambox warning pn.svg'
            },
            content = {
                class = 'tmbox-content',
                image = 'Ambox important.svg'
            },
            style = {
                class = 'tmbox-style',
                image = 'Edit-clear.svg'
            },
            move = {
                class = 'tmbox-move',
                image = 'Merge-split-transwiki default.svg'
            },
            protection = {
                class = 'tmbox-protection',
                image = 'Semi-protection-shackle-keyhole.svg'
            },
            notice = {
                class = 'tmbox-notice',
                image = 'Information icon4.svg'
            }
        },
        default              = 'notice',
        showInvalidTypeError = true,
        classes              = {'tmbox'},
        allowSmall           = true,
        imageRightNone       = true,
        imageEmptyCell       = true,
        imageEmptyCellStyle  = true,
        templateCategory     = 'Talk message boxes'
    }
}</text>
      <sha1>rz63o9789otb966y0k5pcntqf0bl6te</sha1>
    </revision>
  </page>
  <page>
    <title>Module:No globals</title>
    <ns>828</ns>
    <id>42567026</id>
    <revision>
      <id>948473889</id>
      <parentid>948472526</parentid>
      <timestamp>2020-04-01T06:28:55Z</timestamp>
      <contributor>
        <username>MusikAnimal</username>
        <id>14882394</id>
      </contributor>
      <comment>Undid revision 948472525 by [[Special:Contributions/w&gt;DiBabelYurikBot|w&gt;DiBabelYurikBot]] ([[User talk:w&gt;DiBabelYurikBot|talk]])</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="307" xml:space="preserve">local mt = getmetatable(_G) or {}
function mt.__index (t, k)
    if k ~= 'arg' then
        error('Tried to read nil global ' .. tostring(k), 2)
    end
    return nil
end
function mt.__newindex(t, k, v)
    if k ~= 'arg' then
        error('Tried to write global ' .. tostring(k), 2)
    end
    rawset(t, k, v)
end
setmetatable(_G, mt)</text>
      <sha1>gggsv54pq7f94l3up48hr91qtxnskdm</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Category handler</title>
    <ns>828</ns>
    <id>39772274</id>
    <revision>
      <id>948472489</id>
      <parentid>948472486</parentid>
      <timestamp>2020-04-01T06:12:40Z</timestamp>
      <contributor>
        <username>MusikAnimal</username>
        <id>14882394</id>
      </contributor>
      <minor/>
      <comment>1 revision imported</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="7871" xml:space="preserve">--------------------------------------------------------------------------------
--                                                                            --
--                              CATEGORY HANDLER                              --
--                                                                            --
--      This module implements the {{category handler}} template in Lua,      --
--      with a few improvements: all namespaces and all namespace aliases     --
--      are supported, and namespace names are detected automatically for     --
--      the local wiki. This module requires [[Module:Namespace detect]]      --
--      and [[Module:Yesno]] to be available on the local wiki. It can be     --
--      configured for different wikis by altering the values in              --
--      [[Module:Category handler/config]], and pages can be blacklisted      --
--      from categorisation by using [[Module:Category handler/blacklist]].   --
--                                                                            --
--------------------------------------------------------------------------------

-- Load required modules
local yesno = require('Module:Yesno')

-- Lazily load things we don't always need
local mShared, mappings

local p = {}

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

local function trimWhitespace(s, removeBlanks)
    if type(s) ~= 'string' then
        return s
    end
    s = s:match('^%s*(.-)%s*$')
    if removeBlanks then
        if s ~= '' then
            return s
        else
            return nil
        end
    else
        return s
    end
end

--------------------------------------------------------------------------------
-- CategoryHandler class
--------------------------------------------------------------------------------

local CategoryHandler = {}
CategoryHandler.__index = CategoryHandler

function CategoryHandler.new(data, args)
    local obj = setmetatable({ _data = data, _args = args }, CategoryHandler)

    -- Set the title object
    do
        local pagename = obj:parameter('demopage')
        local success, titleObj
        if pagename then
            success, titleObj = pcall(mw.title.new, pagename)
        end
        if success and titleObj then
            obj.title = titleObj
            if titleObj == mw.title.getCurrentTitle() then
                obj._usesCurrentTitle = true
            end
        else
            obj.title = mw.title.getCurrentTitle()
            obj._usesCurrentTitle = true
        end
    end

    -- Set suppression parameter values
    for _, key in ipairs{'nocat', 'categories'} do
        local value = obj:parameter(key)
        value = trimWhitespace(value, true)
        obj['_' .. key] = yesno(value)
    end
    do
        local subpage = obj:parameter('subpage')
        local category2 = obj:parameter('category2')
        if type(subpage) == 'string' then
            subpage = mw.ustring.lower(subpage)
        end
        if type(category2) == 'string' then
            subpage = mw.ustring.lower(category2)
        end
        obj._subpage = trimWhitespace(subpage, true)
        obj._category2 = trimWhitespace(category2) -- don't remove blank values
    end
    return obj
end

function CategoryHandler:parameter(key)
    local parameterNames = self._data.parameters[key]
    local pntype = type(parameterNames)
    if pntype == 'string' or pntype == 'number' then
        return self._args[parameterNames]
    elseif pntype == 'table' then
        for _, name in ipairs(parameterNames) do
            local value = self._args[name]
            if value ~= nil then
                return value
            end
        end
        return nil
    else
        error(string.format(
            'invalid config key "%s"',
            tostring(key)
        ), 2)
    end
end

function CategoryHandler:isSuppressedByArguments()
    return
        -- See if a category suppression argument has been set.
        self._nocat == true
        or self._categories == false
        or (
            self._category2
            and self._category2 ~= self._data.category2Yes
            and self._category2 ~= self._data.category2Negative
        )

        -- Check whether we are on a subpage, and see if categories are
        -- suppressed based on our subpage status.
        or self._subpage == self._data.subpageNo and self.title.isSubpage
        or self._subpage == self._data.subpageOnly and not self.title.isSubpage
end

function CategoryHandler:shouldSkipBlacklistCheck()
    -- Check whether the category suppression arguments indicate we
    -- should skip the blacklist check.
    return self._nocat == false
        or self._categories == true
        or self._category2 == self._data.category2Yes
end

function CategoryHandler:matchesBlacklist()
    if self._usesCurrentTitle then
        return self._data.currentTitleMatchesBlacklist
    else
        mShared = mShared or require('Module:Category handler/shared')
        return mShared.matchesBlacklist(
            self.title.prefixedText,
            mw.loadData('Module:Category handler/blacklist')
        )
    end
end

function CategoryHandler:isSuppressed()
    -- Find if categories are suppressed by either the arguments or by
    -- matching the blacklist.
    return self:isSuppressedByArguments()
        or not self:shouldSkipBlacklistCheck() and self:matchesBlacklist()
end

function CategoryHandler:getNamespaceParameters()
    if self._usesCurrentTitle then
        return self._data.currentTitleNamespaceParameters
    else
        if not mappings then
            mShared = mShared or require('Module:Category handler/shared')
            mappings = mShared.getParamMappings(true) -- gets mappings with mw.loadData
        end
        return mShared.getNamespaceParameters(
            self.title,
            mappings
        )
    end
end

function CategoryHandler:namespaceParametersExist()
    -- Find whether any namespace parameters have been specified.
    -- We use the order "all" --&gt; namespace params --&gt; "other" as this is what
    -- the old template did.
    if self:parameter('all') then
        return true
    end
    if not mappings then
        mShared = mShared or require('Module:Category handler/shared')
        mappings = mShared.getParamMappings(true) -- gets mappings with mw.loadData
    end
    for ns, params in pairs(mappings) do
        for i, param in ipairs(params) do
            if self._args[param] then
                return true
            end
        end
    end
    if self:parameter('other') then
        return true
    end
    return false
end

function CategoryHandler:getCategories()
    local params = self:getNamespaceParameters()
    local nsCategory
    for i, param in ipairs(params) do
        local value = self._args[param]
        if value ~= nil then
            nsCategory = value
            break
        end
    end
    if nsCategory ~= nil or self:namespaceParametersExist() then
        -- Namespace parameters exist - advanced usage.
        if nsCategory == nil then
            nsCategory = self:parameter('other')
        end
        local ret = {self:parameter('all')}
        local numParam = tonumber(nsCategory)
        if numParam and numParam &gt;= 1 and math.floor(numParam) == numParam then
            -- nsCategory is an integer
            ret[#ret + 1] = self._args[numParam]
        else
            ret[#ret + 1] = nsCategory
        end
        if #ret &lt; 1 then
            return nil
        else
            return table.concat(ret)
        end
    elseif self._data.defaultNamespaces[self.title.namespace] then
        -- Namespace parameters don't exist, simple usage.
        return self._args[1]
    end
    return nil
end

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

local p = {}

function p._exportClasses()
    -- Used for testing purposes.
    return {
        CategoryHandler = CategoryHandler
    }
end

function p._main(args, data)
    data = data or mw.loadData('Module:Category handler/data')
    local handler = CategoryHandler.new(data, args)
    if handler:isSuppressed() then
        return nil
    end
    return handler:getCategories()
end

function p.main(frame, data)
    data = data or mw.loadData('Module:Category handler/data')
    local args = require('Module:Arguments').getArgs(frame, {
        wrappers = data.wrappers,
        valueFunc = function (k, v)
            v = trimWhitespace(v)
            if type(k) == 'number' then
                if v ~= '' then
                    return v
                else
                    return nil
                end
            else
                return v
            end
        end
    })
    return p._main(args, data)
end

return p</text>
      <sha1>letwavu3yvlayfzew66uuwixmwebq5b</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Yesno</title>
    <ns>828</ns>
    <id>38665046</id>
    <revision>
      <id>948473803</id>
      <parentid>948472535</parentid>
      <timestamp>2020-04-01T06:27:55Z</timestamp>
      <contributor>
        <username>MusikAnimal</username>
        <id>14882394</id>
      </contributor>
      <comment>Undid revision 948472533 by [[Special:Contributions/w&gt;Vogone|w&gt;Vogone]] ([[User talk:w&gt;Vogone|talk]])</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="745" xml:space="preserve">-- Function allowing for consistent treatment of boolean-like wikitext input.
-- It works similarly to the template {{yesno}}.

return function (val, default)
    -- If your wiki uses non-ascii characters for any of "yes", "no", etc., you
    -- should replace "val:lower()" with "mw.ustring.lower(val)" in the
    -- following line.
    val = type(val) == 'string' and val:lower() or val
    if val == nil then
        return nil
    elseif val == true
        or val == 'yes'
        or val == 'y'
        or val == 'true'
        or val == 't'
        or val == 'on'
        or tonumber(val) == 1
    then
        return true
    elseif val == false
        or val == 'no'
        or val == 'n'
        or val == 'false'
        or val == 'f'
        or val == 'off'
        or tonumber(val) == 0
    then
        return false
    else
        return default
    end
end</text>
      <sha1>swdskn7svew8i9wuydn9uj5l3r2ghcs</sha1>
    </revision>
  </page>
  <page>
    <title>Template:Lua</title>
    <ns>10</ns>
    <id>38752725</id>
    <revision>
      <id>888711835</id>
      <parentid>886057621</parentid>
      <timestamp>2019-03-20T22:04:45Z</timestamp>
      <contributor>
        <username>RMCD bot</username>
        <id>17216044</id>
      </contributor>
      <comment>Removing notice of move discussion</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="196" xml:space="preserve">&lt;includeonly&gt;{{#invoke:Lua banner|main}}&lt;/includeonly&gt;&lt;noinclude&gt;
{{Lua|Module:Lua banner}}
{{documentation}}
&lt;!-- Categories go on the /doc subpage and interwikis go on Wikidata. --&gt;
&lt;/noinclude&gt;</text>
      <sha1>pnmjp3f3fl321yf2jpg5syebi412n7b</sha1>
    </revision>
  </page>
  <page>
    <title>Template:Module other</title>
    <ns>10</ns>
    <id>38821035</id>
    <revision>
      <id>1050945039</id>
      <parentid>929909970</parentid>
      <timestamp>2021-10-20T19:50:22Z</timestamp>
      <contributor>
        <username>MusikBot II</username>
        <id>29539620</id>
      </contributor>
      <minor/>
      <comment>Changed protection settings for "[[Template:Module other]]": [[Wikipedia:High-risk templates|High-risk template or module]]: 3570 transclusions ([[User:MusikBot II/TemplateProtector|more info]]) ([Edit=Require extended confirmed access] (indefinite) [Move=Require extended confirmed access] (indefinite))</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="414" xml:space="preserve">{{#switch:
  &lt;!--If no or empty "demospace" parameter then detect namespace--&gt;
  {{#if:{{{demospace|}}}
  | {{lc: {{{demospace}}} }}    &lt;!--Use lower case "demospace"--&gt;
  | {{#ifeq:{{NAMESPACE}}|{{ns:Module}}
    | module
    | other
    }}
  }}
| module = {{{1|}}}
| other
| #default = {{{2|}}}
}}&lt;!--End switch--&gt;&lt;noinclude&gt;

{{documentation}}
&lt;!-- Add categories to the /doc subpage, not here! --&gt;
&lt;/noinclude&gt;</text>
      <sha1>9db98vx09purrfch7wguurzjgqz7u93</sha1>
    </revision>
  </page>
  <page>
    <title>Template:Module rating</title>
    <ns>10</ns>
    <id>39134544</id>
    <revision>
      <id>1059797183</id>
      <parentid>986097640</parentid>
      <timestamp>2021-12-11T17:54:10Z</timestamp>
      <contributor>
        <username>Alexis Jazz</username>
        <id>2521907</id>
      </contributor>
      <comment>do not show protection level of the module on the doc page, use the second (and optionally third) parameter if the doc page is also protected</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="5531" xml:space="preserve">&lt;includeonly&gt;{{#ifeq:{{SUBPAGENAME}}|doc|&lt;!--do not show protection level of the module on the doc page, use the second and optionally third parameter if the doc page is also protected --&gt;{{#if:{{{2|}}}|{{Pp|{{{2}}}|action={{{3|}}}}}}}|{{Module other|{{ombox
 | type      = notice
 | image     = {{#switch: {{{1|}}}
   | pre-alpha | prealpha | pa = [[File:Ambox warning blue construction.svg|40x40px|link=|alt=Pre-alpha]]
   | alpha | a                 = [[File:Alpha lowercase.svg|26x26px|link=|alt=Alpha]]
   | beta | b                  = [[File:Greek lc beta.svg|40x40px|link=|alt=Beta]]
   | release | r | general | g = [[File:Green check.svg|40x40px|link=|alt=Ready for use]]
   | protected | protect | p   = [[File:{{#switch:{{#invoke:Effective protection level|edit|{{#switch:{{SUBPAGENAME}}|doc|sandbox={{FULLBASEPAGENAME}}|{{FULLPAGENAME}}}}}}|autoconfirmed=Semi|extendedconfirmed=Extended|accountcreator|templateeditor=Template|#default=Full}}-protection-shackle.svg|40x40px|link=|alt=Protected]]
   | semiprotected | semiprotect | semi =[[File:Semi-protection-shackle.svg|40x40px|link=|alt=Semi-protected]]
  }}
 | style     =
 | textstyle =
 | text      = {{#switch: {{{1|}}}
   | pre-alpha | prealpha | pa = This module is rated as [[:Category:Modules in pre-alpha development|pre-alpha]]. It is unfinished, and may or may not be in active development. It should not be used from article namespace pages. Modules remain pre-alpha until the original editor (or someone who takes one over if it is abandoned for some time) is satisfied with the basic structure.&lt;!--
   --&gt;{{#switch: {{SUBPAGENAME}}|doc|sandbox=&lt;!-- No category for /doc or /sandbox subpages --&gt;
       | {{#ifeq: {{{nocat|}}} | true | &lt;!-- No category if user sets nocat=true --&gt; | [[Category:Modules in pre-alpha development|{{PAGENAME}}]] }}
      }}
   | alpha | a                 = This module is rated as [[:Category:Modules in alpha|alpha]]. It is ready for third-party input, and may be used on a few pages to see if problems arise, but should be watched. Suggestions for new features or changes in their input and output mechanisms are welcome.&lt;!--
   --&gt;{{#switch: {{SUBPAGENAME}}|doc|sandbox=&lt;!-- No category for /doc or /sandbox subpages --&gt;
       | {{#ifeq: {{{nocat|}}} | true | &lt;!-- No category if user sets nocat=true --&gt; | [[Category:Modules in alpha|{{PAGENAME}}]] }}
      }}
   | beta | b                  = This module is rated as [[:Category:Modules in beta|beta]], and is ready for widespread use. It is still new and should be used with some caution to ensure the results are as expected.&lt;!--
   --&gt;{{#switch: {{SUBPAGENAME}}|doc|sandbox=&lt;!-- No category for /doc or /sandbox subpages --&gt;
       | {{#ifeq: {{{nocat|}}} | true | &lt;!-- No category if user sets nocat=true --&gt; | [[Category:Modules in beta|{{PAGENAME}}]] }}
      }}
   | release | r | general | g = This module is rated as [[:Category:Modules for general use|ready for general use]]. It has reached a mature form and is thought to be relatively bug-free and ready for use wherever appropriate. It is ready to mention on help pages and other Wikipedia resources as an option for new users to learn. To reduce server load and bad output, it should be improved by [[Wikipedia:Template sandbox and test cases|sandbox testing]] rather than repeated trial-and-error editing.&lt;!--
   --&gt;{{#switch: {{SUBPAGENAME}}|doc|sandbox=&lt;!-- No category for /doc or /sandbox subpages --&gt;
       | {{#ifeq: {{{nocat|}}} | true | &lt;!-- No category if user sets nocat=true --&gt; | [[Category:Modules for general use|{{PAGENAME}}]] }}
      }}
   | protected | protect | p   = This module is [[:Category:Modules subject to page protection|subject to page protection]]. It is a [[Wikipedia:High-risk templates|highly visible module]] in use by a very large number of pages, or is [[Wikipedia:Substitution|substituted]] very frequently. Because vandalism or mistakes would affect many pages, and even trivial editing might cause substantial load on the servers, it is [[Wikipedia:Protection policy|protected]] from editing.&lt;!--
   --&gt;{{#switch: {{SUBPAGENAME}}|doc|sandbox=&lt;!-- No category for /doc or /sandbox subpages --&gt;
       | {{#ifeq: {{{nocat|}}} | true | &lt;!-- No category if user sets nocat=true --&gt; | [[Category:Modules subject to page protection|{{PAGENAME}}]] }}
      }}
   | semiprotected | semiprotect | semi   = This module is [[:Category:Modules subject to page protection|subject to page protection]]. It is a [[Wikipedia:High-risk templates|highly visible module]] in use by a very large number of pages, or is [[Wikipedia:Substitution|substituted]] very frequently. Because vandalism or mistakes would affect many pages, and even trivial editing might cause substantial load on the servers, it is [[WP:SEMI|semi-protected]] from editing.&lt;!--
   --&gt;{{#switch: {{SUBPAGENAME}}|doc|sandbox=&lt;!-- No category for /doc or /sandbox subpages --&gt;
       | {{#ifeq: {{{nocat|}}} | true | &lt;!-- No category if user sets nocat=true --&gt; | [[Category:Modules subject to page protection|{{PAGENAME}}]] }}
      }}
   | #default                  = {{error|Module rating is invalid or not specified.}}
  }}
}}|{{error|Error: {{tl|Module rating}} must be placed in the Module namespace.}} [[Category:Pages with templates in the wrong namespace]]|demospace={{{demospace|&lt;noinclude&gt;module&lt;/noinclude&gt;}}}}}}}&lt;/includeonly&gt;&lt;noinclude&gt;
{{module rating|release|nocat=true|demospace=module}}
{{documentation}}
&lt;!-- Categories go on the /doc subpage, and interwikis go in Wikidata. --&gt;
&lt;/noinclude&gt;</text>
      <sha1>lxtrdpq6pzbeyc3gi5sruxh2ktsy58c</sha1>
    </revision>
  </page>
  <page>
    <title>Template:Ombox</title>
    <ns>10</ns>
    <id>17522403</id>
    <revision>
      <id>948472472</id>
      <parentid>948472468</parentid>
      <timestamp>2020-04-01T06:12:36Z</timestamp>
      <contributor>
        <username>MusikAnimal</username>
        <id>14882394</id>
      </contributor>
      <minor/>
      <comment>1 revision imported</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="146" xml:space="preserve">{{#invoke:Message box|ombox}}&lt;noinclude&gt;
{{documentation}}
&lt;!-- Categories go on the /doc subpage, and interwikis go on Wikidata. --&gt;
&lt;/noinclude&gt;</text>
      <sha1>1o93yrjvq6v2ylug2k0uaaltljurje2</sha1>
    </revision>
  </page>
  <page>
    <title>Template:Sandbox other</title>
    <ns>10</ns>
    <id>48540583</id>
    <revision>
      <id>948779760</id>
      <parentid>929909975</parentid>
      <timestamp>2020-04-03T00:08:09Z</timestamp>
      <contributor>
        <username>Evad37</username>
        <id>16958448</id>
      </contributor>
      <comment>Also match subpage names beginning with "sandbox", per [[Template_talk:Sandbox_other#Template-protected_edit_request_on_28_March_2020|edit request]]</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="260" xml:space="preserve">{{#if:{{#ifeq:{{#invoke:String|sublength|s={{SUBPAGENAME}}|i=0|len=7}}|sandbox|1}}{{#ifeq:{{SUBPAGENAME}}|doc|1}}{{#invoke:String|match|{{PAGENAME}}|/sandbox/styles.css$|plain=false|nomatch=}}|{{{1|}}}|{{{2|}}}}}&lt;!--
--&gt;&lt;noinclude&gt;{{documentation}}&lt;/noinclude&gt;</text>
      <sha1>h1idujwaw20aducxsd1gc4ovgnjikqa</sha1>
    </revision>
  </page>
  <page>
    <title>Template:Tag</title>
    <ns>10</ns>
    <id>7252577</id>
    <revision>
      <id>852104887</id>
      <parentid>848709005</parentid>
      <timestamp>2018-07-26T17:17:13Z</timestamp>
      <contributor>
        <username>SMcCandlish</username>
        <id>378390</id>
      </contributor>
      <comment>These are called attributes; no one who does HTML calls them "parameters".</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="835" xml:space="preserve">&lt;code class="{{#ifeq:{{{wrap|}}}|yes|wrap|nowrap}}" style="{{#ifeq:{{{style|}}}|plain|border:none;background:transparent;|{{{style|}}}}}"&gt;&lt;!--
 Opening tag
--&gt;{{#switch:{{{2|pair}}}
  |c|close =
  |e|empty|s|single|v|void
  |o|open
  |p|pair = &amp;lt;{{#if:{{{link|}}}|[[HTML element#{{{1|tag}}}|{{{1|tag}}}]]|{{{1|tag}}}}}{{#if:{{{params|{{{attribs|}}}}}}|&amp;#32;{{{params|{{{attribs}}}}}}}}
 }}&lt;!--
 Content between tags
--&gt;{{#switch:{{{2|pair}}}
  |c|close = {{{content|}}}
  |e|empty|s|single|v|void = &amp;#32;&amp;#47;&amp;gt;
  |o|open = &amp;gt;{{{content|}}}
  |p|pair = {{#ifeq:{{{1|tag}}}|!--||&amp;gt;}}{{{content|...}}}
 }}&lt;!--
 Closing tag
--&gt;{{#switch:{{{2|pair}}}
  |e|empty|s|single|v|void
  |o|open =
  |c|close
  |p|pair = {{#ifeq:{{{1|tag}}}|!--|--&amp;gt;|&amp;lt;&amp;#47;{{{1|tag}}}&amp;gt;}}
 }}&lt;!--
--&gt;&lt;/code&gt;&lt;noinclude&gt;
{{Documentation}}
&lt;/noinclude&gt;</text>
      <sha1>rfqa950ndrmgt6ozaa81dwgyr2n28ea</sha1>
    </revision>
  </page>
  <page>
    <title>Template:Template link</title>
    <ns>10</ns>
    <id>1487430</id>
    <revision>
      <id>1014201710</id>
      <parentid>1012903429</parentid>
      <timestamp>2021-03-25T19:03:22Z</timestamp>
      <contributor>
        <username>Izno</username>
        <id>2927383</id>
      </contributor>
      <comment>[[Wikipedia:Templates for discussion/Log/2021 March 18#Template:Tlu]] closed as keep ([[WP:XFDC#4.0.11|XFDcloser]])</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="167" xml:space="preserve">&amp;#123;&amp;#123;[[Template:{{{1}}}|{{{1}}}]]&amp;#125;&amp;#125;&lt;noinclude&gt;{{documentation}}
&lt;!-- Categories go on the /doc subpage and interwikis go on Wikidata. --&gt;
&lt;/noinclude&gt;</text>
      <sha1>rf3qx5cilaxlnjqq9fivevkah92ncil</sha1>
    </revision>
  </page>
  <page>
    <title>Template:Tl</title>
    <ns>10</ns>
    <id>66733012</id>
    <redirect title="Template:Template link" />
    <revision>
      <id>1006436965</id>
      <timestamp>2021-02-12T22:03:00Z</timestamp>
      <contributor>
        <username>Anthony Appleyard</username>
        <id>119438</id>
      </contributor>
      <comment>Anthony Appleyard moved page [[Template:Tl]] to [[Template:Template link]]: [[Special:Permalink/1006428669|Requested]] by Buidhe at [[WP:RM/TR]]: RM closed as move</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="83" xml:space="preserve">#REDIRECT [[Template:Template link]]

{{Redirect category shell|
{{R from move}}
}}</text>
      <sha1>p1dn3i2ckb7gtckkrbn0xh6ckx8nei1</sha1>
    </revision>
  </page>
  <page>
    <title>Template:Used in system</title>
    <ns>10</ns>
    <id>22491619</id>
    <revision>
      <id>1046926249</id>
      <parentid>1036596609</parentid>
      <timestamp>2021-09-28T03:41:32Z</timestamp>
      <contributor>
        <username>MusikBot II</username>
        <id>29539620</id>
      </contributor>
      <minor/>
      <comment>Protected "[[Template:Used in system]]": [[Wikipedia:High-risk templates|High-risk template or module]]: 428 transclusions ([[User:MusikBot II/TemplateProtector|more info]]) ([Edit=Require autoconfirmed or confirmed access] (indefinite))</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="235" xml:space="preserve">{{#invoke:High-use|main|1=|2={{{2|}}}|system={{#if:{{{1|}}}|{{{1}}}|in system messages}}&lt;noinclude&gt;|nocat=true&lt;/noinclude&gt;}}&lt;noinclude&gt;
{{documentation}}&lt;!-- Add categories and interwikis to the /doc subpage, not here! --&gt;
&lt;/noinclude&gt;</text>
      <sha1>196bkrax8m9r9spo90sxgyczdyxm0j6</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Arguments</title>
    <ns>828</ns>
    <id>41298065</id>
    <revision>
      <id>948472485</id>
      <parentid>948472482</parentid>
      <timestamp>2020-04-01T06:12:40Z</timestamp>
      <contributor>
        <username>MusikAnimal</username>
        <id>14882394</id>
      </contributor>
      <minor/>
      <comment>1 revision imported</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="10054" xml:space="preserve">-- This module provides easy processing of arguments passed to Scribunto from
-- #invoke. It is intended for use by other Lua modules, and should not be
-- called from #invoke directly.

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

local arguments = {}

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

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

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

local function tidyValRemoveBlanksOnly(key, val)
    if type(val) == 'string' then
        if val:find('%S') then
            return val
        else
            return nil
        end
    else
        return val
    end
end

local function tidyValNoChange(key, val)
    return val
end

local function matchesTitle(given, title)
    local tp = type( given )
    return (tp == 'string' or tp == 'number') and mw.title.new( given ).prefixedText == title
end

local translate_mt = { __index = function(t, k) return k end }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return args
end

return arguments</text>
      <sha1>5qx9tzlul9ser30uxj9nbasjt92cevn</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Documentation</title>
    <ns>828</ns>
    <id>40256557</id>
    <revision>
      <id>1065934020</id>
      <parentid>1061447122</parentid>
      <timestamp>2022-01-16T01:32:10Z</timestamp>
      <contributor>
        <username>Matt Fitzpatrick</username>
        <id>291848</id>
      </contributor>
      <comment>sync from sandbox, add aria role and label to container</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="35027" xml:space="preserve">-- 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

----------------------------------------------------------------------------
-- Helper functions
--
-- These are defined as local functions, but are made available in the p
-- table for testing purposes.
----------------------------------------------------------------------------

local function message(cfgKey, valArray, expectType)
    --[[
    -- Gets a message from the cfg table and formats it if appropriate.
    -- The function raises an error if the value from the cfg table is not
    -- of the type expectType. The default type for expectType is 'string'.
    -- If the table valArray is present, strings such as $1, $2 etc. in the
    -- message are substituted with values from the table keys [1], [2] etc.
    -- For example, if the message "foo-message" had the value 'Foo $2 bar $1.',
    -- message('foo-message', {'baz', 'qux'}) would return "Foo qux bar baz."
    --]]
    local msg = cfg[cfgKey]
    expectType = expectType or 'string'
    if type(msg) ~= expectType then
        error('message: type error in message cfg.' .. cfgKey .. ' (' .. expectType .. ' expected, got ' .. type(msg) .. ')', 2)
    end
    if not valArray then
        return msg
    end

    local function getMessageVal(match)
        match = tonumber(match)
        return valArray[match] or error('message: no value found for key $' .. match .. ' in message cfg.' .. cfgKey, 4)
    end

    return ugsub(msg, '$([1-9][0-9]*)', getMessageVal)
end

p.message = message

local function makeWikilink(page, display)
    if display then
        return mw.ustring.format('[[%s|%s]]', page, display)
    else
        return mw.ustring.format('[[%s]]', page)
    end
end

p.makeWikilink = makeWikilink

local function makeCategoryLink(cat, sort)
    local catns = mw.site.namespaces[14].name
    return makeWikilink(catns .. ':' .. cat, sort)
end

p.makeCategoryLink = makeCategoryLink

local function makeUrlLink(url, display)
    return mw.ustring.format('[%s %s]', url, display)
end

p.makeUrlLink = makeUrlLink

local function makeToolbar(...)
    local ret = {}
    local lim = select('#', ...)
    if lim &lt; 1 then
        return nil
    end
    for i = 1, lim do
        ret[#ret + 1] = select(i, ...)
    end
    -- 'documentation-toolbar'
    return '&lt;span class="' .. message('toolbar-class') .. '"&gt;('
        .. table.concat(ret, ' &amp;#124; ') .. ')&lt;/span&gt;'
end

p.makeToolbar = makeToolbar

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

local function makeInvokeFunc(funcName)
    return function (frame)
        local args = getArgs(frame, {
            valueFunc = function (key, value)
                if type(value) == 'string' then
                    value = value:match('^%s*(.-)%s*$') -- Remove whitespace.
                    if key == 'heading' or value ~= '' then
                        return value
                    else
                        return nil
                    end
                else
                    return value
                end
            end
        })
        return p[funcName](args)
    end
end

----------------------------------------------------------------------------
-- Entry points
----------------------------------------------------------------------------

function p.nonexistent(frame)
    if mw.title.getCurrentTitle().subpageText == 'testcases' then
        return frame:expandTemplate{title = 'module test cases notice'}
    else
        return p.main(frame)
    end
end

p.main = makeInvokeFunc('_main')

function p._main(args)
    --[[
    -- This function defines logic flow for the module.
    -- @args - table of arguments passed by the user
    --]]
    local env = p.getEnvironment(args)
    local root = mw.html.create()
    root
        :wikitext(p._getModuleWikitext(args, env))
        :wikitext(p.protectionTemplate(env))
        :wikitext(p.sandboxNotice(args, env))
        :tag('div')
            -- 'documentation-container'
            :addClass(message('container'))
            :attr('role', 'complementary')
            :attr('aria-labelledby', args.heading ~= '' and 'documentation-heading' or nil)
            :attr('aria-label', args.heading == '' and 'Documentation' or nil)
            :newline()
            :tag('div')
                -- 'documentation'
                :addClass(message('main-div-classes'))
                :newline()
                :wikitext(p._startBox(args, env))
                :wikitext(p._content(args, env))
                :tag('div')
                    -- 'documentation-clear'
                    :addClass(message('clear'))
                    :done()
                :newline()
                :done()
            :wikitext(p._endBox(args, env))
            :done()
        :wikitext(p.addTrackingCategories(env))
    -- 'Module:Documentation/styles.css'
    return mw.getCurrentFrame():extensionTag (
        'templatestyles', '', {src=cfg['templatestyles']
    }) .. tostring(root)
end

----------------------------------------------------------------------------
-- Environment settings
----------------------------------------------------------------------------

function p.getEnvironment(args)
    --[[
    -- Returns a table with information about the environment, including title
    -- objects and other namespace- or path-related data.
    -- @args - table of arguments passed by the user
    --
    -- Title objects include:
    -- env.title - the page we are making documentation for (usually the current title)
    -- env.templateTitle - the template (or module, file, etc.)
    -- env.docTitle - the /doc subpage.
    -- env.sandboxTitle - the /sandbox subpage.
    -- env.testcasesTitle - the /testcases subpage.
    --
    -- Data includes:
    -- env.protectionLevels - the protection levels table of the title object.
    -- env.subjectSpace - the number of the title's subject namespace.
    -- env.docSpace - the number of the namespace the title puts its documentation in.
    -- env.docpageBase - the text of the base page of the /doc, /sandbox and /testcases pages, with namespace.
    -- env.compareUrl - URL of the Special:ComparePages page comparing the sandbox with the template.
    --
    -- All table lookups are passed through pcall so that errors are caught. If an error occurs, the value
    -- returned will be nil.
    --]]

    local env, envFuncs = {}, {}

    -- Set up the metatable. If triggered we call the corresponding function in the envFuncs table. The value
    -- returned by that function is memoized in the env table so that we don't call any of the functions
    -- more than once. (Nils won't be memoized.)
    setmetatable(env, {
        __index = function (t, key)
            local envFunc = envFuncs[key]
            if envFunc then
                local success, val = pcall(envFunc)
                if success then
                    env[key] = val -- Memoise the value.
                    return val
                end
            end
            return nil
        end
    })

    function envFuncs.title()
        -- The title object for the current page, or a test page passed with args.page.
        local title
        local titleArg = args.page
        if titleArg then
            title = mw.title.new(titleArg)
        else
            title = mw.title.getCurrentTitle()
        end
        return title
    end

    function envFuncs.templateTitle()
        --[[
        -- The template (or module, etc.) title object.
        -- Messages:
        -- 'sandbox-subpage' --&gt; 'sandbox'
        -- 'testcases-subpage' --&gt; 'testcases'
        --]]
        local subjectSpace = env.subjectSpace
        local title = env.title
        local subpage = title.subpageText
        if subpage == message('sandbox-subpage') or subpage == message('testcases-subpage') then
            return mw.title.makeTitle(subjectSpace, title.baseText)
        else
            return mw.title.makeTitle(subjectSpace, title.text)
        end
    end

    function envFuncs.docTitle()
        --[[
        -- Title object of the /doc subpage.
        -- Messages:
        -- 'doc-subpage' --&gt; 'doc'
        --]]
        local title = env.title
        local docname = args[1] -- User-specified doc page.
        local docpage
        if docname then
            docpage = docname
        else
            docpage = env.docpageBase .. '/' .. message('doc-subpage')
        end
        return mw.title.new(docpage)
    end

    function envFuncs.sandboxTitle()
        --[[
        -- Title object for the /sandbox subpage.
        -- Messages:
        -- 'sandbox-subpage' --&gt; 'sandbox'
        --]]
        return mw.title.new(env.docpageBase .. '/' .. message('sandbox-subpage'))
    end

    function envFuncs.testcasesTitle()
        --[[
        -- Title object for the /testcases subpage.
        -- Messages:
        -- 'testcases-subpage' --&gt; 'testcases'
        --]]
        return mw.title.new(env.docpageBase .. '/' .. message('testcases-subpage'))
    end

    function envFuncs.protectionLevels()
        -- The protection levels table of the title object.
        return env.title.protectionLevels
    end

    function envFuncs.subjectSpace()
        -- The subject namespace number.
        return mw.site.namespaces[env.title.namespace].subject.id
    end

    function envFuncs.docSpace()
        -- The documentation namespace number. For most namespaces this is the
        -- same as the subject namespace. However, pages in the Article, File,
        -- MediaWiki or Category namespaces must have their /doc, /sandbox and
        -- /testcases pages in talk space.
        local subjectSpace = env.subjectSpace
        if subjectSpace == 0 or subjectSpace == 6 or subjectSpace == 8 or subjectSpace == 14 then
            return subjectSpace + 1
        else
            return subjectSpace
        end
    end

    function envFuncs.docpageBase()
        -- The base page of the /doc, /sandbox, and /testcases subpages.
        -- For some namespaces this is the talk page, rather than the template page.
        local templateTitle = env.templateTitle
        local docSpace = env.docSpace
        local docSpaceText = mw.site.namespaces[docSpace].name
        -- Assemble the link. docSpace is never the main namespace, so we can hardcode the colon.
        return docSpaceText .. ':' .. templateTitle.text
    end

    function envFuncs.compareUrl()
        -- Diff link between the sandbox and the main template using [[Special:ComparePages]].
        local templateTitle = env.templateTitle
        local sandboxTitle = env.sandboxTitle
        if templateTitle.exists and sandboxTitle.exists then
            local compareUrl = mw.uri.fullUrl(
                'Special:ComparePages',
                { page1 = templateTitle.prefixedText, page2 = sandboxTitle.prefixedText}
            )
            return tostring(compareUrl)
        else
            return nil
        end
    end

    return env
end

----------------------------------------------------------------------------
-- Auxiliary templates
----------------------------------------------------------------------------

p.getModuleWikitext = makeInvokeFunc('_getModuleWikitext')

function p._getModuleWikitext(args, env)
    local currentTitle = mw.title.getCurrentTitle()
    if currentTitle.contentModel ~= 'Scribunto' then return end
    pcall(require, currentTitle.prefixedText) -- if it fails, we don't care
    local moduleWikitext =  package.loaded["Module:Module wikitext"]
    if moduleWikitext then
        return moduleWikitext.main()
    end
end

function p.sandboxNotice(args, env)
    --[=[
    -- Generates a sandbox notice for display above sandbox pages.
    -- @args - a table of arguments passed by the user
    -- @env - environment table containing title objects, etc., generated with p.getEnvironment
    --
    -- Messages:
    -- 'sandbox-notice-image' --&gt; '[[Image:Sandbox.svg|50px|alt=|link=]]'
    -- 'sandbox-notice-blurb' --&gt; 'This is the $1 for $2.'
    -- 'sandbox-notice-diff-blurb' --&gt; 'This is the $1 for $2 ($3).'
    -- 'sandbox-notice-pagetype-template' --&gt; '[[Wikipedia:Template test cases|template sandbox]] page'
    -- 'sandbox-notice-pagetype-module' --&gt; '[[Wikipedia:Template test cases|module sandbox]] page'
    -- 'sandbox-notice-pagetype-other' --&gt; 'sandbox page'
    -- 'sandbox-notice-compare-link-display' --&gt; 'diff'
    -- 'sandbox-notice-testcases-blurb' --&gt; 'See also the companion subpage for $1.'
    -- 'sandbox-notice-testcases-link-display' --&gt; 'test cases'
    -- 'sandbox-category' --&gt; 'Template sandboxes'
    --]=]
    local title = env.title
    local sandboxTitle = env.sandboxTitle
    local templateTitle = env.templateTitle
    local subjectSpace = env.subjectSpace
    if not (subjectSpace and title and sandboxTitle and templateTitle
        and mw.title.equals(title, sandboxTitle)) then
        return nil
    end
    -- Build the table of arguments to pass to {{ombox}}. We need just two fields, "image" and "text".
    local omargs = {}
    omargs.image = message('sandbox-notice-image')
    -- Get the text. We start with the opening blurb, which is something like
    -- "This is the template sandbox for [[Template:Foo]] (diff)."
    local text = ''
    local pagetype
    if subjectSpace == 10 then
        pagetype = message('sandbox-notice-pagetype-template')
    elseif subjectSpace == 828 then
        pagetype = message('sandbox-notice-pagetype-module')
    else
        pagetype = message('sandbox-notice-pagetype-other')
    end
    local templateLink = makeWikilink(templateTitle.prefixedText)
    local compareUrl = env.compareUrl
    if compareUrl then
        local compareDisplay = message('sandbox-notice-compare-link-display')
        local compareLink = makeUrlLink(compareUrl, compareDisplay)
        text = text .. message('sandbox-notice-diff-blurb', {pagetype, templateLink, compareLink})
    else
        text = text .. message('sandbox-notice-blurb', {pagetype, templateLink})
    end
    -- Get the test cases page blurb if the page exists. This is something like
    -- "See also the companion subpage for [[Template:Foo/testcases|test cases]]."
    local testcasesTitle = env.testcasesTitle
    if testcasesTitle and testcasesTitle.exists then
        if testcasesTitle.contentModel == "Scribunto" then
            local testcasesLinkDisplay = message('sandbox-notice-testcases-link-display')
            local testcasesRunLinkDisplay = message('sandbox-notice-testcases-run-link-display')
            local testcasesLink = makeWikilink(testcasesTitle.prefixedText, testcasesLinkDisplay)
            local testcasesRunLink = makeWikilink(testcasesTitle.talkPageTitle.prefixedText, testcasesRunLinkDisplay)
            text = text .. '&lt;br /&gt;' .. message('sandbox-notice-testcases-run-blurb', {testcasesLink, testcasesRunLink})
        else
            local testcasesLinkDisplay = message('sandbox-notice-testcases-link-display')
            local testcasesLink = makeWikilink(testcasesTitle.prefixedText, testcasesLinkDisplay)
            text = text .. '&lt;br /&gt;' .. message('sandbox-notice-testcases-blurb', {testcasesLink})
        end
    end
    -- Add the sandbox to the sandbox category.
    omargs.text = text .. makeCategoryLink(message('sandbox-category'))

    -- 'documentation-clear'
    return '&lt;div class="' .. message('clear') .. '"&gt;&lt;/div&gt;'
        .. require('Module:Message box').main('ombox', omargs)
end

function p.protectionTemplate(env)
    -- Generates the padlock icon in the top right.
    -- @env - environment table containing title objects, etc., generated with p.getEnvironment
    -- Messages:
    -- 'protection-template' --&gt; 'pp-template'
    -- 'protection-template-args' --&gt; {docusage = 'yes'}
    local protectionLevels = env.protectionLevels
    if not protectionLevels then
        return nil
    end
    local editProt = protectionLevels.edit and protectionLevels.edit[1]
    local moveProt = protectionLevels.move and protectionLevels.move[1]
    if editProt then
        -- The page is edit-protected.
        return require('Module:Protection banner')._main{
            message('protection-reason-edit'), small = true
        }
    elseif moveProt and moveProt ~= 'autoconfirmed' then
        -- The page is move-protected but not edit-protected. Exclude move
        -- protection with the level "autoconfirmed", as this is equivalent to
        -- no move protection at all.
        return require('Module:Protection banner')._main{
            action = 'move', small = true
        }
    else
        return nil
    end
end

----------------------------------------------------------------------------
-- Start box
----------------------------------------------------------------------------

p.startBox = makeInvokeFunc('_startBox')

function p._startBox(args, env)
    --[[
    -- This function generates the start box.
    -- @args - a table of arguments passed by the user
    -- @env - environment table containing title objects, etc., generated with p.getEnvironment
    --
    -- The actual work is done by p.makeStartBoxLinksData and p.renderStartBoxLinks which make
    -- the [view] [edit] [history] [purge] links, and by p.makeStartBoxData and p.renderStartBox
    -- which generate the box HTML.
    --]]
    env = env or p.getEnvironment(args)
    local links
    local content = args.content
    if not content or args[1] then
        -- No need to include the links if the documentation is on the template page itself.
        local linksData = p.makeStartBoxLinksData(args, env)
        if linksData then
            links = p.renderStartBoxLinks(linksData)
        end
    end
    -- Generate the start box html.
    local data = p.makeStartBoxData(args, env, links)
    if data then
        return p.renderStartBox(data)
    else
        -- User specified no heading.
        return nil
    end
end

function p.makeStartBoxLinksData(args, env)
    --[[
    -- Does initial processing of data to make the [view] [edit] [history] [purge] links.
    -- @args - a table of arguments passed by the user
    -- @env - environment table containing title objects, etc., generated with p.getEnvironment
    --
    -- Messages:
    -- 'view-link-display' --&gt; 'view'
    -- 'edit-link-display' --&gt; 'edit'
    -- 'history-link-display' --&gt; 'history'
    -- 'purge-link-display' --&gt; 'purge'
    -- 'module-preload' --&gt; 'Template:Documentation/preload-module-doc'
    -- 'docpage-preload' --&gt; 'Template:Documentation/preload'
    -- 'create-link-display' --&gt; 'create'
    --]]
    local subjectSpace = env.subjectSpace
    local title = env.title
    local docTitle = env.docTitle
    if not title or not docTitle then
        return nil
    end
    if docTitle.isRedirect then
        docTitle = docTitle.redirectTarget
    end

    local data = {}
    data.title = title
    data.docTitle = docTitle
    -- View, display, edit, and purge links if /doc exists.
    data.viewLinkDisplay = message('view-link-display')
    data.editLinkDisplay = message('edit-link-display')
    data.historyLinkDisplay = message('history-link-display')
    data.purgeLinkDisplay = message('purge-link-display')
    -- Create link if /doc doesn't exist.
    local preload = args.preload
    if not preload then
        if subjectSpace == 828 then -- Module namespace
            preload = message('module-preload')
        else
            preload = message('docpage-preload')
        end
    end
    data.preload = preload
    data.createLinkDisplay = message('create-link-display')
    return data
end

function p.renderStartBoxLinks(data)
    --[[
    -- Generates the [view][edit][history][purge] or [create][purge] links from the data table.
    -- @data - a table of data generated by p.makeStartBoxLinksData
    --]]

    local function escapeBrackets(s)
        -- Escapes square brackets with HTML entities.
        s = s:gsub('%[', '&amp;#91;') -- Replace square brackets with HTML entities.
        s = s:gsub('%]', '&amp;#93;')
        return s
    end

    local ret
    local docTitle = data.docTitle
    local title = data.title
    local purgeLink = makeUrlLink(title:fullUrl{action = 'purge'}, data.purgeLinkDisplay)
    if docTitle.exists then
        local viewLink = makeWikilink(docTitle.prefixedText, data.viewLinkDisplay)
        local editLink = makeUrlLink(docTitle:fullUrl{action = 'edit'}, data.editLinkDisplay)
        local historyLink = makeUrlLink(docTitle:fullUrl{action = 'history'}, data.historyLinkDisplay)
        ret = '[%s] [%s] [%s] [%s]'
        ret = escapeBrackets(ret)
        ret = mw.ustring.format(ret, viewLink, editLink, historyLink, purgeLink)
    else
        local createLink = makeUrlLink(docTitle:fullUrl{action = 'edit', preload = data.preload}, data.createLinkDisplay)
        ret = '[%s] [%s]'
        ret = escapeBrackets(ret)
        ret = mw.ustring.format(ret, createLink, purgeLink)
    end
    return ret
end

function p.makeStartBoxData(args, env, links)
    --[=[
    -- Does initial processing of data to pass to the start-box render function, p.renderStartBox.
    -- @args - a table of arguments passed by the user
    -- @env - environment table containing title objects, etc., generated with p.getEnvironment
    -- @links - a string containing the [view][edit][history][purge] links - could be nil if there's an error.
    --
    -- Messages:
    -- 'documentation-icon-wikitext' --&gt; '[[File:Test Template Info-Icon - Version (2).svg|50px|link=|alt=]]'
    -- 'template-namespace-heading' --&gt; 'Template documentation'
    -- 'module-namespace-heading' --&gt; 'Module documentation'
    -- 'file-namespace-heading' --&gt; 'Summary'
    -- 'other-namespaces-heading' --&gt; 'Documentation'
    -- 'testcases-create-link-display' --&gt; 'create'
    --]=]
    local subjectSpace = env.subjectSpace
    if not subjectSpace then
        -- Default to an "other namespaces" namespace, so that we get at least some output
        -- if an error occurs.
        subjectSpace = 2
    end
    local data = {}

    -- Heading
    local heading = args.heading -- Blank values are not removed.
    if heading == '' then
        -- Don't display the start box if the heading arg is defined but blank.
        return nil
    end
    if heading then
        data.heading = heading
    elseif subjectSpace == 10 then -- Template namespace
        data.heading = message('documentation-icon-wikitext') .. ' ' .. message('template-namespace-heading')
    elseif subjectSpace == 828 then -- Module namespace
        data.heading = message('documentation-icon-wikitext') .. ' ' .. message('module-namespace-heading')
    elseif subjectSpace == 6 then -- File namespace
        data.heading = message('file-namespace-heading')
    else
        data.heading = message('other-namespaces-heading')
    end

    -- Heading CSS
    local headingStyle = args['heading-style']
    if headingStyle then
        data.headingStyleText = headingStyle
    else
        -- 'documentation-heading'
        data.headingClass = message('main-div-heading-class')
    end

    -- Data for the [view][edit][history][purge] or [create] links.
    if links then
        -- 'mw-editsection-like plainlinks'
        data.linksClass = message('start-box-link-classes')
        data.links = links
    end

    return data
end

function p.renderStartBox(data)
    -- Renders the start box html.
    -- @data - a table of data generated by p.makeStartBoxData.
    local sbox = mw.html.create('div')
    sbox
        -- 'documentation-startbox'
        :addClass(message('start-box-class'))
        :newline()
        :tag('span')
            :addClass(data.headingClass)
            :attr('id', 'documentation-heading')
            :cssText(data.headingStyleText)
            :wikitext(data.heading)
    local links = data.links
    if links then
        sbox:tag('span')
            :addClass(data.linksClass)
            :attr('id', data.linksId)
            :wikitext(links)
    end
    return tostring(sbox)
end

----------------------------------------------------------------------------
-- Documentation content
----------------------------------------------------------------------------

p.content = makeInvokeFunc('_content')

function p._content(args, env)
    -- Displays the documentation contents
    -- @args - a table of arguments passed by the user
    -- @env - environment table containing title objects, etc., generated with p.getEnvironment
    env = env or p.getEnvironment(args)
    local docTitle = env.docTitle
    local content = args.content
    if not content and docTitle and docTitle.exists then
        content = args._content or mw.getCurrentFrame():expandTemplate{title = docTitle.prefixedText}
    end
    -- The line breaks below are necessary so that "=== Headings ===" at the start and end
    -- of docs are interpreted correctly.
    return '\n' .. (content or '') .. '\n'
end

p.contentTitle = makeInvokeFunc('_contentTitle')

function p._contentTitle(args, env)
    env = env or p.getEnvironment(args)
    local docTitle = env.docTitle
    if not args.content and docTitle and docTitle.exists then
        return docTitle.prefixedText
    else
        return ''
    end
end

----------------------------------------------------------------------------
-- End box
----------------------------------------------------------------------------

p.endBox = makeInvokeFunc('_endBox')

function p._endBox(args, env)
    --[=[
    -- This function generates the end box (also known as the link box).
    -- @args - a table of arguments passed by the user
    -- @env - environment table containing title objects, etc., generated with p.getEnvironment
    --
    --]=]

    -- Get environment data.
    env = env or p.getEnvironment(args)
    local subjectSpace = env.subjectSpace
    local docTitle = env.docTitle
    if not subjectSpace or not docTitle then
        return nil
    end

    -- Check whether we should output the end box at all. Add the end
    -- box by default if the documentation exists or if we are in the
    -- user, module or template namespaces.
    local linkBox = args['link box']
    if linkBox == 'off'
        or not (
            docTitle.exists
            or subjectSpace == 2
            or subjectSpace == 828
            or subjectSpace == 10
        )
    then
        return nil
    end

    -- Assemble the link box.
    local text = ''
    if linkBox then
        text = text .. linkBox
    else
        text = text .. (p.makeDocPageBlurb(args, env) or '') -- "This documentation is transcluded from [[Foo]]."
        if subjectSpace == 2 or subjectSpace == 10 or subjectSpace == 828 then
            -- We are in the user, template or module namespaces.
            -- Add sandbox and testcases links.
            -- "Editors can experiment in this template's sandbox and testcases pages."
            text = text .. (p.makeExperimentBlurb(args, env) or '') .. '&lt;br /&gt;'
            if not args.content and not args[1] then
                -- "Please add categories to the /doc subpage."
                -- Don't show this message with inline docs or with an explicitly specified doc page,
                -- as then it is unclear where to add the categories.
                text = text .. (p.makeCategoriesBlurb(args, env) or '')
            end
            text = text .. ' ' .. (p.makeSubpagesBlurb(args, env) or '') --"Subpages of this template"
        end
    end

    local box = mw.html.create('div')
    -- 'documentation-metadata'
    box:attr('role', 'note')
        :addClass(message('end-box-class'))
        -- 'plainlinks'
        :addClass(message('end-box-plainlinks'))
        :wikitext(text)
        :done()

    return '\n' .. tostring(box)
end

function p.makeDocPageBlurb(args, env)
    --[=[
    -- Makes the blurb "This documentation is transcluded from [[Template:Foo]] (edit, history)".
    -- @args - a table of arguments passed by the user
    -- @env - environment table containing title objects, etc., generated with p.getEnvironment
    --
    -- Messages:
    -- 'edit-link-display' --&gt; 'edit'
    -- 'history-link-display' --&gt; 'history'
    -- 'transcluded-from-blurb' --&gt;
    -- 'The above [[Wikipedia:Template documentation|documentation]]
    -- is [[Help:Transclusion|transcluded]] from $1.'
    -- 'module-preload' --&gt; 'Template:Documentation/preload-module-doc'
    -- 'create-link-display' --&gt; 'create'
    -- 'create-module-doc-blurb' --&gt;
    -- 'You might want to $1 a documentation page for this [[Wikipedia:Lua|Scribunto module]].'
    --]=]
    local docTitle = env.docTitle
    if not docTitle then
        return nil
    end
    local ret
    if docTitle.exists then
        -- /doc exists; link to it.
        local docLink = makeWikilink(docTitle.prefixedText)
        local editUrl = docTitle:fullUrl{action = 'edit'}
        local editDisplay = message('edit-link-display')
        local editLink = makeUrlLink(editUrl, editDisplay)
        local historyUrl = docTitle:fullUrl{action = 'history'}
        local historyDisplay = message('history-link-display')
        local historyLink = makeUrlLink(historyUrl, historyDisplay)
        ret = message('transcluded-from-blurb', {docLink})
            .. ' '
            .. makeToolbar(editLink, historyLink)
            .. '&lt;br /&gt;'
    elseif env.subjectSpace == 828 then
        -- /doc does not exist; ask to create it.
        local createUrl = docTitle:fullUrl{action = 'edit', preload = message('module-preload')}
        local createDisplay = message('create-link-display')
        local createLink = makeUrlLink(createUrl, createDisplay)
        ret = message('create-module-doc-blurb', {createLink})
            .. '&lt;br /&gt;'
    end
    return ret
end

function p.makeExperimentBlurb(args, env)
    --[[
    -- Renders the text "Editors can experiment in this template's sandbox (edit | diff) and testcases (edit) pages."
    -- @args - a table of arguments passed by the user
    -- @env - environment table containing title objects, etc., generated with p.getEnvironment
    --
    -- Messages:
    -- 'sandbox-link-display' --&gt; 'sandbox'
    -- 'sandbox-edit-link-display' --&gt; 'edit'
    -- 'compare-link-display' --&gt; 'diff'
    -- 'module-sandbox-preload' --&gt; 'Template:Documentation/preload-module-sandbox'
    -- 'template-sandbox-preload' --&gt; 'Template:Documentation/preload-sandbox'
    -- 'sandbox-create-link-display' --&gt; 'create'
    -- 'mirror-edit-summary' --&gt; 'Create sandbox version of $1'
    -- 'mirror-link-display' --&gt; 'mirror'
    -- 'mirror-link-preload' --&gt; 'Template:Documentation/mirror'
    -- 'sandbox-link-display' --&gt; 'sandbox'
    -- 'testcases-link-display' --&gt; 'testcases'
    -- 'testcases-edit-link-display'--&gt; 'edit'
    -- 'template-sandbox-preload' --&gt; 'Template:Documentation/preload-sandbox'
    -- 'testcases-create-link-display' --&gt; 'create'
    -- 'testcases-link-display' --&gt; 'testcases'
    -- 'testcases-edit-link-display' --&gt; 'edit'
    -- 'module-testcases-preload' --&gt; 'Template:Documentation/preload-module-testcases'
    -- 'template-testcases-preload' --&gt; 'Template:Documentation/preload-testcases'
    -- 'experiment-blurb-module' --&gt; 'Editors can experiment in this module's $1 and $2 pages.'
    -- 'experiment-blurb-template' --&gt; 'Editors can experiment in this template's $1 and $2 pages.'
    --]]
    local subjectSpace = env.subjectSpace
    local templateTitle = env.templateTitle
    local sandboxTitle = env.sandboxTitle
    local testcasesTitle = env.testcasesTitle
    local templatePage = templateTitle.prefixedText
    if not subjectSpace or not templateTitle or not sandboxTitle or not testcasesTitle then
        return nil
    end
    -- Make links.
    local sandboxLinks, testcasesLinks
    if sandboxTitle.exists then
        local sandboxPage = sandboxTitle.prefixedText
        local sandboxDisplay = message('sandbox-link-display')
        local sandboxLink = makeWikilink(sandboxPage, sandboxDisplay)
        local sandboxEditUrl = sandboxTitle:fullUrl{action = 'edit'}
        local sandboxEditDisplay = message('sandbox-edit-link-display')
        local sandboxEditLink = makeUrlLink(sandboxEditUrl, sandboxEditDisplay)
        local compareUrl = env.compareUrl
        local compareLink
        if compareUrl then
            local compareDisplay = message('compare-link-display')
            compareLink = makeUrlLink(compareUrl, compareDisplay)
        end
        sandboxLinks = sandboxLink .. ' ' .. makeToolbar(sandboxEditLink, compareLink)
    else
        local sandboxPreload
        if subjectSpace == 828 then
            sandboxPreload = message('module-sandbox-preload')
        else
            sandboxPreload = message('template-sandbox-preload')
        end
        local sandboxCreateUrl = sandboxTitle:fullUrl{action = 'edit', preload = sandboxPreload}
        local sandboxCreateDisplay = message('sandbox-create-link-display')
        local sandboxCreateLink = makeUrlLink(sandboxCreateUrl, sandboxCreateDisplay)
        local mirrorSummary = message('mirror-edit-summary', {makeWikilink(templatePage)})
        local mirrorPreload = message('mirror-link-preload')
        local mirrorUrl = sandboxTitle:fullUrl{action = 'edit', preload = mirrorPreload, summary = mirrorSummary}
        if subjectSpace == 828 then
            mirrorUrl = sandboxTitle:fullUrl{action = 'edit', preload = templateTitle.prefixedText, summary = mirrorSummary}
        end
        local mirrorDisplay = message('mirror-link-display')
        local mirrorLink = makeUrlLink(mirrorUrl, mirrorDisplay)
        sandboxLinks = message('sandbox-link-display') .. ' ' .. makeToolbar(sandboxCreateLink, mirrorLink)
    end
    if testcasesTitle.exists then
        local testcasesPage = testcasesTitle.prefixedText
        local testcasesDisplay = message('testcases-link-display')
        local testcasesLink = makeWikilink(testcasesPage, testcasesDisplay)
        local testcasesEditUrl = testcasesTitle:fullUrl{action = 'edit'}
        local testcasesEditDisplay = message('testcases-edit-link-display')
        local testcasesEditLink = makeUrlLink(testcasesEditUrl, testcasesEditDisplay)
        -- for Modules, add testcases run link if exists
        if testcasesTitle.contentModel == "Scribunto"  and testcasesTitle.talkPageTitle and testcasesTitle.talkPageTitle.exists then
            local testcasesRunLinkDisplay = message('testcases-run-link-display')
            local testcasesRunLink = makeWikilink(testcasesTitle.talkPageTitle.prefixedText, testcasesRunLinkDisplay)
            testcasesLinks = testcasesLink .. ' ' .. makeToolbar(testcasesEditLink, testcasesRunLink)
        else
            testcasesLinks = testcasesLink .. ' ' .. makeToolbar(testcasesEditLink)
        end
    else
        local testcasesPreload
        if subjectSpace == 828 then
            testcasesPreload = message('module-testcases-preload')
        else
            testcasesPreload = message('template-testcases-preload')
        end
        local testcasesCreateUrl = testcasesTitle:fullUrl{action = 'edit', preload = testcasesPreload}
        local testcasesCreateDisplay = message('testcases-create-link-display')
        local testcasesCreateLink = makeUrlLink(testcasesCreateUrl, testcasesCreateDisplay)
        testcasesLinks = message('testcases-link-display') .. ' ' .. makeToolbar(testcasesCreateLink)
    end
    local messageName
    if subjectSpace == 828 then
        messageName = 'experiment-blurb-module'
    else
        messageName = 'experiment-blurb-template'
    end
    return message(messageName, {sandboxLinks, testcasesLinks})
end

function p.makeCategoriesBlurb(args, env)
    --[[
    -- Generates the text "Please add categories to the /doc subpage."
    -- @args - a table of arguments passed by the user
    -- @env - environment table containing title objects, etc., generated with p.getEnvironment
    -- Messages:
    -- 'doc-link-display' --&gt; '/doc'
    -- 'add-categories-blurb' --&gt; 'Please add categories to the $1 subpage.'
    --]]
    local docTitle = env.docTitle
    if not docTitle then
        return nil
    end
    local docPathLink = makeWikilink(docTitle.prefixedText, message('doc-link-display'))
    return message('add-categories-blurb', {docPathLink})
end

function p.makeSubpagesBlurb(args, env)
    --[[
    -- Generates the "Subpages of this template" link.
    -- @args - a table of arguments passed by the user
    -- @env - environment table containing title objects, etc., generated with p.getEnvironment

    -- Messages:
    -- 'template-pagetype' --&gt; 'template'
    -- 'module-pagetype' --&gt; 'module'
    -- 'default-pagetype' --&gt; 'page'
    -- 'subpages-link-display' --&gt; 'Subpages of this $1'
    --]]
    local subjectSpace = env.subjectSpace
    local templateTitle = env.templateTitle
    if not subjectSpace or not templateTitle then
        return nil
    end
    local pagetype
    if subjectSpace == 10 then
        pagetype = message('template-pagetype')
    elseif subjectSpace == 828 then
        pagetype = message('module-pagetype')
    else
        pagetype = message('default-pagetype')
    end
    local subpagesLink = makeWikilink(
        'Special:PrefixIndex/' .. templateTitle.prefixedText .. '/',
        message('subpages-link-display', {pagetype})
    )
    return message('subpages-blurb', {subpagesLink})
end

----------------------------------------------------------------------------
-- Tracking categories
----------------------------------------------------------------------------

function p.addTrackingCategories(env)
    --[[
    -- Check if {{documentation}} is transcluded on a /doc or /testcases page.
    -- @env - environment table containing title objects, etc., generated with p.getEnvironment

    -- Messages:
    -- 'display-strange-usage-category' --&gt; true
    -- 'doc-subpage' --&gt; 'doc'
    -- 'testcases-subpage' --&gt; 'testcases'
    -- 'strange-usage-category' --&gt; 'Wikipedia pages with strange ((documentation)) usage'
    --
    -- /testcases pages in the module namespace are not categorised, as they may have
    -- {{documentation}} transcluded automatically.
    --]]
    local title = env.title
    local subjectSpace = env.subjectSpace
    if not title or not subjectSpace then
        return nil
    end
    local subpage = title.subpageText
    local ret = ''
    if message('display-strange-usage-category', nil, 'boolean')
        and (
            subpage == message('doc-subpage')
            or subjectSpace ~= 828 and subpage == message('testcases-subpage')
        )
    then
        ret = ret .. makeCategoryLink(message('strange-usage-category'))
    end
    return ret
end

return p</text>
      <sha1>hhe6rl9gdvqywjk6r1tbi4ymwotbf24</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Documentation/config</title>
    <ns>828</ns>
    <id>41520829</id>
    <revision>
      <id>1067946425</id>
      <parentid>1061447213</parentid>
      <timestamp>2022-01-25T23:46:11Z</timestamp>
      <contributor>
        <username>Ianblair23</username>
        <id>145927</id>
      </contributor>
      <comment>link</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="17433" xml:space="preserve">----------------------------------------------------------------------------------------------------
--
--                               Configuration for Module:Documentation
--
-- Here you can set the values of the parameters and messages used in Module:Documentation to
-- localise it to your wiki and your language. Unless specified otherwise, values given here
-- should be string values.
----------------------------------------------------------------------------------------------------

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

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

-- cfg['protection-reason-edit']
-- The protection reason for edit-protected templates to pass to
-- [[Module:Protection banner]].
cfg['protection-reason-edit'] = 'template'

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

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

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

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

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

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

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

-- cfg['documentation-icon-wikitext']
-- The wikitext for the icon shown at the top of the template.
cfg['documentation-icon-wikitext'] = '[[File:Test Template Info-Icon - Version (2).svg|50px|link=|alt=]]'

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- cfg['mirror-link-preload']
-- The page to preload when a user clicks the "mirror" link.
cfg['mirror-link-preload'] = 'Template:Documentation/mirror'

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- cfg['templatestyles']
-- The name of the TemplateStyles page where CSS is kept.
-- Sandbox CSS will be at Module:Documentation/sandbox/styles.css when needed.
cfg['templatestyles'] = 'Module:Documentation/styles.css'

-- cfg['container']
-- Class which can be used to set flex or grid CSS on the
-- two child divs documentation and documentation-metadata
cfg['container'] = 'documentation-container'

-- cfg['main-div-classes']
-- Classes added to the main HTML "div" tag.
cfg['main-div-classes'] = 'documentation'

-- cfg['main-div-heading-class']
-- Class for the main heading for templates and modules and assoc. talk spaces
cfg['main-div-heading-class'] = 'documentation-heading'

-- cfg['start-box-class']
-- Class for the start box
cfg['start-box-class'] = 'documentation-startbox'

-- cfg['start-box-link-classes']
-- Classes used for the [view][edit][history] or [create] links in the start box.
-- mw-editsection-like is per [[Wikipedia:Village pump (technical)/Archive 117]]
cfg['start-box-link-classes'] = 'mw-editsection-like plainlinks'

-- cfg['end-box-class']
-- Class for the end box.
cfg['end-box-class'] = 'documentation-metadata'

-- cfg['end-box-plainlinks']
-- Plainlinks
cfg['end-box-plainlinks'] = 'plainlinks'

-- cfg['toolbar-class']
-- Class added for toolbar links.
cfg['toolbar-class'] = 'documentation-toolbar'

-- cfg['clear']
-- Just used to clear things.
cfg['clear'] = 'documentation-clear'


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

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

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

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

return cfg</text>
      <sha1>da6pt1lzpy4z0skaztwblaqnfhizyf7</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Documentation/styles.css</title>
    <ns>828</ns>
    <id>61440006</id>
    <revision>
      <id>989579069</id>
      <parentid>989578481</parentid>
      <timestamp>2020-11-19T20:21:58Z</timestamp>
      <contributor>
        <username>Izno</username>
        <id>2927383</id>
      </contributor>
      <minor/>
      <comment>Changed protection level for "[[Module:Documentation/styles.css]]": actually match module ([Edit=Require template editor access] (indefinite) [Move=Require template editor access] (indefinite))</comment>
      <model>sanitized-css</model>
      <format>text/css</format>
      <text bytes="716" xml:space="preserve">/* {{pp|small=yes}} */
.documentation,
.documentation-metadata {
    border: 1px solid #a2a9b1;
    background-color: #ecfcf4;
    clear: both;
}

.documentation {
    margin: 1em 0 0 0;
    padding: 1em;
}

.documentation-metadata {
    margin: 0.2em 0; /* same margin left-right as .documentation */
    font-style: italic;
    padding: 0.4em 1em; /* same padding left-right as .documentation */
}

.documentation-startbox {
    padding-bottom: 3px;
    border-bottom: 1px solid #aaa;
    margin-bottom: 1ex;
}

.documentation-heading {
    font-weight: bold;
    font-size: 125%;
}

.documentation-clear { /* Don't want things to stick out where they shouldn't. */
    clear: both;
}

.documentation-toolbar {
    font-style: normal;
    font-size: 85%;
}</text>
      <sha1>o2ia525en7wbq32mq4fpdevtl5d6pcb</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Effective protection expiry</title>
    <ns>828</ns>
    <id>48785459</id>
    <revision>
      <id>948472505</id>
      <parentid>948472504</parentid>
      <timestamp>2020-04-01T06:12:42Z</timestamp>
      <contributor>
        <username>MusikAnimal</username>
        <id>14882394</id>
      </contributor>
      <minor/>
      <comment>1 revision imported</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="1494" xml:space="preserve">local p = {}

-- Returns the expiry of a restriction of an action on a given title, or unknown if it cannot be known.
-- If no title is specified, the title of the page being displayed is used.
function p._main(action, pagename)
    local title
    if type(pagename) == 'table' and pagename.prefixedText then
        title = pagename
    elseif pagename then
        title = mw.title.new(pagename)
    else
        title = mw.title.getCurrentTitle()
    end
    pagename = title.prefixedText
    if action == 'autoreview' then
        local stabilitySettings = mw.ext.FlaggedRevs.getStabilitySettings(title)
        return stabilitySettings and stabilitySettings.expiry or 'unknown'
    elseif action ~= 'edit' and action ~= 'move' and action ~= 'create' and action ~= 'upload' then
        error( 'First parameter must be one of edit, move, create, upload, autoreview', 2 )
    end
    local rawExpiry = mw.getCurrentFrame():callParserFunction('PROTECTIONEXPIRY', action, pagename)
    if rawExpiry == 'infinity' then
        return 'infinity'
    elseif rawExpiry == '' then
        return 'unknown'
    else
        local year, month, day, hour, minute, second = rawExpiry:match(
            '^(%d%d%d%d)(%d%d)(%d%d)(%d%d)(%d%d)(%d%d)$'
        )
        if year then
            return string.format(
                '%s-%s-%sT%s:%s:%s',
                year, month, day, hour, minute, second
            )
        else
            error('internal error in Module:Effective protection expiry; malformed expiry timestamp')
        end
    end
end

setmetatable(p, { __index = function(t, k)
    return function(frame)
        return t._main(k, frame.args[1])
    end
end })

return p</text>
      <sha1>i1wms02y1w048cq6uttka18a5pjzp63</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Effective protection level</title>
    <ns>828</ns>
    <id>41617327</id>
    <revision>
      <id>980896975</id>
      <parentid>948472507</parentid>
      <timestamp>2020-09-29T03:38:47Z</timestamp>
      <contributor>
        <username>Jackmcbarn</username>
        <id>19285809</id>
      </contributor>
      <comment>bring in changes from sandbox</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="3438" xml:space="preserve">local p = {}

-- Returns the permission required to perform a given action on a given title.
-- If no title is specified, the title of the page being displayed is used.
function p._main(action, pagename)
    local title
    if type(pagename) == 'table' and pagename.prefixedText then
        title = pagename
    elseif pagename then
        title = mw.title.new(pagename)
    else
        title = mw.title.getCurrentTitle()
    end
    pagename = title.prefixedText
    if action == 'autoreview' then
        local level = mw.ext.FlaggedRevs.getStabilitySettings(title)
        level = level and level.autoreview
        if level == 'review' then
            return 'reviewer'
        elseif level ~= '' then
            return level
        else
            return nil -- not '*'. a page not being PC-protected is distinct from it being PC-protected with anyone able to review. also not '', as that would mean PC-protected but nobody can review
        end
    elseif action ~= 'edit' and action ~= 'move' and action ~= 'create' and action ~= 'upload' and action ~= 'undelete' then
        error( 'First parameter must be one of edit, move, create, upload, undelete, autoreview', 2 )
    end
    if title.namespace == 8 then -- MediaWiki namespace
        if title.text:sub(-3) == '.js' or title.text:sub(-4) == '.css' or title.contentModel == 'javascript' or title.contentModel == 'css' then -- site JS or CSS page
            return 'interfaceadmin'
        else -- any non-JS/CSS MediaWiki page
            return 'sysop'
        end
    elseif title.namespace == 2 and title.isSubpage then
        if title.contentModel == 'javascript' or title.contentModel == 'css' then -- user JS or CSS page
            return 'interfaceadmin'
        elseif title.contentModel == 'json' then -- user JSON page
            return 'sysop'
        end
    end
    if action == 'undelete' then
        return 'sysop'
    end
    local level = title.protectionLevels[action] and title.protectionLevels[action][1]
    if level == 'sysop' or level == 'editprotected' then
        return 'sysop'
    elseif title.cascadingProtection.restrictions[action] and title.cascadingProtection.restrictions[action][1] then -- used by a cascading-protected page
        return 'sysop'
    elseif level == 'templateeditor' then
        return 'templateeditor'
    elseif action == 'move' then
        local blacklistentry = mw.ext.TitleBlacklist.test('edit', pagename) -- Testing action edit is correct, since this is for the source page. The target page name gets tested with action move.
        if blacklistentry and not blacklistentry.params.autoconfirmed then
            return 'templateeditor'
        elseif title.namespace == 6 then
            return 'filemover'
        elseif level == 'extendedconfirmed' then
            return 'extendedconfirmed'
        else
            return 'autoconfirmed'
        end
    end
    local blacklistentry = mw.ext.TitleBlacklist.test(action, pagename)
    if blacklistentry then
        if not blacklistentry.params.autoconfirmed then
            return 'templateeditor'
        elseif level == 'extendedconfirmed' then
            return 'extendedconfirmed'
        else
            return 'autoconfirmed'
        end
    elseif level == 'editsemiprotected' then -- create-semiprotected pages return this for some reason
        return 'autoconfirmed'
    elseif level then
        return level
    elseif action == 'upload' then
        return 'autoconfirmed'
    elseif action == 'create' and title.namespace % 2 == 0 and title.namespace ~= 118 then -- You need to be registered, but not autoconfirmed, to create non-talk pages other than drafts
        return 'user'
    else
        return '*'
    end
end

setmetatable(p, { __index = function(t, k)
    return function(frame)
        return t._main(k, frame.args[1])
    end
end })

return p</text>
      <sha1>d3lhy0comfcfe9lnnj8klmrfqm1oxw7</sha1>
    </revision>
  </page>
  <page>
    <title>Module:File link</title>
    <ns>828</ns>
    <id>42903140</id>
    <revision>
      <id>948474149</id>
      <parentid>948472509</parentid>
      <timestamp>2020-04-01T06:31:54Z</timestamp>
      <contributor>
        <username>MusikAnimal</username>
        <id>14882394</id>
      </contributor>
      <comment>Undid revision 948472508 by [[Special:Contributions/w&gt;IPad365|w&gt;IPad365]] ([[User talk:w&gt;IPad365|talk]])</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="2544" xml:space="preserve">-- This module provides a library for formatting file wikilinks.

local yesno = require('Module:Yesno')
local checkType = require('libraryUtil').checkType

local p = {}

function p._main(args)
    checkType('_main', 1, args, 'table')

    -- This is basically libraryUtil.checkTypeForNamedArg, but we are rolling our
    -- own function to get the right error level.
    local function checkArg(key, val, level)
        if type(val) ~= 'string' then
            error(string.format(
                "type error in '%s' parameter of '_main' (expected string, got %s)",
                key, type(val)
            ), level)
        end
    end

    local ret = {}

    -- Adds a positional parameter to the buffer.
    local function addPositional(key)
        local val = args[key]
        if not val then
            return nil
        end
        checkArg(key, val, 4)
        ret[#ret + 1] = val
    end

    -- Adds a named parameter to the buffer. We assume that the parameter name
    -- is the same as the argument key.
    local function addNamed(key)
        local val = args[key]
        if not val then
            return nil
        end
        checkArg(key, val, 4)
        ret[#ret + 1] = key .. '=' .. val
    end

    -- Filename
    checkArg('file', args.file, 3)
    ret[#ret + 1] = 'File:' .. args.file

    -- Format
    if args.format then
        checkArg('format', args.format)
        if args.formatfile then
            checkArg('formatfile', args.formatfile)
            ret[#ret + 1] = args.format .. '=' .. args.formatfile
        else
            ret[#ret + 1] = args.format
        end
    end

    -- Border
    if yesno(args.border) then
        ret[#ret + 1] = 'border'
    end

    addPositional('location')
    addPositional('alignment')
    addPositional('size')
    addNamed('upright')
    addNamed('link')
    addNamed('alt')
    addNamed('page')
    addNamed('class')
    addNamed('lang')
    addNamed('start')
    addNamed('end')
    addNamed('thumbtime')
    addPositional('caption')

    return string.format('[[%s]]', table.concat(ret, '|'))
end

function p.main(frame)
    local origArgs = require('Module:Arguments').getArgs(frame, {
        wrappers = 'Template:File link'
    })
    if not origArgs.file then
        error("'file' parameter missing from [[Template:File link]]", 0)
    end

    -- Copy the arguments that were passed to a new table to avoid looking up
    -- every possible parameter in the frame object.
    local args = {}
    for k, v in pairs(origArgs) do
        -- Make _BLANK a special argument to add a blank parameter. For use in
        -- conditional templates etc. it is useful for blank arguments to be
        -- ignored, but we still need a way to specify them so that we can do
        -- things like [[File:Example.png|link=]].
        if v == '_BLANK' then
            v = ''
        end
        args[k] = v
    end
    return p._main(args)
end

return p</text>
      <sha1>bzc22v133v9z5yc4aisazripn6l94p8</sha1>
    </revision>
  </page>
  <page>
    <title>Module:High-use</title>
    <ns>828</ns>
    <id>62062952</id>
    <revision>
      <id>1053091615</id>
      <parentid>1050945202</parentid>
      <timestamp>2021-11-01T21:11:55Z</timestamp>
      <contributor>
        <username>GKFX</username>
        <id>14918984</id>
      </contributor>
      <comment>Link to https://linkcount.toolforge.org/ which is more detailed and mobile-friendly</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="6690" xml:space="preserve">local p = {}

-- _fetch looks at the "demo" argument.
local _fetch = require('Module:Transclusion_count').fetch
local yesno = require('Module:Yesno')

function p.num(frame, count)
    if count == nil then
        if yesno(frame.args['fetch']) == false then
            if (frame.args[1] or '') ~= '' then count = tonumber(frame.args[1]) end
        else
            count = _fetch(frame)
        end
    end

    -- Build output string
    local return_value = ""
    if count == nil then
        if frame.args[1] == "risk" then
            return_value = "a very large number of"
        else
            return_value = "many"
        end
    else
        -- Use 2 significant figures for smaller numbers and 3 for larger ones
        local sigfig = 2
        if count &gt;= 100000 then
            sigfig = 3
        end

        -- Prepare to round to appropriate number of sigfigs
        local f = math.floor(math.log10(count)) - sigfig + 1

        -- Round and insert "approximately" or "+" when appropriate
        if (frame.args[2] == "yes") or (mw.ustring.sub(frame.args[1],-1) == "+") then
            -- Round down
            return_value = string.format("%s+", mw.getContentLanguage():formatNum(math.floor( (count / 10^(f)) ) * (10^(f))) )
        else
            -- Round to nearest
            return_value = string.format("approximately&amp;#x20;%s", mw.getContentLanguage():formatNum(math.floor( (count / 10^(f)) + 0.5) * (10^(f))) )
        end

        -- Insert percentage of pages if that is likely to be &gt;= 1% and when |no-percent= not set to yes
        if count and count &gt; 250000 and not yesno (frame:getParent().args['no-percent']) then
            local percent = math.floor( ( (count/frame:callParserFunction('NUMBEROFPAGES', 'R') ) * 100) + 0.5)
            if percent &gt;= 1 then
                return_value = string.format("%s&amp;#x20;pages, or roughly %s%% of all", return_value, percent)
            end
        end
    end

    return return_value
end
-- Actions if there is a large (greater than or equal to 100,000) transclusion count
function p.risk(frame)
    local return_value = ""
    if frame.args[1] == "risk" then
        return_value = "risk"
    else
        local count = _fetch(frame)
        if count and count &gt;= 100000 then return_value = "risk" end
    end
    return return_value
end

function p.text(frame, count)
    -- Only show the information about how this template gets updated if someone
    -- is actually editing the page and maybe trying to update the count.
    local bot_text = (frame:preprocess("{{REVISIONID}}") == "") and "\n\n----\n'''Preview message''': Transclusion count updated automatically ([[Template:High-use/doc#Technical details|see documentation]])." or ''

    if count == nil then
        if yesno(frame.args['fetch']) == false then
            if (frame.args[1] or '') ~= '' then count = tonumber(frame.args[1]) end
        else
            count = _fetch(frame)
        end
    end
    local title = mw.title.getCurrentTitle()
    if title.subpageText == "doc" or title.subpageText == "sandbox" then
        title = title.basePageTitle
    end

    local systemMessages = frame.args['system']
    if frame.args['system'] == '' then
        systemMessages = nil
    end

    -- This retrieves the project URL automatically to simplify localiation.
    local templateCount = ('on [https://linkcount.toolforge.org/index.php?project=%s&amp;page=%s %s pages]'):format(
        mw.title.getCurrentTitle():fullUrl():gsub('//(.-)/.*', '%1'),
        mw.uri.encode(title.fullText), p.num(frame, count))
    local used_on_text = "'''This " .. (mw.title.getCurrentTitle().namespace == 828 and "Lua module" or "template") .. ' is used ';
    if systemMessages then
        used_on_text = used_on_text .. systemMessages ..
            ((count and count &gt; 2000) and (",''' and " .. templateCount) or ("'''"))
    else
        used_on_text = used_on_text .. templateCount .. "'''"
    end


    local sandbox_text =  ("%s's [[%s/sandbox|/sandbox]] or [[%s/testcases|/testcases]] subpages, or in your own [[%s]]. "):format(
        (mw.title.getCurrentTitle().namespace == 828 and "module" or "template"),
        title.fullText, title.fullText,
        mw.title.getCurrentTitle().namespace == 828 and "Module:Sandbox|module sandbox" or "Wikipedia:User pages#SUB|user subpage"
    )

    local infoArg = frame.args["info"] ~= "" and frame.args["info"]
    if (systemMessages or frame.args[1] == "risk" or (count and count &gt;= 100000) ) then
        local info = systemMessages and '.&lt;br/&gt;Changes to it can cause immediate changes to the Wikipedia user interface.' or '.'
        if infoArg then
            info = info .. "&lt;br /&gt;" .. infoArg
        end
        sandbox_text = info .. '&lt;br /&gt; To avoid major disruption' ..
            (count and count &gt;= 100000 and ' and server load' or '') ..
            ', any changes should be tested in the ' .. sandbox_text ..
            'The tested changes can be added to this page in a single edit. '
    else
        sandbox_text = (infoArg and ('.&lt;br /&gt;' .. infoArg .. ' C') or ' and c') ..
            'hanges may be widely noticed. Test changes in the ' .. sandbox_text
    end


    local discussion_text = systemMessages and 'Please discuss changes ' or 'Consider discussing changes '
    if frame.args["2"] and frame.args["2"] ~= "" and frame.args["2"] ~= "yes" then
        discussion_text = string.format("%sat [[%s]]", discussion_text, frame.args["2"])
    else
        discussion_text = string.format("%son the [[%s|talk page]]", discussion_text, title.talkPageTitle.fullText )
    end

    return used_on_text .. sandbox_text .. discussion_text .. " before implementing them." .. bot_text
end

function p.main(frame)
    local count = nil
    if yesno(frame.args['fetch']) == false then
        if (frame.args[1] or '') ~= '' then count = tonumber(frame.args[1]) end
    else
        count = _fetch(frame)
    end
    local image = "[[File:Ambox warning yellow.svg|40px|alt=Warning|link=]]"
    local type_param = "style"
    local epilogue = ''
    if frame.args['system'] and frame.args['system'] ~= '' then
        image = "[[File:Ambox important.svg|40px|alt=Warning|link=]]"
        type_param = "content"
        local nocat = frame:getParent().args['nocat'] or frame.args['nocat']
        local categorise = (nocat == '' or not yesno(nocat))
        if categorise then
            epilogue = frame:preprocess('{{Sandbox other||{{#switch:{{#invoke:Effective protection level|{{#switch:{{NAMESPACE}}|File=upload|#default=edit}}|{{FULLPAGENAME}}}}|sysop|templateeditor|interfaceadmin=|#default=[[Category:Pages used in system messages needing protection]]}}}}')
        end
    elseif (frame.args[1] == "risk" or (count and count &gt;= 100000)) then
        image = "[[File:Ambox warning orange.svg|40px|alt=Warning|link=]]"
        type_param = "content"
    end

    if frame.args["form"] == "editnotice" then
        return frame:expandTemplate{
                title = 'editnotice',
                args = {
                        ["image"] = image,
                        ["text"] = p.text(frame, count),
                        ["expiry"] = (frame.args["expiry"] or "")
                }
        } .. epilogue
    else
        return require('Module:Message box').main('ombox', {
            type = type_param,
            image = image,
            text = p.text(frame, count),
            expiry = (frame.args["expiry"] or "")
        }) .. epilogue
    end
end

return p</text>
      <sha1>sy3y3omwgho4wnukvqxwejjpb2mjh3c</sha1>
    </revision>
  </page>
  <page>
    <title>Module:List</title>
    <ns>828</ns>
    <id>41068627</id>
    <revision>
      <id>915206629</id>
      <parentid>914636065</parentid>
      <timestamp>2019-09-11T21:05:14Z</timestamp>
      <contributor>
        <username>Paine Ellsworth</username>
        <id>9092818</id>
      </contributor>
      <comment>xfer from sandbox per edit request on talk page</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="5410" xml:space="preserve">-- This module outputs different kinds of lists. At the moment, bulleted,
-- unbulleted, horizontal, ordered, and horizontal ordered lists are supported.

local libUtil = require('libraryUtil')
local checkType = libUtil.checkType
local mTableTools = require('Module:TableTools')

local p = {}

local listTypes = {
    ['bulleted'] = true,
    ['unbulleted'] = true,
    ['horizontal'] = true,
    ['ordered'] = true,
    ['horizontal_ordered'] = true
}

function p.makeListData(listType, args)
    -- Constructs a data table to be passed to p.renderList.
    local data = {}

    -- Classes
    data.classes = {}
    if listType == 'horizontal' or listType == 'horizontal_ordered' then
        table.insert(data.classes, 'hlist hlist-separated')
    elseif listType == 'unbulleted' then
        table.insert(data.classes, 'plainlist')
    end
    table.insert(data.classes, args.class)

    -- Main div style
    data.style = args.style

    -- Indent for horizontal lists
    if listType == 'horizontal' or listType == 'horizontal_ordered' then
        local indent = tonumber(args.indent)
        indent = indent and indent * 1.6 or 0
        if indent &gt; 0 then
            data.marginLeft = indent .. 'em'
        end
    end

    -- List style types for ordered lists
    -- This could be "1, 2, 3", "a, b, c", or a number of others. The list style
    -- type is either set by the "type" attribute or the "list-style-type" CSS
    -- property.
    if listType == 'ordered' or listType == 'horizontal_ordered' then
        data.listStyleType = args.list_style_type or args['list-style-type']
        data.type = args['type']

        -- Detect invalid type attributes and attempt to convert them to
        -- list-style-type CSS properties.
        if data.type
            and not data.listStyleType
            and not tostring(data.type):find('^%s*[1AaIi]%s*$')
        then
            data.listStyleType = data.type
            data.type = nil
        end
    end

    -- List tag type
    if listType == 'ordered' or listType == 'horizontal_ordered' then
        data.listTag = 'ol'
    else
        data.listTag = 'ul'
    end

    -- Start number for ordered lists
    data.start = args.start
    if listType == 'horizontal_ordered' then
        -- Apply fix to get start numbers working with horizontal ordered lists.
        local startNum = tonumber(data.start)
        if startNum then
            data.counterReset = 'listitem ' .. tostring(startNum - 1)
        end
    end

    -- List style
     -- ul_style and ol_style are included for backwards compatibility. No
     -- distinction is made for ordered or unordered lists.
    data.listStyle = args.list_style

    -- List items
    -- li_style is included for backwards compatibility. item_style was included
    -- to be easier to understand for non-coders.
    data.itemStyle = args.item_style or args.li_style
    data.items = {}
    for i, num in ipairs(mTableTools.numKeys(args)) do
        local item = {}
        item.content = args[num]
        item.style = args['item' .. tostring(num) .. '_style']
            or args['item_style' .. tostring(num)]
        item.value = args['item' .. tostring(num) .. '_value']
            or args['item_value' .. tostring(num)]
        table.insert(data.items, item)
    end

    return data
end

function p.renderList(data)
    -- Renders the list HTML.

    -- Return the blank string if there are no list items.
    if type(data.items) ~= 'table' or #data.items &lt; 1 then
        return ''
    end

    -- Render the main div tag.
    local root = mw.html.create('div')
    for i, class in ipairs(data.classes or {}) do
        root:addClass(class)
    end
    root:css{['margin-left'] = data.marginLeft}
    if data.style then
        root:cssText(data.style)
    end

    -- Render the list tag.
    local list = root:tag(data.listTag or 'ul')
    list
        :attr{start = data.start, type = data.type}
        :css{
            ['counter-reset'] = data.counterReset,
            ['list-style-type'] = data.listStyleType
        }
    if data.listStyle then
        list:cssText(data.listStyle)
    end

    -- Render the list items
    for i, t in ipairs(data.items or {}) do
        local item = list:tag('li')
        if data.itemStyle then
            item:cssText(data.itemStyle)
        end
        if t.style then
            item:cssText(t.style)
        end
        item
            :attr{value = t.value}
            :wikitext(t.content)
    end

    return tostring(root)
end

function p.renderTrackingCategories(args)
    local isDeprecated = false -- Tracks deprecated parameters.
    for k, v in pairs(args) do
        k = tostring(k)
        if k:find('^item_style%d+$') or k:find('^item_value%d+$') then
            isDeprecated = true
            break
        end
    end
    local ret = ''
    if isDeprecated then
        ret = ret .. '[[Category:List templates with deprecated parameters]]'
    end
    return ret
end

function p.makeList(listType, args)
    if not listType or not listTypes[listType] then
        error(string.format(
            "bad argument #1 to 'makeList' ('%s' is not a valid list type)",
            tostring(listType)
        ), 2)
    end
    checkType('makeList', 2, args, 'table')
    local data = p.makeListData(listType, args)
    local list = p.renderList(data)
    local trackingCategories = p.renderTrackingCategories(args)
    return list .. trackingCategories
end

for listType in pairs(listTypes) do
    p[listType] = function (frame)
        local mArguments = require('Module:Arguments')
        local origArgs = mArguments.getArgs(frame, {
            valueFunc = function (key, value)
            if not value or not mw.ustring.find(value, '%S') then return nil end
            if mw.ustring.find(value, '^%s*[%*#;:]') then
                return value
            else
                return value:match('^%s*(.-)%s*$')
            end
            return nil
        end
        })
        -- Copy all the arguments to a new table, for faster indexing.
        local args = {}
        for k, v in pairs(origArgs) do
            args[k] = v
        end
        return p.makeList(listType, args)
    end
end

return p</text>
      <sha1>1kfxv6e8upfdko23gc41ky0lax25kzs</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Lua banner</title>
    <ns>828</ns>
    <id>42951651</id>
    <revision>
      <id>1059679087</id>
      <parentid>1043920761</parentid>
      <timestamp>2021-12-10T22:30:39Z</timestamp>
      <contributor>
        <username>Fayenatic london</username>
        <id>1639942</id>
      </contributor>
      <comment>Update categories, see [[Wikipedia:Categories for discussion/Log/2021 October 31]]</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="3904" xml:space="preserve">-- This module implements the {{lua}} template.
local yesno = require('Module:Yesno')
local mList = require('Module:List')
local mTableTools = require('Module:TableTools')
local mMessageBox = require('Module:Message box')

local p = {}

function p.main(frame)
    local origArgs = frame:getParent().args
    local args = {}
    for k, v in pairs(origArgs) do
        v = v:match('^%s*(.-)%s*$')
        if v ~= '' then
            args[k] = v
        end
    end
    return p._main(args)
end

function p._main(args)
    local modules = mTableTools.compressSparseArray(args)
    local box = p.renderBox(modules)
    local trackingCategories = p.renderTrackingCategories(args, modules)
    return box .. trackingCategories
end

function p.renderBox(modules)
    local boxArgs = {}
    if #modules &lt; 1 then
        boxArgs.text = '&lt;strong class="error"&gt;Error: no modules specified&lt;/strong&gt;'
    else
        local moduleLinks = {}
        for i, module in ipairs(modules) do
            moduleLinks[i] = string.format('[[:%s]]', module)
            local maybeSandbox = mw.title.new(module .. '/sandbox')
            if maybeSandbox.exists then
                moduleLinks[i] = moduleLinks[i] .. string.format(' ([[:%s|sandbox]])', maybeSandbox.fullText)
            end
        end
        local moduleList = mList.makeList('bulleted', moduleLinks)
        local title = mw.title.getCurrentTitle()
        if title.subpageText == "doc" then
            title = title.basePageTitle
        end
        if title.contentModel == "Scribunto" then
            boxArgs.text = 'This module depends on the following other modules:' .. moduleList
        else
            boxArgs.text = 'This template  uses [[Wikipedia:Lua|Lua]]:\n' .. moduleList
        end
    end
    boxArgs.type = 'notice'
    boxArgs.small = true
    boxArgs.image = '[[File:Lua-Logo.svg|30px|alt=|link=]]'
    return mMessageBox.main('mbox', boxArgs)
end

function p.renderTrackingCategories(args, modules, titleObj)
    if yesno(args.nocat) then
        return ''
    end

    local cats = {}

    -- Error category
    if #modules &lt; 1 then
        cats[#cats + 1] = 'Lua templates with errors'
    end

    -- Lua templates category
    titleObj = titleObj or mw.title.getCurrentTitle()
    local subpageBlacklist = {
        doc = true,
        sandbox = true,
        sandbox2 = true,
        testcases = true
    }
    if not subpageBlacklist[titleObj.subpageText] then
        local protCatName
        if titleObj.namespace == 10 then
            local category = args.category
            if not category then
                local categories = {
                    ['Module:String'] = 'Templates based on the String Lua module',
                    ['Module:Math'] = 'Templates based on the Math Lua module',
                    ['Module:BaseConvert'] = 'Templates based on the BaseConvert Lua module',
                    ['Module:Citation'] = 'Templates based on the Citation/CS1 Lua module'
                }
                categories['Module:Citation/CS1'] = categories['Module:Citation']
                category = modules[1] and categories[modules[1]]
                category = category or 'Lua-based templates'
            end
            cats[#cats + 1] = category
            protCatName = "Templates using under-protected Lua modules"
        elseif titleObj.namespace == 828 then
            protCatName = "Modules depending on under-protected modules"
        end
        if not args.noprotcat and protCatName then
            local protLevels = {
                autoconfirmed = 1,
                extendedconfirmed = 2,
                templateeditor = 3,
                sysop = 4
            }
            local currentProt
            if titleObj.id ~= 0 then
                -- id is 0 (page does not exist) if am previewing before creating a template.
                currentProt = titleObj.protectionLevels["edit"][1]
            end
            if currentProt == nil then currentProt = 0 else currentProt = protLevels[currentProt] end
            for i, module in ipairs(modules) do
                if module ~= "WP:libraryUtil" then
                    local moduleProt = mw.title.new(module).protectionLevels["edit"][1]
                    if moduleProt == nil then moduleProt = 0 else moduleProt = protLevels[moduleProt] end
                    if moduleProt &lt; currentProt then
                        cats[#cats + 1] = protCatName
                        break
                    end
                end
            end
        end
    end
    for i, cat in ipairs(cats) do
        cats[i] = string.format('[[Category:%s]]', cat)
    end
    return table.concat(cats)
end

return p</text>
      <sha1>cvk1cpv9jtriqu1hfkfklnnsm49md8l</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Message box/doc</title>
    <ns>828</ns>
    <id>40677928</id>
    <revision>
      <id>1051963995</id>
      <parentid>1051901519</parentid>
      <timestamp>2021-10-26T15:50:54Z</timestamp>
      <contributor>
        <username>Pppery</username>
        <id>28032115</id>
      </contributor>
      <comment>Ugh, more undetected vandalism</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="5323" xml:space="preserve">{{Used in system}}
{{module rating|p}}
{{Lua|Module:Message box/configuration|Module:No globals|Module:Yesno|Module:Arguments|Module:Category handler}}

This is a meta-module that implements the message box templates {{tl|mbox}}, {{tl|ambox}}, {{tl|cmbox}}, {{tl|fmbox}}, {{tl|imbox}}, {{tl|ombox}}, and {{tl|tmbox}}. It is intended to be used from Lua modules, and should not be used directly from wiki pages. If you want to use this module's functionality from a wiki page, please use the individual message box templates instead.

== Usage ==

To use this module from another Lua module, first you need to load it.

&lt;syntaxhighlight lang="lua"&gt;
local messageBox = require('Module:Message box')
&lt;/syntaxhighlight&gt;

To create a message box, use the &lt;code&gt;main&lt;/code&gt; function. It takes two parameters: the first is the box type (as a string), and the second is a table containing the message box parameters.

&lt;syntaxhighlight lang="lua"&gt;
local box = messageBox.main( boxType, {
    param1 = param1,
    param2 = param2,
    -- More parameters...
})
&lt;/syntaxhighlight&gt;

There are seven available box types:

{| class="wikitable"
! Box type !! Template !! Purpose
|-
| &lt;code&gt;mbox&lt;/code&gt; || {{tl|mbox}} || For message boxes to be used in multiple namespaces
|-
| &lt;code&gt;ambox&lt;/code&gt; || {{tl|ambox}} || For article message boxes
|-
| &lt;code&gt;cmbox&lt;/code&gt; || {{tl|cmbox}} || For category message boxes
|-
| &lt;code&gt;fmbox&lt;/code&gt; || {{tl|fmbox}} || For interface message boxes
|-
| &lt;code&gt;imbox&lt;/code&gt; || {{tl|imbox}} || For file namespace message boxes
|-
| &lt;code&gt;tmbox&lt;/code&gt; || {{tl|tmbox}} || For talk page message boxes
|-
| &lt;code&gt;ombox&lt;/code&gt; || {{tl|ombox}} || For message boxes in other namespaces
|}

See the template page of each box type for the available parameters.

== Usage from #invoke ==

As well as the &lt;code&gt;main&lt;/code&gt; function, this module has separate functions for each box type. They are accessed using the code &lt;code&gt;&lt;nowiki&gt;{{#invoke:Message box|mbox|...}}&lt;/nowiki&gt;&lt;/code&gt;, &lt;code&gt;&lt;nowiki&gt;{{#invoke:Message box|ambox|...}}&lt;/nowiki&gt;&lt;/code&gt;, etc. These will work when called from other modules, but they access code used to process arguments passed from #invoke, and so calling them will be less efficient than calling &lt;code&gt;main&lt;/code&gt;.

== Technical details ==

The module uses the same basic code for each of the templates listed above; the differences between each of them are configured using the data at [[Module:Message box/configuration]]. Here are the various configuration options and what they mean:

* &lt;code&gt;types&lt;/code&gt; – a table containing data used by the type parameter of the message box. The table keys are the values that can be passed to the type parameter, and the table values are tables containing the class and the image used by that type.
* &lt;code&gt;default&lt;/code&gt; – the type to use if no value was passed to the type parameter, or if an invalid value was specified.
* &lt;code&gt;showInvalidTypeError&lt;/code&gt; – whether to show an error if the value passed to the type parameter was invalid.
* &lt;code&gt;allowBlankParams&lt;/code&gt; – usually blank values are stripped from parameters passed to the module. However, whitespace is preserved for the parameters included in the allowBlankParams table.
* &lt;code&gt;allowSmall&lt;/code&gt; – whether a small version of the message box can be produced with "small=yes".
* &lt;code&gt;smallParam&lt;/code&gt; – a custom name for the small parameter. For example, if set to "left" you can produce a small message box using "small=left".
* &lt;code&gt;smallClass&lt;/code&gt; – the class to use for small message boxes.
* &lt;code&gt;substCheck&lt;/code&gt; – whether to perform a subst check or not.
* &lt;code&gt;classes&lt;/code&gt; – an array of classes to use with the message box.
* &lt;code&gt;imageEmptyCell&lt;/code&gt; – whether to use an empty {{tag|td}} cell if there is no image set. This is used to preserve spacing for message boxes with a width of less than 100% of the screen.
* &lt;code&gt;imageEmptyCellStyle&lt;/code&gt; – whether empty image cells should be styled.
* &lt;code&gt;imageCheckBlank&lt;/code&gt; – whether "image=blank" results in no image being displayed.
* &lt;code&gt;imageSmallSize&lt;/code&gt; – usually, images used in small message boxes are set to 30x30px. This sets a custom size.
* &lt;code&gt;imageCellDiv&lt;/code&gt; – whether to enclose the image in a div enforcing a maximum image size.
* &lt;code&gt;useCollapsibleTextFields&lt;/code&gt; – whether to use text fields that can be collapsed, i.e. "issue", "fix", "talk", etc. Currently only used in ambox.
* &lt;code&gt;imageRightNone&lt;/code&gt; – whether imageright=none results in no image being displayed on the right-hand side of the message box.
* &lt;code&gt;sectionDefault&lt;/code&gt; – the default name for the "section" parameter. Depends on &lt;code&gt;useCollapsibleTextFields&lt;/code&gt;.
* &lt;code&gt;allowMainspaceCategories&lt;/code&gt; – allow categorisation in the main namespace.
* &lt;code&gt;templateCategory&lt;/code&gt; – the name of a category to be placed on the template page.
* &lt;code&gt;templateCategoryRequireName&lt;/code&gt; – whether the &lt;code&gt;name&lt;/code&gt; parameter is required to display the template category.
* &lt;code&gt;templateErrorCategory&lt;/code&gt; – the name of the error category to be used on the template page.
* &lt;code&gt;templateErrorParamsToCheck&lt;/code&gt; – an array of parameter names to check. If any are absent, the &lt;code&gt;templateErrorCategory&lt;/code&gt; is applied to the template page.</text>
      <sha1>gylas5sr0c7uo5g3nrxklnd0k774pvd</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Protection banner</title>
    <ns>828</ns>
    <id>42040984</id>
    <revision>
      <id>1033879006</id>
      <parentid>1013845490</parentid>
      <timestamp>2021-07-16T11:59:29Z</timestamp>
      <contributor>
        <username>ProcrastinatingReader</username>
        <id>32939139</id>
      </contributor>
      <comment>add catonly param which hides both the banner and padlock if set to yes. all testcases pass. tested in sandbox.</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="26029" xml:space="preserve">-- This module implements {{pp-meta}} and its daughter templates such as
-- {{pp-dispute}}, {{pp-vandalism}} and {{pp-sock}}.

-- Initialise necessary modules.
require('Module:No globals')
local makeFileLink = require('Module:File link')._main
local effectiveProtectionLevel = require('Module:Effective protection level')._main
local effectiveProtectionExpiry = require('Module:Effective protection expiry')._main
local yesno = require('Module:Yesno')

-- Lazily initialise modules and objects we don't always need.
local getArgs, makeMessageBox, lang

-- Set constants.
local CONFIG_MODULE = 'Module:Protection banner/config'

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

local function makeCategoryLink(cat, sort)
    if cat then
        return string.format(
            '[[%s:%s|%s]]',
            mw.site.namespaces[14].name,
            cat,
            sort
        )
    end
end

-- Validation function for the expiry and the protection date
local function validateDate(dateString, dateType)
    if not lang then
        lang = mw.language.getContentLanguage()
    end
    local success, result = pcall(lang.formatDate, lang, 'U', dateString)
    if success then
        result = tonumber(result)
        if result then
            return result
        end
    end
    error(string.format(
        'invalid %s: %s',
        dateType,
        tostring(dateString)
    ), 4)
end

local function makeFullUrl(page, query, display)
    return string.format(
        '[%s %s]',
        tostring(mw.uri.fullUrl(page, query)),
        display
    )
end

-- Given a directed graph formatted as node -&gt; table of direct successors,
-- get a table of all nodes reachable from a given node (though always
-- including the given node).
local function getReachableNodes(graph, start)
    local toWalk, retval = {[start] = true}, {}
    while true do
        -- Can't use pairs() since we're adding and removing things as we're iterating
        local k = next(toWalk) -- This always gets the "first" key
        if k == nil then
            return retval
        end
        toWalk[k] = nil
        retval[k] = true
        for _,v in ipairs(graph[k]) do
            if not retval[v] then
                toWalk[v] = true
            end
        end
    end
end

--------------------------------------------------------------------------------
-- Protection class
--------------------------------------------------------------------------------

local Protection = {}
Protection.__index = Protection

Protection.supportedActions = {
    edit = true,
    move = true,
    autoreview = true,
    upload = true
}

Protection.bannerConfigFields = {
    'text',
    'explanation',
    'tooltip',
    'alt',
    'link',
    'image'
}

function Protection.new(args, cfg, title)
    local obj = {}
    obj._cfg = cfg
    obj.title = title or mw.title.getCurrentTitle()

    -- Set action
    if not args.action then
        obj.action = 'edit'
    elseif Protection.supportedActions[args.action] then
        obj.action = args.action
    else
        error(string.format(
            'invalid action: %s',
            tostring(args.action)
        ), 3)
    end

    -- Set level
    obj.level = args.demolevel or effectiveProtectionLevel(obj.action, obj.title)
    if not obj.level or (obj.action == 'move' and obj.level == 'autoconfirmed') then
        -- Users need to be autoconfirmed to move pages anyway, so treat
        -- semi-move-protected pages as unprotected.
        obj.level = '*'
    end

    -- Set expiry
    local effectiveExpiry = effectiveProtectionExpiry(obj.action, obj.title)
    if effectiveExpiry == 'infinity' then
        obj.expiry = 'indef'
    elseif effectiveExpiry ~= 'unknown' then
        obj.expiry = validateDate(effectiveExpiry, 'expiry date')
    end

    -- Set reason
    if args[1] then
        obj.reason = mw.ustring.lower(args[1])
        if obj.reason:find('|') then
            error('reasons cannot contain the pipe character ("|")', 3)
        end
    end

    -- Set protection date
    if args.date then
        obj.protectionDate = validateDate(args.date, 'protection date')
    end

    -- Set banner config
    do
        obj.bannerConfig = {}
        local configTables = {}
        if cfg.banners[obj.action] then
            configTables[#configTables + 1] = cfg.banners[obj.action][obj.reason]
        end
        if cfg.defaultBanners[obj.action] then
            configTables[#configTables + 1] = cfg.defaultBanners[obj.action][obj.level]
            configTables[#configTables + 1] = cfg.defaultBanners[obj.action].default
        end
        configTables[#configTables + 1] = cfg.masterBanner
        for i, field in ipairs(Protection.bannerConfigFields) do
            for j, t in ipairs(configTables) do
                if t[field] then
                    obj.bannerConfig[field] = t[field]
                    break
                end
            end
        end
    end
    return setmetatable(obj, Protection)
end

function Protection:isUserScript()
    -- Whether the page is a user JavaScript or CSS page.
    local title = self.title
    return title.namespace == 2 and (
        title.contentModel == 'javascript' or title.contentModel == 'css'
    )
end

function Protection:isProtected()
    return self.level ~= '*'
end

function Protection:shouldShowLock()
    -- Whether we should output a banner/padlock
    return self:isProtected() and not self:isUserScript()
end

-- Whether this page needs a protection category.
Protection.shouldHaveProtectionCategory = Protection.shouldShowLock

function Protection:isTemporary()
    return type(self.expiry) == 'number'
end

function Protection:makeProtectionCategory()
    if not self:shouldHaveProtectionCategory() then
        return ''
    end

    local cfg = self._cfg
    local title = self.title

    -- Get the expiry key fragment.
    local expiryFragment
    if self.expiry == 'indef' then
        expiryFragment = self.expiry
    elseif type(self.expiry) == 'number' then
        expiryFragment = 'temp'
    end

    -- Get the namespace key fragment.
    local namespaceFragment = cfg.categoryNamespaceKeys[title.namespace]
    if not namespaceFragment and title.namespace % 2 == 1 then
            namespaceFragment = 'talk'
    end

    -- Define the order that key fragments are tested in. This is done with an
    -- array of tables containing the value to be tested, along with its
    -- position in the cfg.protectionCategories table.
    local order = {
        {val = expiryFragment,    keypos = 1},
        {val = namespaceFragment, keypos = 2},
        {val = self.reason,       keypos = 3},
        {val = self.level,        keypos = 4},
        {val = self.action,       keypos = 5}
    }

    --[[
    -- The old protection templates used an ad-hoc protection category system,
    -- with some templates prioritising namespaces in their categories, and
    -- others prioritising the protection reason. To emulate this in this module
    -- we use the config table cfg.reasonsWithNamespacePriority to set the
    -- reasons for which namespaces have priority over protection reason.
    -- If we are dealing with one of those reasons, move the namespace table to
    -- the end of the order table, i.e. give it highest priority. If not, the
    -- reason should have highest priority, so move that to the end of the table
    -- instead.
    --]]
    table.insert(order, table.remove(order, self.reason and cfg.reasonsWithNamespacePriority[self.reason] and 2 or 3))

    --[[
    -- Define the attempt order. Inactive subtables (subtables with nil "value"
    -- fields) are moved to the end, where they will later be given the key
    -- "all". This is to cut down on the number of table lookups in
    -- cfg.protectionCategories, which grows exponentially with the number of
    -- non-nil keys. We keep track of the number of active subtables with the
    -- noActive parameter.
    --]]
    local noActive, attemptOrder
    do
        local active, inactive = {}, {}
        for i, t in ipairs(order) do
            if t.val then
                active[#active + 1] = t
            else
                inactive[#inactive + 1] = t
            end
        end
        noActive = #active
        attemptOrder = active
        for i, t in ipairs(inactive) do
            attemptOrder[#attemptOrder + 1] = t
        end
    end

    --[[
    -- Check increasingly generic key combinations until we find a match. If a
    -- specific category exists for the combination of key fragments we are
    -- given, that match will be found first. If not, we keep trying different
    -- key fragment combinations until we match using the key
    -- "all-all-all-all-all".
    --
    -- To generate the keys, we index the key subtables using a binary matrix
    -- with indexes i and j. j is only calculated up to the number of active
    -- subtables. For example, if there were three active subtables, the matrix
    -- would look like this, with 0 corresponding to the key fragment "all", and
    -- 1 corresponding to other key fragments.
    --
    --   j 1  2  3
    -- i
    -- 1   1  1  1
    -- 2   0  1  1
    -- 3   1  0  1
    -- 4   0  0  1
    -- 5   1  1  0
    -- 6   0  1  0
    -- 7   1  0  0
    -- 8   0  0  0
    --
    -- Values of j higher than the number of active subtables are set
    -- to the string "all".
    --
    -- A key for cfg.protectionCategories is constructed for each value of i.
    -- The position of the value in the key is determined by the keypos field in
    -- each subtable.
    --]]
    local cats = cfg.protectionCategories
    for i = 1, 2^noActive do
        local key = {}
        for j, t in ipairs(attemptOrder) do
            if j &gt; noActive then
                key[t.keypos] = 'all'
            else
                local quotient = i / 2 ^ (j - 1)
                quotient = math.ceil(quotient)
                if quotient % 2 == 1 then
                    key[t.keypos] = t.val
                else
                    key[t.keypos] = 'all'
                end
            end
        end
        key = table.concat(key, '|')
        local attempt = cats[key]
        if attempt then
            return makeCategoryLink(attempt, title.text)
        end
    end
    return ''
end

function Protection:isIncorrect()
    local expiry = self.expiry
    return not self:shouldHaveProtectionCategory()
        or type(expiry) == 'number' and expiry &lt; os.time()
end

function Protection:isTemplateProtectedNonTemplate()
    local action, namespace = self.action, self.title.namespace
    return self.level == 'templateeditor'
        and (
            (action ~= 'edit' and action ~= 'move')
            or (namespace ~= 10 and namespace ~= 828)
        )
end

function Protection:makeCategoryLinks()
    local msg = self._cfg.msg
    local ret = {self:makeProtectionCategory()}
    if self:isIncorrect() then
        ret[#ret + 1] = makeCategoryLink(
            msg['tracking-category-incorrect'],
            self.title.text
        )
    end
    if self:isTemplateProtectedNonTemplate() then
        ret[#ret + 1] = makeCategoryLink(
            msg['tracking-category-template'],
            self.title.text
        )
    end
    return table.concat(ret)
end

--------------------------------------------------------------------------------
-- Blurb class
--------------------------------------------------------------------------------

local Blurb = {}
Blurb.__index = Blurb

Blurb.bannerTextFields = {
    text = true,
    explanation = true,
    tooltip = true,
    alt = true,
    link = true
}

function Blurb.new(protectionObj, args, cfg)
    return setmetatable({
        _cfg = cfg,
        _protectionObj = protectionObj,
        _args = args
    }, Blurb)
end

-- Private methods --

function Blurb:_formatDate(num)
    -- Formats a Unix timestamp into dd Month, YYYY format.
    lang = lang or mw.language.getContentLanguage()
    local success, date = pcall(
        lang.formatDate,
        lang,
        self._cfg.msg['expiry-date-format'] or 'j F Y',
        '@' .. tostring(num)
    )
    if success then
        return date
    end
end

function Blurb:_getExpandedMessage(msgKey)
    return self:_substituteParameters(self._cfg.msg[msgKey])
end

function Blurb:_substituteParameters(msg)
    if not self._params then
        local parameterFuncs = {}

        parameterFuncs.CURRENTVERSION     = self._makeCurrentVersionParameter
        parameterFuncs.EDITREQUEST        = self._makeEditRequestParameter
        parameterFuncs.EXPIRY             = self._makeExpiryParameter
        parameterFuncs.EXPLANATIONBLURB   = self._makeExplanationBlurbParameter
        parameterFuncs.IMAGELINK          = self._makeImageLinkParameter
        parameterFuncs.INTROBLURB         = self._makeIntroBlurbParameter
        parameterFuncs.INTROFRAGMENT      = self._makeIntroFragmentParameter
        parameterFuncs.PAGETYPE           = self._makePagetypeParameter
        parameterFuncs.PROTECTIONBLURB    = self._makeProtectionBlurbParameter
        parameterFuncs.PROTECTIONDATE     = self._makeProtectionDateParameter
        parameterFuncs.PROTECTIONLEVEL    = self._makeProtectionLevelParameter
        parameterFuncs.PROTECTIONLOG      = self._makeProtectionLogParameter
        parameterFuncs.TALKPAGE           = self._makeTalkPageParameter
        parameterFuncs.TOOLTIPBLURB       = self._makeTooltipBlurbParameter
        parameterFuncs.TOOLTIPFRAGMENT    = self._makeTooltipFragmentParameter
        parameterFuncs.VANDAL             = self._makeVandalTemplateParameter

        self._params = setmetatable({}, {
            __index = function (t, k)
                local param
                if parameterFuncs[k] then
                    param = parameterFuncs[k](self)
                end
                param = param or ''
                t[k] = param
                return param
            end
        })
    end

    msg = msg:gsub('${(%u+)}', self._params)
    return msg
end

function Blurb:_makeCurrentVersionParameter()
    -- A link to the page history or the move log, depending on the kind of
    -- protection.
    local pagename = self._protectionObj.title.prefixedText
    if self._protectionObj.action == 'move' then
        -- We need the move log link.
        return makeFullUrl(
            'Special:Log',
            {type = 'move', page = pagename},
            self:_getExpandedMessage('current-version-move-display')
        )
    else
        -- We need the history link.
        return makeFullUrl(
            pagename,
            {action = 'history'},
            self:_getExpandedMessage('current-version-edit-display')
        )
    end
end

function Blurb:_makeEditRequestParameter()
    local mEditRequest = require('Module:Submit an edit request')
    local action = self._protectionObj.action
    local level = self._protectionObj.level

    -- Get the edit request type.
    local requestType
    if action == 'edit' then
        if level == 'autoconfirmed' then
            requestType = 'semi'
        elseif level == 'extendedconfirmed' then
            requestType = 'extended'
        elseif level == 'templateeditor' then
            requestType = 'template'
        end
    end
    requestType = requestType or 'full'

    -- Get the display value.
    local display = self:_getExpandedMessage('edit-request-display')

    return mEditRequest._link{type = requestType, display = display}
end

function Blurb:_makeExpiryParameter()
    local expiry = self._protectionObj.expiry
    if type(expiry) == 'number' then
        return self:_formatDate(expiry)
    else
        return expiry
    end
end

function Blurb:_makeExplanationBlurbParameter()
    -- Cover special cases first.
    if self._protectionObj.title.namespace == 8 then
        -- MediaWiki namespace
        return self:_getExpandedMessage('explanation-blurb-nounprotect')
    end

    -- Get explanation blurb table keys
    local action = self._protectionObj.action
    local level = self._protectionObj.level
    local talkKey = self._protectionObj.title.isTalkPage and 'talk' or 'subject'

    -- Find the message in the explanation blurb table and substitute any
    -- parameters.
    local explanations = self._cfg.explanationBlurbs
    local msg
    if explanations[action][level] and explanations[action][level][talkKey] then
        msg = explanations[action][level][talkKey]
    elseif explanations[action][level] and explanations[action][level].default then
        msg = explanations[action][level].default
    elseif explanations[action].default and explanations[action].default[talkKey] then
        msg = explanations[action].default[talkKey]
    elseif explanations[action].default and explanations[action].default.default then
        msg = explanations[action].default.default
    else
        error(string.format(
            'could not find explanation blurb for action "%s", level "%s" and talk key "%s"',
            action,
            level,
            talkKey
        ), 8)
    end
    return self:_substituteParameters(msg)
end

function Blurb:_makeImageLinkParameter()
    local imageLinks = self._cfg.imageLinks
    local action = self._protectionObj.action
    local level = self._protectionObj.level
    local msg
    if imageLinks[action][level] then
        msg = imageLinks[action][level]
    elseif imageLinks[action].default then
        msg = imageLinks[action].default
    else
        msg = imageLinks.edit.default
    end
    return self:_substituteParameters(msg)
end

function Blurb:_makeIntroBlurbParameter()
    if self._protectionObj:isTemporary() then
        return self:_getExpandedMessage('intro-blurb-expiry')
    else
        return self:_getExpandedMessage('intro-blurb-noexpiry')
    end
end

function Blurb:_makeIntroFragmentParameter()
    if self._protectionObj:isTemporary() then
        return self:_getExpandedMessage('intro-fragment-expiry')
    else
        return self:_getExpandedMessage('intro-fragment-noexpiry')
    end
end

function Blurb:_makePagetypeParameter()
    local pagetypes = self._cfg.pagetypes
    return pagetypes[self._protectionObj.title.namespace]
        or pagetypes.default
        or error('no default pagetype defined', 8)
end

function Blurb:_makeProtectionBlurbParameter()
    local protectionBlurbs = self._cfg.protectionBlurbs
    local action = self._protectionObj.action
    local level = self._protectionObj.level
    local msg
    if protectionBlurbs[action][level] then
        msg = protectionBlurbs[action][level]
    elseif protectionBlurbs[action].default then
        msg = protectionBlurbs[action].default
    elseif protectionBlurbs.edit.default then
        msg = protectionBlurbs.edit.default
    else
        error('no protection blurb defined for protectionBlurbs.edit.default', 8)
    end
    return self:_substituteParameters(msg)
end

function Blurb:_makeProtectionDateParameter()
    local protectionDate = self._protectionObj.protectionDate
    if type(protectionDate) == 'number' then
        return self:_formatDate(protectionDate)
    else
        return protectionDate
    end
end

function Blurb:_makeProtectionLevelParameter()
    local protectionLevels = self._cfg.protectionLevels
    local action = self._protectionObj.action
    local level = self._protectionObj.level
    local msg
    if protectionLevels[action][level] then
        msg = protectionLevels[action][level]
    elseif protectionLevels[action].default then
        msg = protectionLevels[action].default
    elseif protectionLevels.edit.default then
        msg = protectionLevels.edit.default
    else
        error('no protection level defined for protectionLevels.edit.default', 8)
    end
    return self:_substituteParameters(msg)
end

function Blurb:_makeProtectionLogParameter()
    local pagename = self._protectionObj.title.prefixedText
    if self._protectionObj.action == 'autoreview' then
        -- We need the pending changes log.
        return makeFullUrl(
            'Special:Log',
            {type = 'stable', page = pagename},
            self:_getExpandedMessage('pc-log-display')
        )
    else
        -- We need the protection log.
        return makeFullUrl(
            'Special:Log',
            {type = 'protect', page = pagename},
            self:_getExpandedMessage('protection-log-display')
        )
    end
end

function Blurb:_makeTalkPageParameter()
    return string.format(
        '[[%s:%s#%s|%s]]',
        mw.site.namespaces[self._protectionObj.title.namespace].talk.name,
        self._protectionObj.title.text,
        self._args.section or 'top',
        self:_getExpandedMessage('talk-page-link-display')
    )
end

function Blurb:_makeTooltipBlurbParameter()
    if self._protectionObj:isTemporary() then
        return self:_getExpandedMessage('tooltip-blurb-expiry')
    else
        return self:_getExpandedMessage('tooltip-blurb-noexpiry')
    end
end

function Blurb:_makeTooltipFragmentParameter()
    if self._protectionObj:isTemporary() then
        return self:_getExpandedMessage('tooltip-fragment-expiry')
    else
        return self:_getExpandedMessage('tooltip-fragment-noexpiry')
    end
end

function Blurb:_makeVandalTemplateParameter()
    return mw.getCurrentFrame():expandTemplate{
        title="vandal-m",
        args={self._args.user or self._protectionObj.title.baseText}
    }
end

-- Public methods --

function Blurb:makeBannerText(key)
    -- Validate input.
    if not key or not Blurb.bannerTextFields[key] then
        error(string.format(
            '"%s" is not a valid banner config field',
            tostring(key)
        ), 2)
    end

    -- Generate the text.
    local msg = self._protectionObj.bannerConfig[key]
    if type(msg) == 'string' then
        return self:_substituteParameters(msg)
    elseif type(msg) == 'function' then
        msg = msg(self._protectionObj, self._args)
        if type(msg) ~= 'string' then
            error(string.format(
                'bad output from banner config function with key "%s"'
                    .. ' (expected string, got %s)',
                tostring(key),
                type(msg)
            ), 4)
        end
        return self:_substituteParameters(msg)
    end
end

--------------------------------------------------------------------------------
-- BannerTemplate class
--------------------------------------------------------------------------------

local BannerTemplate = {}
BannerTemplate.__index = BannerTemplate

function BannerTemplate.new(protectionObj, cfg)
    local obj = {}
    obj._cfg = cfg

    -- Set the image filename.
    local imageFilename = protectionObj.bannerConfig.image
    if imageFilename then
        obj._imageFilename = imageFilename
    else
        -- If an image filename isn't specified explicitly in the banner config,
        -- generate it from the protection status and the namespace.
        local action = protectionObj.action
        local level = protectionObj.level
        local namespace = protectionObj.title.namespace
        local reason = protectionObj.reason

        -- Deal with special cases first.
        if (
            namespace == 10
            or namespace == 828
            or reason and obj._cfg.indefImageReasons[reason]
            )
            and action == 'edit'
            and level == 'sysop'
            and not protectionObj:isTemporary()
        then
            -- Fully protected modules and templates get the special red "indef"
            -- padlock.
            obj._imageFilename = obj._cfg.msg['image-filename-indef']
        else
            -- Deal with regular protection types.
            local images = obj._cfg.images
            if images[action] then
                if images[action][level] then
                    obj._imageFilename = images[action][level]
                elseif images[action].default then
                    obj._imageFilename = images[action].default
                end
            end
        end
    end
    return setmetatable(obj, BannerTemplate)
end

function BannerTemplate:renderImage()
    local filename = self._imageFilename
        or self._cfg.msg['image-filename-default']
        or 'Transparent.gif'
    return makeFileLink{
        file = filename,
        size = (self.imageWidth or 20) .. 'px',
        alt = self._imageAlt,
        link = self._imageLink,
        caption = self.imageCaption
    }
end

--------------------------------------------------------------------------------
-- Banner class
--------------------------------------------------------------------------------

local Banner = setmetatable({}, BannerTemplate)
Banner.__index = Banner

function Banner.new(protectionObj, blurbObj, cfg)
    local obj = BannerTemplate.new(protectionObj, cfg) -- This doesn't need the blurb.
    obj.imageWidth = 40
    obj.imageCaption = blurbObj:makeBannerText('alt') -- Large banners use the alt text for the tooltip.
    obj._reasonText = blurbObj:makeBannerText('text')
    obj._explanationText = blurbObj:makeBannerText('explanation')
    obj._page = protectionObj.title.prefixedText -- Only makes a difference in testing.
    return setmetatable(obj, Banner)
end

function Banner:__tostring()
    -- Renders the banner.
    makeMessageBox = makeMessageBox or require('Module:Message box').main
    local reasonText = self._reasonText or error('no reason text set', 2)
    local explanationText = self._explanationText
    local mbargs = {
        page = self._page,
        type = 'protection',
        image = self:renderImage(),
        text = string.format(
            "'''%s'''%s",
            reasonText,
            explanationText and '&lt;br /&gt;' .. explanationText or ''
        )
    }
    return makeMessageBox('mbox', mbargs)
end

--------------------------------------------------------------------------------
-- Padlock class
--------------------------------------------------------------------------------

local Padlock = setmetatable({}, BannerTemplate)
Padlock.__index = Padlock

function Padlock.new(protectionObj, blurbObj, cfg)
    local obj = BannerTemplate.new(protectionObj, cfg) -- This doesn't need the blurb.
    obj.imageWidth = 20
    obj.imageCaption = blurbObj:makeBannerText('tooltip')
    obj._imageAlt = blurbObj:makeBannerText('alt')
    obj._imageLink = blurbObj:makeBannerText('link')
    obj._indicatorName = cfg.padlockIndicatorNames[protectionObj.action]
        or cfg.padlockIndicatorNames.default
        or 'pp-default'
    return setmetatable(obj, Padlock)
end

function Padlock:__tostring()
    local frame = mw.getCurrentFrame()
    -- The nowiki tag helps prevent whitespace at the top of articles.
    return frame:extensionTag{name = 'nowiki'} .. frame:extensionTag{
        name = 'indicator',
        args = {name = self._indicatorName},
        content = self:renderImage()
    }
end

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

local p = {}

function p._exportClasses()
    -- This is used for testing purposes.
    return {
        Protection = Protection,
        Blurb = Blurb,
        BannerTemplate = BannerTemplate,
        Banner = Banner,
        Padlock = Padlock,
    }
end

function p._main(args, cfg, title)
    args = args or {}
    cfg = cfg or require(CONFIG_MODULE)

    local protectionObj = Protection.new(args, cfg, title)

    local ret = {}

    -- If a page's edit protection is equally or more restrictive than its
    -- protection from some other action, then don't bother displaying anything
    -- for the other action (except categories).
    if not yesno(args.catonly) and (protectionObj.action == 'edit' or
        args.demolevel or
        not getReachableNodes(
            cfg.hierarchy,
            protectionObj.level
        )[effectiveProtectionLevel('edit', protectionObj.title)])
    then
        -- Initialise the blurb object
        local blurbObj = Blurb.new(protectionObj, args, cfg)

        -- Render the banner
        if protectionObj:shouldShowLock() then
            ret[#ret + 1] = tostring(
                (yesno(args.small) and Padlock or Banner)
                .new(protectionObj, blurbObj, cfg)
            )
        end
    end

    -- Render the categories
    if yesno(args.category) ~= false then
        ret[#ret + 1] = protectionObj:makeCategoryLinks()
    end

    return table.concat(ret)
end

function p.main(frame, cfg)
    cfg = cfg or require(CONFIG_MODULE)

    -- Find default args, if any.
    local parent = frame.getParent and frame:getParent()
    local defaultArgs = parent and cfg.wrappers[parent:getTitle():gsub('/sandbox$', '')]

    -- Find user args, and use the parent frame if we are being called from a
    -- wrapper template.
    getArgs = getArgs or require('Module:Arguments').getArgs
    local userArgs = getArgs(frame, {
        parentOnly = defaultArgs,
        frameOnly = not defaultArgs
    })

    -- Build the args table. User-specified args overwrite default args.
    local args = {}
    for k, v in pairs(defaultArgs or {}) do
        args[k] = v
    end
    for k, v in pairs(userArgs) do
        args[k] = v
    end
    return p._main(args, cfg)
end

return p</text>
      <sha1>ktral6mmlw9hhlxwgaq85237qklrdx8</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Protection banner/config</title>
    <ns>828</ns>
    <id>42982788</id>
    <revision>
      <id>1069763876</id>
      <parentid>1053458493</parentid>
      <timestamp>2022-02-03T23:49:55Z</timestamp>
      <contributor>
        <username>Andrybak</username>
        <id>23735172</id>
      </contributor>
      <comment>add categorization into [[:Category:Wikipedia extended-confirmed-protected modules]] per [[Special:Diff/1069761256|request]]</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="46228" xml:space="preserve">-- This module provides configuration data for [[Module:Protection banner]].

return {

--------------------------------------------------------------------------------
--
--                                BANNER DATA
--
--------------------------------------------------------------------------------

--[[
-- Banner data consists of six fields:
-- * text - the main protection text that appears at the top of protection
--   banners.
-- * explanation - the text that appears below the main protection text, used
--   to explain the details of the protection.
-- * tooltip - the tooltip text you see when you move the mouse over a small
--   padlock icon.
-- * link - the page that the small padlock icon links to.
-- * alt - the alt text for the small padlock icon. This is also used as tooltip
--   text for the large protection banners.
-- * image - the padlock image used in both protection banners and small padlock
--   icons.
--
-- The module checks in three separate tables to find a value for each field.
-- First it checks the banners table, which has values specific to the reason
-- for the page being protected. Then the module checks the defaultBanners
-- table, which has values specific to each protection level. Finally, the
-- module checks the masterBanner table, which holds data for protection
-- templates to use if no data has been found in the previous two tables.
--
-- The values in the banner data can take parameters. These are specified
-- using ${TEXTLIKETHIS} (a dollar sign preceding a parameter name
-- enclosed in curly braces).
--
--                          Available parameters:
--
-- ${CURRENTVERSION} - a link to the page history or the move log, with the
-- display message "current-version-edit-display" or
-- "current-version-move-display".
--
-- ${EDITREQUEST} - a link to create an edit request for the current page.
--
-- ${EXPLANATIONBLURB} - an explanation blurb, e.g. "Please discuss any changes
-- on the talk page; you may submit a request to ask an administrator to make
-- an edit if it is minor or supported by consensus."
--
-- ${IMAGELINK} - a link to set the image to, depending on the protection
-- action and protection level.
--
-- ${INTROBLURB} - the PROTECTIONBLURB parameter, plus the expiry if an expiry
-- is set. E.g. "Editing of this page by new or unregistered users is currently
-- disabled until dd Month YYYY."
--
-- ${INTROFRAGMENT} - the same as ${INTROBLURB}, but without final punctuation
-- so that it can be used in run-on sentences.
--
-- ${PAGETYPE} - the type of the page, e.g. "article" or "template".
-- Defined in the cfg.pagetypes table.
--
-- ${PROTECTIONBLURB} - a blurb explaining the protection level of the page, e.g.
-- "Editing of this page by new or unregistered users is currently disabled"
--
-- ${PROTECTIONDATE} - the protection date, if it has been supplied to the
-- template.
--
-- ${PROTECTIONLEVEL} - the protection level, e.g. "fully protected" or
-- "semi-protected".
--
-- ${PROTECTIONLOG} - a link to the protection log or the pending changes log,
-- depending on the protection action.
--
-- ${TALKPAGE} - a link to the talk page. If a section is specified, links
-- straight to that talk page section.
--
-- ${TOOLTIPBLURB} - uses the PAGETYPE, PROTECTIONTYPE and EXPIRY parameters to
-- create a blurb like "This template is semi-protected", or "This article is
-- move-protected until DD Month YYYY".
--
-- ${VANDAL} - links for the specified username (or the root page name)
-- using Module:Vandal-m.
--
--                                 Functions
--
-- For advanced users, it is possible to use Lua functions instead of strings
-- in the banner config tables. Using functions gives flexibility that is not
-- possible just by using parameters. Functions take two arguments, the
-- protection object and the template arguments, and they must output a string.
--
-- For example:
--
-- text = function (protectionObj, args)
--     if protectionObj.level == 'autoconfirmed' then
--         return 'foo'
--     else
--         return 'bar'
--     end
-- end
--
-- Some protection object properties and methods that may be useful:
-- protectionObj.action - the protection action
-- protectionObj.level - the protection level
-- protectionObj.reason - the protection reason
-- protectionObj.expiry - the expiry. Nil if unset, the string "indef" if set
--     to indefinite, and the protection time in unix time if temporary.
-- protectionObj.protectionDate - the protection date in unix time, or nil if
--     unspecified.
-- protectionObj.bannerConfig - the banner config found by the module. Beware
--     of editing the config field used by the function, as it could create an
--     infinite loop.
-- protectionObj:isProtected - returns a boolean showing whether the page is
--     protected.
-- protectionObj:isTemporary - returns a boolean showing whether the expiry is
--     temporary.
-- protectionObj:isIncorrect - returns a boolean showing whether the protection
--     template is incorrect.
--]]

-- The master banner data, used if no values have been found in banners or
-- defaultBanners.
masterBanner = {
    text = '${INTROBLURB}',
    explanation = '${EXPLANATIONBLURB}',
    tooltip = '${TOOLTIPBLURB}',
    link = '${IMAGELINK}',
    alt = 'Page ${PROTECTIONLEVEL}'
},

-- The default banner data. This holds banner data for different protection
-- levels.
-- *required* - this table needs edit, move, autoreview and upload subtables.
defaultBanners = {
    edit = {},
    move = {},
    autoreview = {
        default = {
            alt = 'Page protected with pending changes',
            tooltip = 'All edits by unregistered and new users are subject to review prior to becoming visible to unregistered users',
            image = 'Pending-protection-shackle.svg'
        }
    },
    upload = {}
},

-- The banner data. This holds banner data for different protection reasons.
-- In fact, the reasons specified in this table control which reasons are
-- valid inputs to the first positional parameter.
--
-- There is also a non-standard "description" field that can be used for items
-- in this table. This is a description of the protection reason for use in the
-- module documentation.
--
-- *required* - this table needs edit, move, autoreview and upload subtables.
banners = {
    edit = {
        blp = {
            description = 'For pages protected to promote compliance with the'
                .. ' [[Wikipedia:Biographies of living persons'
                .. '|biographies of living persons]] policy',
            text = '${INTROFRAGMENT} to promote compliance with'
                .. ' [[Wikipedia:Biographies of living persons'
                .. "|Wikipedia's&amp;nbsp;policy on&amp;nbsp;the&amp;nbsp;biographies"
                .. ' of&amp;nbsp;living&amp;nbsp;people]].',
            tooltip = '${TOOLTIPFRAGMENT} to promote compliance with the policy on'
                .. ' biographies of living persons',
        },
        dmca = {
            description = 'For pages protected by the Wikimedia Foundation'
                .. ' due to [[Digital Millennium Copyright Act]] takedown requests',
            explanation = function (protectionObj, args)
                local ret = 'Pursuant to a rights owner notice under the Digital'
                    .. ' Millennium Copyright Act (DMCA) regarding some content'
                    .. ' in this article, the Wikimedia Foundation acted under'
                    .. ' applicable law and took down and restricted the content'
                    .. ' in question.'
                if args.notice then
                    ret = ret .. ' A copy of the received notice can be found here: '
                        .. args.notice .. '.'
                end
                ret = ret .. ' For more information, including websites discussing'
                    .. ' how to file a counter-notice, please see'
                    .. " [[Wikipedia:Office actions]] and the article's ${TALKPAGE}."
                    .. "'''Do not remove this template from the article until the"
                    .. " restrictions are withdrawn'''."
                return ret
            end,
            image = 'Office-protection-shackle.svg',
        },
        dispute = {
            description = 'For pages protected due to editing disputes',
            text = function (protectionObj, args)
                -- Find the value of "disputes".
                local display = 'disputes'
                local disputes
                if args.section then
                    disputes = string.format(
                        '[[%s:%s#%s|%s]]',
                        mw.site.namespaces[protectionObj.title.namespace].talk.name,
                        protectionObj.title.text,
                        args.section,
                        display
                    )
                else
                    disputes = display
                end

                -- Make the blurb, depending on the expiry.
                local msg
                if type(protectionObj.expiry) == 'number' then
                    msg = '${INTROFRAGMENT} or until editing %s have been resolved.'
                else
                    msg = '${INTROFRAGMENT} until editing %s have been resolved.'
                end
                return string.format(msg, disputes)
            end,
            explanation = "This protection is '''not''' an endorsement of the"
                .. ' ${CURRENTVERSION}. ${EXPLANATIONBLURB}',
            tooltip = '${TOOLTIPFRAGMENT} due to editing disputes',
        },
        ecp = {
            description = 'For articles in topic areas authorized by'
                .. ' [[Wikipedia:Arbitration Committee|ArbCom]] or'
                .. ' meets the criteria for community use',
            tooltip = 'This ${PAGETYPE} is extended-confirmed protected',
            alt = 'Extended-protected ${PAGETYPE}',
        },
        mainpage = {
            description = 'For pages protected for being displayed on the [[Main Page]]',
            text = 'This file is currently'
                .. ' [[Wikipedia:This page is protected|protected]] from'
                .. ' editing because it is currently or will soon be displayed'
                .. ' on the [[Main Page]].',
            explanation = 'Images on the Main Page are protected due to their high'
                .. ' visibility. Please discuss any necessary changes on the ${TALKPAGE}.'
                .. '&lt;br /&gt;&lt;span style="font-size:90%;"&gt;'
                .. "'''Administrators:''' Once this image is definitely off the Main Page,"
                .. ' please unprotect this file, or reduce to semi-protection,'
                .. ' as appropriate.&lt;/span&gt;',
        },
        office = {
            description = 'For pages protected by the Wikimedia Foundation',
            text = function (protectionObj, args)
                local ret = 'This ${PAGETYPE} is currently under the'
                    .. ' scrutiny of the'
                    .. ' [[Wikipedia:Office actions|Wikimedia Foundation Office]]'
                    .. ' and is protected.'
                if protectionObj.protectionDate then
                    ret = ret .. ' It has been protected since ${PROTECTIONDATE}.'
                end
                return ret
            end,
            explanation = "If you can edit this page, please discuss all changes and"
                .. " additions on the ${TALKPAGE} first. '''Do not remove protection from this"
                .. " page unless you are authorized by the Wikimedia Foundation to do"
                .. " so.'''",
            image = 'Office-protection-shackle.svg',
        },
        reset = {
            description = 'For pages protected by the Wikimedia Foundation and'
                .. ' "reset" to a bare-bones version',
            text = 'This ${PAGETYPE} is currently under the'
                    .. ' scrutiny of the'
                    .. ' [[Wikipedia:Office actions|Wikimedia Foundation Office]]'
                    .. ' and is protected.',
            explanation = function (protectionObj, args)
                local ret = ''
                if protectionObj.protectionDate then
                    ret = ret .. 'On ${PROTECTIONDATE} this ${PAGETYPE} was'
                else
                    ret = ret .. 'This ${PAGETYPE} has been'
                end
                ret = ret .. ' reduced to a'
                .. ' simplified, "bare bones" version so that it may be completely'
                .. ' rewritten to ensure it meets the policies of'
                .. ' [[WP:NPOV|Neutral Point of View]] and [[WP:V|Verifiability]].'
                .. ' Standard Wikipedia policies will apply to its rewriting—which'
                .. ' will eventually be open to all editors—and will be strictly'
                .. ' enforced. The ${PAGETYPE} has been ${PROTECTIONLEVEL} while'
                .. ' it is being rebuilt.\n\n'
                .. 'Any insertion of material directly from'
                .. ' pre-protection revisions of the ${PAGETYPE} will be removed, as'
                .. ' will any material added to the ${PAGETYPE} that is not properly'
                .. ' sourced. The associated talk page(s) were also cleared on the'
                .. " same date.\n\n"
                .. "If you can edit this page, please discuss all changes and"
                .. " additions on the ${TALKPAGE} first. '''Do not override"
                .. " this action, and do not remove protection from this page,"
                .. " unless you are authorized by the Wikimedia Foundation"
                .. " to do so. No editor may remove this notice.'''"

                return ret
            end,
            image = 'Office-protection-shackle.svg',
        },
        sock = {
            description = 'For pages protected due to'
                .. ' [[Wikipedia:Sock puppetry|sock puppetry]]',
            text = '${INTROFRAGMENT} to prevent [[Wikipedia:Sock puppetry|sock puppets]] of'
                .. ' [[Wikipedia:Blocking policy|blocked]] or'
                .. ' [[Wikipedia:Banning policy|banned users]]'
                .. ' from editing it.',
            tooltip = '${TOOLTIPFRAGMENT} to prevent sock puppets of blocked or banned users from'
                .. ' editing it',
        },
        template = {
            description = 'For [[Wikipedia:High-risk templates|high-risk]]'
                .. ' templates and Lua modules',
            text = 'This is a permanently [[Help:Protection|protected]] ${PAGETYPE},'
                .. ' as it is [[Wikipedia:High-risk templates|high-risk]].',
            explanation = 'Please discuss any changes on the ${TALKPAGE}; you may'
                .. ' ${EDITREQUEST} to ask an'
                .. ' [[Wikipedia:Administrators|administrator]] or'
                .. ' [[Wikipedia:Template editor|template editor]] to make an edit if'
                .. ' it is [[Help:Minor edit#When to mark an edit as a minor edit'
                .. '|uncontroversial]] or supported by'
                .. ' [[Wikipedia:Consensus|consensus]]. You can also'
                .. ' [[Wikipedia:Requests for page protection|request]] that the page be'
                .. ' unprotected.',
            tooltip = 'This high-risk ${PAGETYPE} is permanently ${PROTECTIONLEVEL}'
                .. ' to prevent vandalism',
            alt = 'Permanently protected ${PAGETYPE}',
        },
        usertalk = {
            description = 'For pages protected against disruptive edits by a'
                .. ' particular user',
            text = '${INTROFRAGMENT} to prevent ${VANDAL} from using it to make disruptive edits,'
                .. ' such as abusing the'
                .. ' &amp;#123;&amp;#123;[[Template:unblock|unblock]]&amp;#125;&amp;#125; template.',
            explanation = 'If you cannot edit this user talk page and you need to'
                .. ' make a change or leave a message, you can'
                .. ' [[Wikipedia:Requests for page protection'
                .. '#Current requests for edits to a protected page'
                .. '|request an edit]],'
                .. ' [[Wikipedia:Requests for page protection'
                .. '#Current requests for reduction in protection level'
                .. '|request unprotection]],'
                .. ' [[Special:Userlogin|log in]],'
                .. ' or [[Special:UserLogin/signup|create an account]].',
        },
        vandalism = {
            description = 'For pages protected against'
                .. ' [[Wikipedia:Vandalism|vandalism]]',
            text = '${INTROFRAGMENT} due to [[Wikipedia:Vandalism|vandalism]].',
            explanation = function (protectionObj, args)
                local ret = ''
                if protectionObj.level == 'sysop' then
                    ret = ret .. "This protection is '''not''' an endorsement of the"
                        .. ' ${CURRENTVERSION}. '
                end
                return ret .. '${EXPLANATIONBLURB}'
            end,
            tooltip = '${TOOLTIPFRAGMENT} due to vandalism',
        }
    },
    move = {
        dispute = {
            description = 'For pages protected against page moves due to'
                .. ' disputes over the page title',
            explanation = "This protection is '''not''' an endorsement of the"
                .. ' ${CURRENTVERSION}. ${EXPLANATIONBLURB}',
            image = 'Move-protection-shackle.svg'
        },
        vandalism = {
            description = 'For pages protected against'
                .. ' [[Wikipedia:Vandalism#Page-move vandalism'
                .. ' |page-move vandalism]]'
        }
    },
    autoreview = {},
    upload = {}
},

--------------------------------------------------------------------------------
--
--                            GENERAL DATA TABLES
--
--------------------------------------------------------------------------------

--------------------------------------------------------------------------------
-- Protection blurbs
--------------------------------------------------------------------------------

-- This table produces the protection blurbs available with the
-- ${PROTECTIONBLURB} parameter. It is sorted by protection action and
-- protection level, and is checked by the module in the following order:
-- 1. page's protection action, page's protection level
-- 2. page's protection action, default protection level
-- 3. "edit" protection action, default protection level
--
-- It is possible to use banner parameters inside this table.
-- *required* - this table needs edit, move, autoreview and upload subtables.
protectionBlurbs = {
    edit = {
        default = 'This ${PAGETYPE} is currently [[Help:Protection|'
            .. 'protected]] from editing',
        autoconfirmed = 'Editing of this ${PAGETYPE} by [[Wikipedia:User access'
            .. ' levels#New users|new]] or [[Wikipedia:User access levels#Unregistered'
            .. ' users|unregistered]] users is currently [[Help:Protection|disabled]]',
        extendedconfirmed = 'This ${PAGETYPE} is currently under extended confirmed protection',
    },
    move = {
        default = 'This ${PAGETYPE} is currently [[Help:Protection|protected]]'
            .. ' from [[Help:Moving a page|page moves]]'
    },
    autoreview = {
        default = 'All edits made to this ${PAGETYPE} by'
            .. ' [[Wikipedia:User access levels#New users|new]] or'
            .. ' [[Wikipedia:User access levels#Unregistered users|unregistered]]'
            .. ' users are currently'
            .. ' [[Wikipedia:Pending changes|subject to review]]'
    },
    upload = {
        default = 'Uploading new versions of this ${PAGETYPE} is currently disabled'
    }
},


--------------------------------------------------------------------------------
-- Explanation blurbs
--------------------------------------------------------------------------------

-- This table produces the explanation blurbs available with the
-- ${EXPLANATIONBLURB} parameter. It is sorted by protection action,
-- protection level, and whether the page is a talk page or not. If the page is
-- a talk page it will have a talk key of "talk"; otherwise it will have a talk
-- key of "subject". The table is checked in the following order:
-- 1. page's protection action, page's protection level, page's talk key
-- 2. page's protection action, page's protection level, default talk key
-- 3. page's protection action, default protection level, page's talk key
-- 4. page's protection action, default protection level, default talk key
--
-- It is possible to use banner parameters inside this table.
-- *required* - this table needs edit, move, autoreview and upload subtables.
explanationBlurbs = {
    edit = {
        autoconfirmed = {
            subject = 'See the [[Wikipedia:Protection policy|'
                .. 'protection policy]] and ${PROTECTIONLOG} for more details. If you'
                .. ' cannot edit this ${PAGETYPE} and you wish to make a change, you can'
                .. ' ${EDITREQUEST}, discuss changes on the ${TALKPAGE},'
                .. ' [[Wikipedia:Requests for page protection'
                .. '#Current requests for reduction in protection level'
                .. '|request unprotection]], [[Special:Userlogin|log in]], or'
                .. ' [[Special:UserLogin/signup|create an account]].',
            default = 'See the [[Wikipedia:Protection policy|'
                .. 'protection policy]] and ${PROTECTIONLOG} for more details. If you'
                .. ' cannot edit this ${PAGETYPE} and you wish to make a change, you can'
                .. ' [[Wikipedia:Requests for page protection'
                .. '#Current requests for reduction in protection level'
                .. '|request unprotection]], [[Special:Userlogin|log in]], or'
                .. ' [[Special:UserLogin/signup|create an account]].',
        },
        extendedconfirmed = {
            default = 'Extended confirmed protection prevents edits from all unregistered editors'
                .. ' and registered users with fewer than 30 days tenure and 500 edits.'
                .. ' The [[Wikipedia:Protection policy#extended|policy on community use]]'
                .. ' specifies that extended confirmed protection can be applied to combat'
                .. ' disruption, if semi-protection has proven to be ineffective.'
                .. ' Extended confirmed protection may also be applied to enforce'
                .. ' [[Wikipedia:Arbitration Committee|arbitration sanctions]].'
                .. ' Please discuss any changes on the ${TALKPAGE}; you may'
                .. ' ${EDITREQUEST} to ask for uncontroversial changes supported by'
                .. ' [[Wikipedia:Consensus|consensus]].'
        },
        default = {
            subject = 'See the [[Wikipedia:Protection policy|'
                .. 'protection policy]] and ${PROTECTIONLOG} for more details.'
                .. ' Please discuss any changes on the ${TALKPAGE}; you'
                .. ' may ${EDITREQUEST} to ask an'
                .. ' [[Wikipedia:Administrators|administrator]] to make an edit if it'
                .. ' is [[Help:Minor edit#When to mark an edit as a minor edit'
                .. '|uncontroversial]] or supported by [[Wikipedia:Consensus'
                .. '|consensus]]. You may also [[Wikipedia:Requests for'
                .. ' page protection#Current requests for reduction in protection level'
                .. '|request]] that this page be unprotected.',
            default = 'See the [[Wikipedia:Protection policy|'
                .. 'protection policy]] and ${PROTECTIONLOG} for more details.'
                .. ' You may [[Wikipedia:Requests for page'
                .. ' protection#Current requests for edits to a protected page|request an'
                .. ' edit]] to this page, or [[Wikipedia:Requests for'
                .. ' page protection#Current requests for reduction in protection level'
                .. '|ask]] for it to be unprotected.'
        }
    },
    move = {
        default = {
            subject = 'See the [[Wikipedia:Protection policy|'
                .. 'protection policy]] and ${PROTECTIONLOG} for more details.'
                .. ' The page may still be edited but cannot be moved'
                .. ' until unprotected. Please discuss any suggested moves on the'
                .. ' ${TALKPAGE} or at [[Wikipedia:Requested moves]]. You can also'
                .. ' [[Wikipedia:Requests for page protection|request]] that the page be'
                .. ' unprotected.',
            default = 'See the [[Wikipedia:Protection policy|'
                .. 'protection policy]] and ${PROTECTIONLOG} for more details.'
                .. ' The page may still be edited but cannot be moved'
                .. ' until unprotected. Please discuss any suggested moves at'
                .. ' [[Wikipedia:Requested moves]]. You can also'
                .. ' [[Wikipedia:Requests for page protection|request]] that the page be'
                .. ' unprotected.'
        }
    },
    autoreview = {
        default = {
            default = 'See the [[Wikipedia:Protection policy|'
                .. 'protection policy]] and ${PROTECTIONLOG} for more details.'
                .. ' Edits to this ${PAGETYPE} by new and unregistered users'
                .. ' will not be visible to readers until they are accepted by'
                .. ' a reviewer. To avoid the need for your edits to be'
                .. ' reviewed, you may'
                .. ' [[Wikipedia:Requests for page protection'
                .. '#Current requests for reduction in protection level'
                .. '|request unprotection]], [[Special:Userlogin|log in]], or'
                .. ' [[Special:UserLogin/signup|create an account]].'
        },
    },
    upload = {
        default = {
            default = 'See the [[Wikipedia:Protection policy|'
                .. 'protection policy]] and ${PROTECTIONLOG} for more details.'
                .. ' The page may still be edited but new versions of the file'
                .. ' cannot be uploaded until it is unprotected. You can'
                .. ' request that a new version be uploaded by using a'
                .. ' [[Wikipedia:Edit requests|protected edit request]], or you'
                .. ' can  [[Wikipedia:Requests for page protection|request]]'
                .. ' that the file be unprotected.'
        }
    }
},

--------------------------------------------------------------------------------
-- Protection levels
--------------------------------------------------------------------------------

-- This table provides the data for the ${PROTECTIONLEVEL} parameter, which
-- produces a short label for different protection levels. It is sorted by
-- protection action and protection level, and is checked in the following
-- order:
-- 1. page's protection action, page's protection level
-- 2. page's protection action, default protection level
-- 3. "edit" protection action, default protection level
--
-- It is possible to use banner parameters inside this table.
-- *required* - this table needs edit, move, autoreview and upload subtables.
protectionLevels = {
    edit = {
        default = 'protected',
        templateeditor = 'template-protected',
        extendedconfirmed = 'extended-protected',
        autoconfirmed = 'semi-protected',
    },
    move = {
        default = 'move-protected'
    },
    autoreview = {
    },
    upload = {
        default = 'upload-protected'
    }
},

--------------------------------------------------------------------------------
-- Images
--------------------------------------------------------------------------------

-- This table lists different padlock images for each protection action and
-- protection level. It is used if an image is not specified in any of the
-- banner data tables, and if the page does not satisfy the conditions for using
-- the ['image-filename-indef'] image. It is checked in the following order:
-- 1. page's protection action, page's protection level
-- 2. page's protection action, default protection level
images = {
    edit = {
        default = 'Full-protection-shackle.svg',
        templateeditor = 'Template-protection-shackle.svg',
        extendedconfirmed = 'Extended-protection-shackle.svg',
        autoconfirmed = 'Semi-protection-shackle.svg'
    },
    move = {
        default = 'Move-protection-shackle.svg',
    },
    autoreview = {
        default = 'Pending-protection-shackle.svg'
    },
    upload = {
        default = 'Upload-protection-shackle.svg'
    }
},

-- Pages with a reason specified in this table will show the special "indef"
-- padlock, defined in the 'image-filename-indef' message, if no expiry is set.
indefImageReasons = {
    template = true
},

--------------------------------------------------------------------------------
-- Image links
--------------------------------------------------------------------------------

-- This table provides the data for the ${IMAGELINK} parameter, which gets
-- the image link for small padlock icons based on the page's protection action
-- and protection level. It is checked in the following order:
-- 1. page's protection action, page's protection level
-- 2. page's protection action, default protection level
-- 3. "edit" protection action, default protection level
--
-- It is possible to use banner parameters inside this table.
-- *required* - this table needs edit, move, autoreview and upload subtables.
imageLinks = {
    edit = {
        default = 'Wikipedia:Protection policy#full',
        templateeditor = 'Wikipedia:Protection policy#template',
        extendedconfirmed = 'Wikipedia:Protection policy#extended',
        autoconfirmed = 'Wikipedia:Protection policy#semi'
    },
    move = {
        default = 'Wikipedia:Protection policy#move'
    },
    autoreview = {
        default = 'Wikipedia:Protection policy#pending'
    },
    upload = {
        default = 'Wikipedia:Protection policy#upload'
    }
},

--------------------------------------------------------------------------------
-- Padlock indicator names
--------------------------------------------------------------------------------

-- This table provides the "name" attribute for the &lt;indicator&gt; extension tag
-- with which small padlock icons are generated. All indicator tags on a page
-- are displayed in alphabetical order based on this attribute, and with
-- indicator tags with duplicate names, the last tag on the page wins.
-- The attribute is chosen based on the protection action; table keys must be a
-- protection action name or the string "default".
padlockIndicatorNames = {
    autoreview = 'pp-autoreview',
    default = 'pp-default'
},

--------------------------------------------------------------------------------
-- Protection categories
--------------------------------------------------------------------------------

--[[
-- The protection categories are stored in the protectionCategories table.
-- Keys to this table are made up of the following strings:
--
-- 1. the expiry date
-- 2. the namespace
-- 3. the protection reason (e.g. "dispute" or "vandalism")
-- 4. the protection level (e.g. "sysop" or "autoconfirmed")
-- 5. the action (e.g. "edit" or "move")
--
-- When the module looks up a category in the table, first it will will check to
-- see a key exists that corresponds to all five parameters. For example, a
-- user page semi-protected from vandalism for two weeks would have the key
-- "temp-user-vandalism-autoconfirmed-edit". If no match is found, the module
-- changes the first part of the key to "all" and checks the table again. It
-- keeps checking increasingly generic key combinations until it finds the
-- field, or until it reaches the key "all-all-all-all-all".
--
-- The module uses a binary matrix to determine the order in which to search.
-- This is best demonstrated by a table. In this table, the "0" values
-- represent "all", and the "1" values represent the original data (e.g.
-- "indef" or "file" or "vandalism").
--
--        expiry    namespace reason   level     action
-- order
-- 1      1         1         1        1         1
-- 2      0         1         1        1         1
-- 3      1         0         1        1         1
-- 4      0         0         1        1         1
-- 5      1         1         0        1         1
-- 6      0         1         0        1         1
-- 7      1         0         0        1         1
-- 8      0         0         0        1         1
-- 9      1         1         1        0         1
-- 10     0         1         1        0         1
-- 11     1         0         1        0         1
-- 12     0         0         1        0         1
-- 13     1         1         0        0         1
-- 14     0         1         0        0         1
-- 15     1         0         0        0         1
-- 16     0         0         0        0         1
-- 17     1         1         1        1         0
-- 18     0         1         1        1         0
-- 19     1         0         1        1         0
-- 20     0         0         1        1         0
-- 21     1         1         0        1         0
-- 22     0         1         0        1         0
-- 23     1         0         0        1         0
-- 24     0         0         0        1         0
-- 25     1         1         1        0         0
-- 26     0         1         1        0         0
-- 27     1         0         1        0         0
-- 28     0         0         1        0         0
-- 29     1         1         0        0         0
-- 30     0         1         0        0         0
-- 31     1         0         0        0         0
-- 32     0         0         0        0         0
--
-- In this scheme the action has the highest priority, as it is the last
-- to change, and the expiry has the least priority, as it changes the most.
-- The priorities of the expiry, the protection level and the action are
-- fixed, but the priorities of the reason and the namespace can be swapped
-- through the use of the cfg.bannerDataNamespaceHasPriority table.
--]]

-- If the reason specified to the template is listed in this table,
-- namespace data will take priority over reason data in the protectionCategories
-- table.
reasonsWithNamespacePriority = {
    vandalism = true,
},

-- The string to use as a namespace key for the protectionCategories table for each
-- namespace number.
categoryNamespaceKeys = {
    [  2] = 'user',
    [  3] = 'user',
    [  4] = 'project',
    [  6] = 'file',
    [  8] = 'mediawiki',
    [ 10] = 'template',
    [ 12] = 'project',
    [ 14] = 'category',
    [100] = 'portal',
    [828] = 'module',
},

protectionCategories = {
    ['all|all|all|all|all']                     = 'Wikipedia fully protected pages',
    ['all|all|office|all|all']                  = 'Wikipedia Office-protected pages',
    ['all|all|reset|all|all']                   = 'Wikipedia Office-protected pages',
    ['all|all|dmca|all|all']                    = 'Wikipedia Office-protected pages',
    ['all|all|mainpage|all|all']                = 'Wikipedia fully-protected main page files',
    ['all|all|all|extendedconfirmed|all']       = 'Wikipedia extended-confirmed-protected pages',
    ['all|all|ecp|extendedconfirmed|all']       = 'Wikipedia extended-confirmed-protected pages',
    ['all|template|all|all|edit']               = 'Wikipedia fully protected templates',
    ['all|all|all|autoconfirmed|edit']          = 'Wikipedia semi-protected pages',
    ['indef|all|all|autoconfirmed|edit']        = 'Wikipedia indefinitely semi-protected pages',
    ['all|all|blp|autoconfirmed|edit']          = 'Wikipedia indefinitely semi-protected biographies of living people',
    ['temp|all|blp|autoconfirmed|edit']         = 'Wikipedia temporarily semi-protected biographies of living people',
    ['all|all|dispute|autoconfirmed|edit']      = 'Wikipedia pages semi-protected due to dispute',
    ['all|all|sock|autoconfirmed|edit']         = 'Wikipedia pages semi-protected from banned users',
    ['all|all|vandalism|autoconfirmed|edit']    = 'Wikipedia pages semi-protected against vandalism',
    ['all|category|all|autoconfirmed|edit']     = 'Wikipedia semi-protected categories',
    ['all|file|all|autoconfirmed|edit']         = 'Wikipedia semi-protected files',
    ['all|portal|all|autoconfirmed|edit']       = 'Wikipedia semi-protected portals',
    ['all|project|all|autoconfirmed|edit']      = 'Wikipedia semi-protected project pages',
    ['all|talk|all|autoconfirmed|edit']         = 'Wikipedia semi-protected talk pages',
    ['all|template|all|autoconfirmed|edit']     = 'Wikipedia semi-protected templates',
    ['all|user|all|autoconfirmed|edit']         = 'Wikipedia semi-protected user and user talk pages',
    ['all|all|all|templateeditor|edit']         = 'Wikipedia template-protected pages other than templates and modules',
    ['all|template|all|templateeditor|edit']    = 'Wikipedia template-protected templates',
    ['all|template|all|templateeditor|move']    = 'Wikipedia template-protected templates', -- move-protected templates
    ['all|all|blp|sysop|edit']                  = 'Wikipedia indefinitely protected biographies of living people',
    ['temp|all|blp|sysop|edit']                 = 'Wikipedia temporarily protected biographies of living people',
    ['all|all|dispute|sysop|edit']              = 'Wikipedia pages protected due to dispute',
    ['all|all|sock|sysop|edit']                 = 'Wikipedia pages protected from banned users',
    ['all|all|vandalism|sysop|edit']            = 'Wikipedia pages protected against vandalism',
    ['all|category|all|sysop|edit']             = 'Wikipedia fully protected categories',
    ['all|file|all|sysop|edit']                 = 'Wikipedia fully-protected files',
    ['all|project|all|sysop|edit']              = 'Wikipedia fully-protected project pages',
    ['all|talk|all|sysop|edit']                 = 'Wikipedia fully-protected talk pages',
    ['all|template|all|extendedconfirmed|edit'] = 'Wikipedia extended-confirmed-protected templates',
    ['all|template|all|sysop|edit']             = 'Wikipedia fully protected templates',
    ['all|user|all|sysop|edit']                 = 'Wikipedia fully protected user and user talk pages',
    ['all|module|all|all|edit']                 = 'Wikipedia fully-protected modules',
    ['all|module|all|templateeditor|edit']      = 'Wikipedia template-protected modules',
    ['all|module|all|extendedconfirmed|edit']   = 'Wikipedia extended-confirmed-protected modules',
    ['all|module|all|autoconfirmed|edit']       = 'Wikipedia semi-protected modules',
    ['all|all|all|sysop|move']                  = 'Wikipedia move-protected pages',
    ['indef|all|all|sysop|move']                = 'Wikipedia indefinitely move-protected pages',
    ['all|all|dispute|sysop|move']              = 'Wikipedia pages move-protected due to dispute',
    ['all|all|vandalism|sysop|move']            = 'Wikipedia pages move-protected due to vandalism',
    ['all|portal|all|sysop|move']               = 'Wikipedia move-protected portals',
    ['all|project|all|sysop|move']              = 'Wikipedia move-protected project pages',
    ['all|talk|all|sysop|move']                 = 'Wikipedia move-protected talk pages',
    ['all|template|all|sysop|move']             = 'Wikipedia move-protected templates',
    ['all|user|all|sysop|move']                 = 'Wikipedia move-protected user and user talk pages',
    ['all|all|all|autoconfirmed|autoreview']    = 'Wikipedia pending changes protected pages',
    ['all|file|all|all|upload']                 = 'Wikipedia upload-protected files',
},

--------------------------------------------------------------------------------
-- Expiry category config
--------------------------------------------------------------------------------

-- This table configures the expiry category behaviour for each protection
-- action.
-- * If set to true, setting that action will always categorise the page if
--   an expiry parameter is not set.
-- * If set to false, setting that action will never categorise the page.
-- * If set to nil, the module will categorise the page if:
--   1) an expiry parameter is not set, and
--   2) a reason is provided, and
--   3) the specified reason is not blacklisted in the reasonsWithoutExpiryCheck
--      table.

expiryCheckActions = {
    edit = nil,
    move = false,
    autoreview = true,
    upload = false
},

reasonsWithoutExpiryCheck = {
    blp = true,
    template = true,
},

--------------------------------------------------------------------------------
-- Pagetypes
--------------------------------------------------------------------------------

-- This table produces the page types available with the ${PAGETYPE} parameter.
-- Keys are namespace numbers, or the string "default" for the default value.
pagetypes = {
    [0] = 'article',
    [6] = 'file',
    [10] = 'template',
    [14] = 'category',
    [828] = 'module',
    default = 'page'
},

--------------------------------------------------------------------------------
-- Strings marking indefinite protection
--------------------------------------------------------------------------------

-- This table contains values passed to the expiry parameter that mean the page
-- is protected indefinitely.
indefStrings = {
    ['indef'] = true,
    ['indefinite'] = true,
    ['indefinitely'] = true,
    ['infinite'] = true,
},

--------------------------------------------------------------------------------
-- Group hierarchy
--------------------------------------------------------------------------------

-- This table maps each group to all groups that have a superset of the original
-- group's page editing permissions.
hierarchy = {
    sysop = {},
    reviewer = {'sysop'},
    filemover = {'sysop'},
    templateeditor = {'sysop'},
    extendedconfirmed = {'sysop'},
    autoconfirmed = {'reviewer', 'filemover', 'templateeditor', 'extendedconfirmed'},
    user = {'autoconfirmed'},
    ['*'] = {'user'}
},

--------------------------------------------------------------------------------
-- Wrapper templates and their default arguments
--------------------------------------------------------------------------------

-- This table contains wrapper templates used with the module, and their
-- default arguments. Templates specified in this table should contain the
-- following invocation, and no other template content:
--
-- {{#invoke:Protection banner|main}}
--
-- If other content is desired, it can be added between
-- &lt;noinclude&gt;...&lt;/noinclude&gt; tags.
--
-- When a user calls one of these wrapper templates, they will use the
-- default arguments automatically. However, users can override any of the
-- arguments.
wrappers = {
    ['Template:Pp']                         = {},
    ['Template:Pp-extended']                = {'ecp'},
    ['Template:Pp-blp']                     = {'blp'},
    -- we don't need Template:Pp-create
    ['Template:Pp-dispute']                 = {'dispute'},
    ['Template:Pp-main-page']               = {'mainpage'},
    ['Template:Pp-move']                    = {action = 'move', catonly = 'yes'},
    ['Template:Pp-move-dispute']            = {'dispute', action = 'move', catonly = 'yes'},
    -- we don't need Template:Pp-move-indef
    ['Template:Pp-move-vandalism']          = {'vandalism', action = 'move', catonly = 'yes'},
    ['Template:Pp-office']                  = {'office'},
    ['Template:Pp-office-dmca']             = {'dmca'},
    ['Template:Pp-pc']                      = {action = 'autoreview', small = true},
    ['Template:Pp-pc1']                     = {action = 'autoreview', small = true},
    ['Template:Pp-reset']                   = {'reset'},
    ['Template:Pp-semi-indef']              = {small = true},
    ['Template:Pp-sock']                    = {'sock'},
    ['Template:Pp-template']                = {'template', small = true},
    ['Template:Pp-upload']                  = {action = 'upload'},
    ['Template:Pp-usertalk']                = {'usertalk'},
    ['Template:Pp-vandalism']               = {'vandalism'},
},

--------------------------------------------------------------------------------
--
--                                 MESSAGES
--
--------------------------------------------------------------------------------

msg = {

--------------------------------------------------------------------------------
-- Intro blurb and intro fragment
--------------------------------------------------------------------------------

-- These messages specify what is produced by the ${INTROBLURB} and
-- ${INTROFRAGMENT} parameters. If the protection is temporary they use the
-- intro-blurb-expiry or intro-fragment-expiry, and if not they use
-- intro-blurb-noexpiry or intro-fragment-noexpiry.
-- It is possible to use banner parameters in these messages.
['intro-blurb-expiry'] = '${PROTECTIONBLURB} until ${EXPIRY}.',
['intro-blurb-noexpiry'] = '${PROTECTIONBLURB}.',
['intro-fragment-expiry'] = '${PROTECTIONBLURB} until ${EXPIRY},',
['intro-fragment-noexpiry'] = '${PROTECTIONBLURB}',

--------------------------------------------------------------------------------
-- Tooltip blurb
--------------------------------------------------------------------------------

-- These messages specify what is produced by the ${TOOLTIPBLURB} parameter.
-- If the protection is temporary the tooltip-blurb-expiry message is used, and
-- if not the tooltip-blurb-noexpiry message is used.
-- It is possible to use banner parameters in these messages.
['tooltip-blurb-expiry'] = 'This ${PAGETYPE} is ${PROTECTIONLEVEL} until ${EXPIRY}.',
['tooltip-blurb-noexpiry'] = 'This ${PAGETYPE} is ${PROTECTIONLEVEL}.',
['tooltip-fragment-expiry'] = 'This ${PAGETYPE} is ${PROTECTIONLEVEL} until ${EXPIRY},',
['tooltip-fragment-noexpiry'] = 'This ${PAGETYPE} is ${PROTECTIONLEVEL}',

--------------------------------------------------------------------------------
-- Special explanation blurb
--------------------------------------------------------------------------------

-- An explanation blurb for pages that cannot be unprotected, e.g. for pages
-- in the MediaWiki namespace.
-- It is possible to use banner parameters in this message.
['explanation-blurb-nounprotect'] = 'See the [[Wikipedia:Protection policy|'
    .. 'protection policy]] and ${PROTECTIONLOG} for more details.'
    .. ' Please discuss any changes on the ${TALKPAGE}; you'
    .. ' may ${EDITREQUEST} to ask an'
    .. ' [[Wikipedia:Administrators|administrator]] to make an edit if it'
    .. ' is [[Help:Minor edit#When to mark an edit as a minor edit'
    .. '|uncontroversial]] or supported by [[Wikipedia:Consensus'
    .. '|consensus]].',

--------------------------------------------------------------------------------
-- Protection log display values
--------------------------------------------------------------------------------

-- These messages determine the display values for the protection log link
-- or the pending changes log link produced by the ${PROTECTIONLOG} parameter.
-- It is possible to use banner parameters in these messages.
['protection-log-display'] = 'protection log',
['pc-log-display'] = 'pending changes log',

--------------------------------------------------------------------------------
-- Current version display values
--------------------------------------------------------------------------------

-- These messages determine the display values for the page history link
-- or the move log link produced by the ${CURRENTVERSION} parameter.
-- It is possible to use banner parameters in these messages.
['current-version-move-display'] = 'current title',
['current-version-edit-display'] = 'current version',

--------------------------------------------------------------------------------
-- Talk page
--------------------------------------------------------------------------------

-- This message determines the display value of the talk page link produced
-- with the ${TALKPAGE} parameter.
-- It is possible to use banner parameters in this message.
['talk-page-link-display'] = 'talk page',

--------------------------------------------------------------------------------
-- Edit requests
--------------------------------------------------------------------------------

-- This message determines the display value of the edit request link produced
-- with the ${EDITREQUEST} parameter.
-- It is possible to use banner parameters in this message.
['edit-request-display'] = 'submit an edit request',

--------------------------------------------------------------------------------
-- Expiry date format
--------------------------------------------------------------------------------

-- This is the format for the blurb expiry date. It should be valid input for
-- the first parameter of the #time parser function.
['expiry-date-format'] = 'F j, Y "at" H:i e',

--------------------------------------------------------------------------------
-- Tracking categories
--------------------------------------------------------------------------------

-- These messages determine which tracking categories the module outputs.
['tracking-category-incorrect'] = 'Wikipedia pages with incorrect protection templates',
['tracking-category-template'] = 'Wikipedia template-protected pages other than templates and modules',

--------------------------------------------------------------------------------
-- Images
--------------------------------------------------------------------------------

-- These are images that are not defined by their protection action and protection level.
['image-filename-indef'] = 'Full-protection-shackle.svg',
['image-filename-default'] = 'Transparent.gif',

--------------------------------------------------------------------------------
-- End messages
--------------------------------------------------------------------------------
}

--------------------------------------------------------------------------------
-- End configuration
--------------------------------------------------------------------------------
}</text>
      <sha1>eeb6sgpzkp24z3uln44ko8rah6nhotf</sha1>
    </revision>
  </page>
  <page>
    <title>Module:String</title>
    <ns>828</ns>
    <id>38569505</id>
    <revision>
      <id>970815276</id>
      <parentid>924313232</parentid>
      <timestamp>2020-08-02T15:49:42Z</timestamp>
      <contributor>
        <username>RexxS</username>
        <id>6112901</id>
      </contributor>
      <comment>separate annotations for str.match from those for str._match</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="18033" xml:space="preserve">--[[

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
        [Category: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/tests.
]]

local str = {}

--[[
len

This function returns the length of the target string.

Usage:
{{#invoke:String|len|target_string|}}
OR
{{#invoke:String|len|s=target_string}}

Parameters
    s: The string whose length to report

If invoked using named parameters, Mediawiki will automatically remove any leading or
trailing whitespace from the target string.
]]
function str.len( frame )
    local new_args = str._getParameters( frame.args, {'s'} )
    local s = new_args['s'] or ''
    return mw.ustring.len( s )
end

--[[
sub

This function returns a substring of the target string at specified indices.

Usage:
{{#invoke:String|sub|target_string|start_index|end_index}}
OR
{{#invoke:String|sub|s=target_string|i=start_index|j=end_index}}

Parameters
    s: The string to return a subset of
    i: The fist 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.
]]
function str.sub( frame )
    local new_args = str._getParameters( frame.args, { 's', 'i', 'j' } )
    local s = new_args['s'] or ''
    local i = tonumber( new_args['i'] ) or 1
    local j = tonumber( new_args['j'] ) or -1

    local len = mw.ustring.len( s )

    -- Convert negatives for range checking
    if i &lt; 0 then
        i = len + i + 1
    end
    if j &lt; 0 then
        j = len + j + 1
    end

    if i &gt; len or j &gt; len or i &lt; 1 or j &lt; 1 then
        return str._error( 'String subset index out of range' )
    end
    if j &lt; i then
        return str._error( 'String subset indices out of order' )
    end

    return mw.ustring.sub( s, i, j )
end

--[[
This function implements that features of {{str sub old}} and is kept in order
to maintain these older templates.
]]
function str.sublength( frame )
    local i = tonumber( frame.args.i ) or 0
    local len = tonumber( frame.args.len )
    return mw.ustring.sub( frame.args.s, i + 1, len and ( i + len ) )
end

--[[
_match

This function returns a substring from the source string that matches a
specified pattern. It is exported for use in other modules

Usage:
strmatch = require("Module:String")._match
sresult = strmatch( s, pattern, start, match, plain, nomatch )

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: A flag indicating that the pattern should be understood as plain
        text.  Defaults to false.
    nomatch: If no match is found, output the "nomatch" value rather than an error.

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

* http://www.lua.org/manual/5.1/manual.html#5.4.1
* http://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual#Patterns
* http://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual#Ustring_patterns

]]
-- This sub-routine is exported for use in other modules
function str._match( s, pattern, start, match_index, plain_flag, nomatch )
    if s == '' then
        return str._error( 'Target string is empty' )
    end
    if pattern == '' then
        return str._error( 'Pattern string is empty' )
    end
    start = tonumber(start) or 1
    if math.abs(start) &lt; 1 or math.abs(start) &gt; mw.ustring.len( s ) then
        return str._error( 'Requested start is out of range' )
    end
    if match_index == 0 then
        return str._error( 'Match index is out of range' )
    end
    if plain_flag then
        pattern = str._escapePattern( pattern )
    end

    local result
    if match_index == 1 then
        -- Find first match is simple case
        result = mw.ustring.match( s, pattern, start )
    else
        if start &gt; 1 then
            s = mw.ustring.sub( s, start )
        end

        local iterator = mw.ustring.gmatch(s, pattern)
        if match_index &gt; 0 then
            -- Forward search
            for w in iterator do
                match_index = match_index - 1
                if match_index == 0 then
                    result = w
                    break
                end
            end
        else
            -- Reverse search
            local result_table = {}
            local count = 1
            for w in iterator do
                result_table[count] = w
                count = count + 1
            end

            result = result_table[ count + match_index ]
        end
    end

    if result == nil then
        if nomatch == nil then
            return str._error( 'Match not found' )
        else
            return nomatch
        end
    else
        return result
    end
end

--[[
match

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

Usage:
{{#invoke:String|match|source_string|pattern_string|start_index|match_number|plain_flag|nomatch_output}}
OR
{{#invoke:String|match|s=source_string|pattern=pattern_string|start=start_index
    |match=match_number|plain=plain_flag|nomatch=nomatch_output}}

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: A flag indicating that the pattern should be understood as plain
        text.  Defaults to false.
    nomatch: If no match is found, output the "nomatch" value rather than an error.

If invoked using named parameters, Mediawiki will automatically remove any leading or
trailing whitespace from each string.  In some circumstances this is desirable, in
other cases one may want to preserve the whitespace.

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 Lua patterns, a form of [regular expression], see:

* http://www.lua.org/manual/5.1/manual.html#5.4.1
* http://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual#Patterns
* http://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual#Ustring_patterns

]]
-- This is the entry point for #invoke:String|match
function str.match( frame )
    local new_args = str._getParameters( frame.args, {'s', 'pattern', 'start', 'match', 'plain', 'nomatch'} )
    local s = new_args['s'] or ''
    local start = tonumber( new_args['start'] ) or 1
    local plain_flag = str._getBoolean( new_args['plain'] or false )
    local pattern = new_args['pattern'] or ''
    local match_index = math.floor( tonumber(new_args['match']) or 1 )
    local nomatch = new_args['nomatch']

    return str._match( s, pattern, start, match_index, plain_flag, nomatch )
end

--[[
pos

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

Usage:
{{#invoke:String|pos|target_string|index_value}}
OR
{{#invoke:String|pos|target=target_string|pos=index_value}}

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

If invoked using named parameters, Mediawiki will automatically remove any leading or
trailing whitespace from the target string.  In some circumstances this is desirable, in
other cases one may want to preserve the whitespace.

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.
]]
function str.pos( frame )
    local new_args = str._getParameters( frame.args, {'target', 'pos'} )
    local target_str = new_args['target'] or ''
    local pos = tonumber( new_args['pos'] ) or 0

    if pos == 0 or math.abs(pos) &gt; mw.ustring.len( target_str ) then
        return str._error( 'String index out of range' )
    end

    return mw.ustring.sub( target_str, pos, pos )
end

--[[
str_find

This function duplicates the behavior of {{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
separatetly.
]]
function str.str_find( frame )
    local new_args = str._getParameters( frame.args, {'source', 'target'} )
    local source_str = new_args['source'] or ''
    local target_str = new_args['target'] or ''

    if target_str == '' then
        return 1
    end

    local start = mw.ustring.find( source_str, target_str, 1, true )
    if start == nil then
        start = -1
    end

    return start
end

--[[
find

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

Usage:
{{#invoke:String|find|source_str|target_string|start_index|plain_flag}}
OR
{{#invoke:String|find|source=source_str|target=target_str|start=start_index|plain=plain_flag}}

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 Lua style regular expression, defaults to true

If invoked using named parameters, Mediawiki will automatically remove any leading or
trailing whitespace from the parameter.  In some circumstances this is desirable, in
other cases one may want to preserve the whitespace.

This function returns the first index &gt;= "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.
]]
function str.find( frame )
    local new_args = str._getParameters( frame.args, {'source', 'target', 'start', 'plain' } )
    local source_str = new_args['source'] or ''
    local pattern = new_args['target'] or ''
    local start_pos = tonumber(new_args['start']) or 1
    local plain = new_args['plain'] or true

    if source_str == '' or pattern == '' then
        return 0
    end

    plain = str._getBoolean( plain )

    local start = mw.ustring.find( source_str, pattern, start_pos, plain )
    if start == nil then
        start = 0
    end

    return start
end

--[[
replace

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

Usage:
{{#invoke:String|replace|source_str|pattern_string|replace_string|replacement_count|plain_flag}}
OR
{{#invoke:String|replace|source=source_string|pattern=pattern_string|replace=replace_string|
   count=replacement_count|plain=plain_flag}}

Parameters
    source: The string to search
    pattern: The string or pattern to find within source
    replace: The replacement text
    count: The number of occurences to replace, defaults to all.
    plain: Boolean flag indicating that pattern should be understood as plain
        text and not as a Lua style regular expression, defaults to true
]]
function str.replace( frame )
    local new_args = str._getParameters( frame.args, {'source', 'pattern', 'replace', 'count', 'plain' } )
    local source_str = new_args['source'] or ''
    local pattern = new_args['pattern'] or ''
    local replace = new_args['replace'] or ''
    local count = tonumber( new_args['count'] )
    local plain = new_args['plain'] or true

    if source_str == '' or pattern == '' then
        return source_str
    end
    plain = str._getBoolean( plain )

    if plain then
        pattern = str._escapePattern( pattern )
        replace = mw.ustring.gsub( replace, "%%", "%%%%" ) --Only need to escape replacement sequences.
    end

    local result

    if count ~= nil then
        result = mw.ustring.gsub( source_str, pattern, replace, count )
    else
        result = mw.ustring.gsub( source_str, pattern, replace )
    end

    return result
end

--[[
    simple function to pipe string.rep to templates.
]]
function str.rep( frame )
    local repetitions = tonumber( frame.args[2] )
    if not repetitions then
        return str._error( 'function rep expects a number as second parameter, received "' .. ( frame.args[2] or '' ) .. '"' )
    end
    return string.rep( frame.args[1] or '', repetitions )
end

--[[
escapePattern

This function escapes special characters from a Lua string pattern. See [1]
for details on how patterns work.

[1] https://www.mediawiki.org/wiki/Extension:Scribunto/Lua_reference_manual#Patterns

Usage:
{{#invoke:String|escapePattern|pattern_string}}

Parameters
    pattern_string: The pattern string to escape.
]]
function str.escapePattern( frame )
    local pattern_str = frame.args[1]
    if not pattern_str then
        return str._error( 'No pattern string specified' )
    end
    local result = str._escapePattern( pattern_str )
    return result
end

--[[
count
This function counts the number of occurrences of one string in another.
]]
function str.count(frame)
    local args = str._getParameters(frame.args, {'source', 'pattern', 'plain'})
    local source = args.source or ''
    local pattern = args.pattern or ''
    local plain = str._getBoolean(args.plain or true)
    if plain then
        pattern = str._escapePattern(pattern)
    end
    local _, count = mw.ustring.gsub(source, pattern, '')
    return count
end

--[[
endswith
This function determines whether a string ends with another string.
]]
function str.endswith(frame)
    local args = str._getParameters(frame.args, {'source', 'pattern'})
    local source = args.source or ''
    local pattern = args.pattern or ''
    if pattern == '' then
        -- All strings end with the empty string.
        return "yes"
    end
    if mw.ustring.sub(source, -mw.ustring.len(pattern), -1) == pattern then
        return "yes"
    else
        return ""
    end
end

--[[
join

Join all non empty arguments together; the first argument is the separator.
Usage:
{{#invoke:String|join|sep|one|two|three}}
]]
function str.join(frame)
    local args = {}
    local sep
    for _, v in ipairs( frame.args ) do
        if sep then
            if v ~= '' then
                table.insert(args, v)
            end
        else
            sep = v
        end
    end
    return table.concat( args, sep or '' )
end

--[[
Helper function that populates the argument list given that user may need to use a mix of
named and unnamed parameters.  This is relevant because named parameters are not
identical to unnamed parameters due to string trimming, and when dealing with strings
we sometimes want to either preserve or remove that whitespace depending on the application.
]]
function str._getParameters( frame_args, arg_list )
    local new_args = {}
    local index = 1
    local value

    for _, arg in ipairs( arg_list ) do
        value = frame_args[arg]
        if value == nil then
            value = frame_args[index]
            index = index + 1
        end
        new_args[arg] = value
    end

    return new_args
end

--[[
Helper function to handle error messages.
]]
function str._error( error_str )
    local frame = mw.getCurrentFrame()
    local error_category = frame.args.error_category or 'Errors reported by Module String'
    local ignore_errors = frame.args.ignore_errors or false
    local no_category = frame.args.no_category or false

    if str._getBoolean(ignore_errors) then
        return ''
    end

    local error_str = '&lt;strong class="error"&gt;String Module Error: ' .. error_str .. '&lt;/strong&gt;'
    if error_category ~= '' and not str._getBoolean( no_category ) then
        error_str = '[[Category:' .. error_category .. ']]' .. error_str
    end

    return error_str
end

--[[
Helper Function to interpret boolean strings
]]
function str._getBoolean( boolean_str )
    local boolean_value

    if type( boolean_str ) == 'string' then
        boolean_str = boolean_str:lower()
        if boolean_str == 'false' or boolean_str == 'no' or boolean_str == '0'
                or boolean_str == '' then
            boolean_value = false
        else
            boolean_value = true
        end
    elseif type( boolean_str ) == 'boolean' then
        boolean_value = boolean_str
    else
        error( 'No boolean value found' )
    end
    return boolean_value
end

--[[
Helper function that escapes all pattern characters so that they will be treated
as plain text.
]]
function str._escapePattern( pattern_str )
    return mw.ustring.gsub( pattern_str, "([%(%)%.%%%+%-%*%?%[%^%$%]])", "%%%1" )
end

return str</text>
      <sha1>cufmbepw7ml3gut4lchtqrhtj5r63cp</sha1>
    </revision>
  </page>
  <page>
    <title>Module:TableTools</title>
    <ns>828</ns>
    <id>41371028</id>
    <revision>
      <id>1069058368</id>
      <parentid>1048120640</parentid>
      <timestamp>2022-01-31T13:08:18Z</timestamp>
      <contributor>
        <username>MSGJ</username>
        <id>42630</id>
      </contributor>
      <comment>updates/fixes requested by [[User:Uzume]]</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="15281" xml:space="preserve">------------------------------------------------------------------------------------
--                                   TableTools                                   --
--                                                                                --
-- This module includes a number of functions for dealing with Lua tables.        --
-- It is a meta-module, meant to be called from other Lua modules, and should not --
-- be called directly from #invoke.                                               --
------------------------------------------------------------------------------------

local libraryUtil = require('libraryUtil')

local p = {}

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

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

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

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

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

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

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

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

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

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

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

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

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

------------------------------------------------------------------------------------
-- size
--
-- This returns the size of a key/value pair table. It will also work on arrays,
-- but for arrays it is more efficient to use the # operator.
------------------------------------------------------------------------------------
function p.size(t)
    checkType('size', 1, t, 'table')
    local i = 0
    for _ in pairs(t) do
        i = i + 1
    end
    return i
end

local function defaultKeySort(item1, item2)
    -- "number" &lt; "string", so numbers will be sorted before strings.
    local type1, type2 = type(item1), type(item2)
    if type1 ~= type2 then
        return type1 &lt; type2
    elseif type1 == 'table' or type1 == 'boolean' or type1 == 'function' then
        return tostring(item1) &lt; tostring(item2)
    else
        return item1 &lt; item2
    end
end
------------------------------------------------------------------------------------
-- keysToList
--
-- Returns an array of the keys in a table, sorted using either a default
-- comparison function or a custom keySort function.
------------------------------------------------------------------------------------
function p.keysToList(t, keySort, checked)
    if not checked then
        checkType('keysToList', 1, t, 'table')
        checkTypeMulti('keysToList', 2, keySort, {'function', 'boolean', 'nil'})
    end

    local arr = {}
    local index = 1
    for k in pairs(t) do
        arr[index] = k
        index = index + 1
    end

    if keySort ~= false then
        keySort = type(keySort) == 'function' and keySort or defaultKeySort
        table.sort(arr, keySort)
    end

    return arr
end

------------------------------------------------------------------------------------
-- sortedPairs
--
-- Iterates through a table, with the keys sorted using the keysToList function.
-- If there are only numerical keys, sparseIpairs is probably more efficient.
------------------------------------------------------------------------------------
function p.sortedPairs(t, keySort)
    checkType('sortedPairs', 1, t, 'table')
    checkType('sortedPairs', 2, keySort, 'function', true)

    local arr = p.keysToList(t, keySort, true)

    local i = 0
    return function ()
        i = i + 1
        local key = arr[i]
        if key ~= nil then
            return key, t[key]
        else
            return nil, nil
        end
    end
end

------------------------------------------------------------------------------------
-- isArray
--
-- Returns true if the given value is a table and all keys are consecutive
-- integers starting at 1.
------------------------------------------------------------------------------------
function p.isArray(v)
    if type(v) ~= 'table' then
        return false
    end
    local i = 0
    for _ in pairs(v) do
        i = i + 1
        if v[i] == nil then
            return false
        end
    end
    return true
end

------------------------------------------------------------------------------------
-- isArrayLike
--
-- Returns true if the given value is iterable and all keys are consecutive
-- integers starting at 1.
------------------------------------------------------------------------------------
function p.isArrayLike(v)
    if not pcall(pairs, v) then
        return false
    end
    local i = 0
    for _ in pairs(v) do
        i = i + 1
        if v[i] == nil then
            return false
        end
    end
    return true
end

------------------------------------------------------------------------------------
-- invert
--
-- Transposes the keys and values in an array. For example, {"a", "b", "c"} -&gt;
-- {a = 1, b = 2, c = 3}. Duplicates are not supported (result values refer to
-- the index of the last duplicate) and NaN values are ignored.
------------------------------------------------------------------------------------
function p.invert(arr)
    checkType("invert", 1, arr, "table")
    local isNan = p.isNan
    local map = {}
    for i, v in ipairs(arr) do
        if not isNan(v) then
            map[v] = i
        end
    end

    return map
end

------------------------------------------------------------------------------------
-- listToSet
--
-- Creates a set from the array part of the table. Indexing the set by any of the
-- values of the array returns true. For example, {"a", "b", "c"} -&gt;
-- {a = true, b = true, c = true}. NaN values are ignored as Lua considers them
-- never equal to any value (including other NaNs or even themselves).
------------------------------------------------------------------------------------
function p.listToSet(arr)
    checkType("listToSet", 1, arr, "table")
    local isNan = p.isNan
    local set = {}
    for _, v in ipairs(arr) do
        if not isNan(v) then
            set[v] = true
        end
    end

    return set
end

------------------------------------------------------------------------------------
-- deepCopy
--
-- Recursive deep copy function. Preserves identities of subtables.
------------------------------------------------------------------------------------
local function _deepCopy(orig, includeMetatable, already_seen)
    -- Stores copies of tables indexed by the original table.
    already_seen = already_seen or {}

    local copy = already_seen[orig]
    if copy ~= nil then
        return copy
    end

    if type(orig) == 'table' then
        copy = {}
        for orig_key, orig_value in pairs(orig) do
            copy[_deepCopy(orig_key, includeMetatable, already_seen)] = _deepCopy(orig_value, includeMetatable, already_seen)
        end
        already_seen[orig] = copy

        if includeMetatable then
            local mt = getmetatable(orig)
            if mt ~= nil then
                local mt_copy = _deepCopy(mt, includeMetatable, already_seen)
                setmetatable(copy, mt_copy)
                already_seen[mt] = mt_copy
            end
        end
    else -- number, string, boolean, etc
        copy = orig
    end
    return copy
end

function p.deepCopy(orig, noMetatable, already_seen)
    checkType("deepCopy", 3, already_seen, "table", true)
    return _deepCopy(orig, not noMetatable, already_seen)
end

------------------------------------------------------------------------------------
-- sparseConcat
--
-- Concatenates all values in the table that are indexed by a number, in order.
-- sparseConcat{a, nil, c, d}  =&gt;  "acd"
-- sparseConcat{nil, b, c, d}  =&gt;  "bcd"
------------------------------------------------------------------------------------
function p.sparseConcat(t, sep, i, j)
    local arr = {}

    local arr_i = 0
    for _, v in p.sparseIpairs(t) do
        arr_i = arr_i + 1
        arr[arr_i] = v
    end

    return table.concat(arr, sep, i, j)
end

------------------------------------------------------------------------------------
-- length
--
-- Finds the length of an array, or of a quasi-array with keys such as "data1",
-- "data2", etc., using an exponential search algorithm. It is similar to the
-- operator #, but may return a different value when there are gaps in the array
-- portion of the table. Intended to be used on data loaded with mw.loadData. For
-- other tables, use #.
-- Note: #frame.args in frame object always be set to 0, regardless of  the number
-- of unnamed template parameters, so use this function for frame.args.
------------------------------------------------------------------------------------
function p.length(t, prefix)
    -- requiring module inline so that [[Module:Exponential search]] which is
    -- only needed by this one function doesn't get millions of transclusions
    local expSearch = require("Module:Exponential search")
    checkType('length', 1, t, 'table')
    checkType('length', 2, prefix, 'string', true)
    return expSearch(function (i)
        local key
        if prefix then
            key = prefix .. tostring(i)
        else
            key = i
        end
        return t[key] ~= nil
    end) or 0
end

------------------------------------------------------------------------------------
-- inArray
--
-- Returns true if valueToFind is a member of the array, and false otherwise.
------------------------------------------------------------------------------------
function p.inArray(arr, valueToFind)
    checkType("inArray", 1, arr, "table")
    -- if valueToFind is nil, error?

    for _, v in ipairs(arr) do
        if v == valueToFind then
            return true
        end
    end
    return false
end

return p</text>
      <sha1>0z6y1iz1ggzcjp1rhkrrhgprosuh475</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Transclusion count</title>
    <ns>828</ns>
    <id>61792794</id>
    <revision>
      <id>1061635767</id>
      <parentid>1057474521</parentid>
      <timestamp>2021-12-22T22:48:57Z</timestamp>
      <contributor>
        <username>GKFX</username>
        <id>14918984</id>
      </contributor>
      <comment>Correction to tabulate function</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="2174" xml:space="preserve">local p = {}

function p.fetch(frame)
    local template = nil
    local return_value = nil

    -- Use demo parameter if it exists, otherswise use current template name
    local namespace = mw.title.getCurrentTitle().namespace
    if frame.args["demo"] and frame.args["demo"] ~= "" then
        template = frame.args["demo"]
    elseif namespace == 10 then -- Template namespace
        template = mw.title.getCurrentTitle().text
    elseif namespace == 828 then -- Module namespace
        template = (mw.site.namespaces[828].name .. ":" .. mw.title.getCurrentTitle().text)
    end

    -- If in template or module namespace, look up count in /data
    if template ~= nil then
        namespace = mw.title.new(template, "Template").namespace
        if namespace == 10 or namespace == 828 then
            template =  mw.ustring.gsub(template, "/doc$", "") -- strip /doc from end
            local index = mw.ustring.sub(mw.title.new(template).text,1,1)
            local status, data = pcall(function ()
                return(mw.loadData('Module:Transclusion_count/data/' .. (mw.ustring.find(index, "%a") and index or "other")))
            end)
            if status then
                return_value = tonumber(data[mw.ustring.gsub(template, " ", "_")])
            end
        end
    end

    -- If database value doesn't exist, use value passed to template
    if return_value == nil and frame.args[1] ~= nil then
        local arg1=mw.ustring.match(frame.args[1], '[%d,]+')
        if arg1 and arg1 ~= '' then
            return_value = tonumber(frame:callParserFunction('formatnum', arg1, 'R'))
        end
    end

    return return_value
end

-- Tabulate this data for [[Wikipedia:Database reports/Templates transcluded on the most pages]]
function p.tabulate(frame)
    local list = {}
    for i = 65, 91 do
        local data = mw.loadData('Module:Transclusion count/data/' .. ((i == 91) and 'other' or string.char(i)))
        for name, count in pairs(data) do
            table.insert(list, {mw.title.new(name, "Template").fullText, count})
        end
    end
    table.sort(list, function(a, b)
        return (a[2] == b[2]) and (a[1] &lt; b[1]) or (a[2] &gt; b[2])
    end)
    local lang = mw.getContentLanguage();
    for i = 1, #list do
        list[i] = ('|-\n| %d || [[%s]] || %s\n'):format(i, list[i][1]:gsub('_', ' '), lang:formatNum(list[i][2]))
    end
    return table.concat(list)
end

return p</text>
      <sha1>i4hf4ogs2jqprtn91iinnikcxeyynd9</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Transclusion count/data/M</title>
    <ns>828</ns>
    <id>61481077</id>
    <revision>
      <id>1071544693</id>
      <parentid>1070187754</parentid>
      <timestamp>2022-02-13T05:13:35Z</timestamp>
      <contributor>
        <username>Ahechtbot</username>
        <id>26109785</id>
      </contributor>
      <minor/>
      <comment>[[Wikipedia:BOT|Bot]]: Updated page.</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="3889" xml:space="preserve">return {
["MAD"] = 2000,
["MAR"] = 2600,
["MAS"] = 2400,
["MDG"] = 2200,
["MEX"] = 6000,
["MILHIST"] = 12000,
["MINUTE"] = 2300,
["MKD"] = 2300,
["MLB_Farm_System"] = 2100,
["MLB_Year"] = 13000,
["MLB_standings"] = 3700,
["MLBplayer"] = 4000,
["MMA_record_start"] = 3500,
["MMArecordbox"] = 3500,
["MMSI_Number"] = 3000,
["MONTH"] = 6400,
["MONTHNAME"] = 740000,
["MONTHNUMBER"] = 751000,
["MS"] = 4600,
["MV"] = 8400,
["MYS"] = 3500,
["MacTutor"] = 2000,
["Main"] = 309000,
["Main_article"] = 27000,
["Main_other"] = 8960000,
["Main_page_image"] = 20000,
["Main_page_image/DYK"] = 5800,
["Main_page_image/TFA"] = 3600,
["Maintenance_category"] = 35000,
["Map_requested"] = 9800,
["Map_requested/Category_helper"] = 8300,
["Maplink"] = 18000,
["Marriage"] = 57000,
["Math"] = 7900,
["MathGenealogy"] = 6700,
["MathWorld"] = 2400,
["Maths_rating"] = 20000,
["Max"] = 230000,
["Mbox"] = 2190000,
["Mdash"] = 7900,
["MeSH_name"] = 6000,
["Medal"] = 104000,
["MedalBottom"] = 17000,
["MedalBronze"] = 50000,
["MedalCompetition"] = 80000,
["MedalCount"] = 2400,
["MedalCountry"] = 73000,
["MedalGold"] = 49000,
["MedalOlympic"] = 3900,
["MedalOlympics"] = 6000,
["MedalSilver"] = 49000,
["MedalSport"] = 73000,
["MedalTableTop"] = 17000,
["MedalTop"] = 4400,
["MedalWorldChampionships"] = 2200,
["MedalistTable"] = 13000,
["Medals_table"] = 12000,
["Media"] = 2500,
["Medical_resources"] = 6700,
["Merge_done"] = 2700,
["Merge_partner"] = 3000,
["Merged-from"] = 14000,
["Merged-to"] = 16000,
["Merged_to"] = 2100,
["MeshName"] = 5900,
["Metacritic_film"] = 4100,
["Metadata_Population_DE-BY"] = 2100,
["Metadata_Population_DE-RP"] = 2300,
["Mhof"] = 6700,
["Mid-Class"] = 15000,
["Mid-importance"] = 15000,
["Middot"] = 79000,
["MilHist"] = 2500,
["Military_navigation"] = 79000,
["Min"] = 18000,
["Minor_planet"] = 4800,
["Minor_planet_link"] = 2600,
["Minor_planet_list_link"] = 4100,
["Minor_planets_navigator"] = 3100,
["MirrorH"] = 4700,
["Missing_information"] = 3000,
["Mlby"] = 13000,
["Mobile_IP"] = 9900,
["MobyGames"] = 7600,
["Moby_game"] = 6100,
["Mod"] = 14000,
["Module_other"] = 3100,
["Mojo_title"] = 7800,
["Molecular_formula_index"] = 2200,
["Monday"] = 2600,
["Mono"] = 17000,
["Mono/styles.css"] = 18000,
["MonthCategoryNav"] = 28000,
["MonthlyArchive"] = 2700,
["MonthlyLinks"] = 2700,
["Monthly_archive_list"] = 2700,
["Monthly_clean-up_category"] = 14000,
["Monthly_clean-up_category/core"] = 14000,
["Monthly_clean-up_category/monthname"] = 15000,
["Monthly_clean-up_category/monthno"] = 15000,
["Monthly_clean-up_category/name_part"] = 15000,
["Monthly_clean-up_category/outer_core"] = 14000,
["Monthly_clean-up_category/to_add"] = 2500,
["Monthly_clean_up_category"] = 7600,
["Monthyear"] = 89000,
["Monthyear-1"] = 87000,
["More_citations_needed"] = 365000,
["More_citations_needed_section"] = 16000,
["More_footnotes"] = 47000,
["More_footnotes_needed"] = 50000,
["More_references"] = 3400,
["Moresources"] = 5900,
["Motorcycling"] = 3200,
["Motorsport_season"] = 4600,
["Motorsport_season/styles.css"] = 4600,
["Moved_discussion_from"] = 2400,
["Moved_discussion_to"] = 2300,
["Mp"] = 4800,
["Mpl"] = 2600,
["MultiReplace"] = 198000,
["Multiple_image"] = 39000,
["Multiple_image/styles.css"] = 39000,
["Multiple_issues"] = 120000,
["Music"] = 7200,
["MusicBrainz_artist"] = 2100,
["MusicBrainz_meta"] = 4400,
["Mvar"] = 5400,
["Mw_lang"] = 68000,
["My"] = 2400,
["My_sandbox"] = 3800,
["Myprefs"] = 9000,
["Module:MLB_standings"] = 3700,
["Module:MLB_standings/data"] = 3700,
["Module:Main_page_image"] = 9900,
["Module:Mapframe"] = 362000,
["Module:Math"] = 1480000,
["Module:Medals_table"] = 12000,
["Module:Message_box"] = 8920000,
["Module:Message_box/configuration"] = 8920000,
["Module:Military_navigation"] = 79000,
["Module:Minor_planet_list_link"] = 4100,
["Module:MultiReplace"] = 580000,
["Module:Multiple_image"] = 39000,
["Module:Mw_lang"] = 69000,
}</text>
      <sha1>qdzbibfhs0x3zmqrqgv33umbkeln73y</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Message box/configuration/doc</title>
    <ns>828</ns>
    <id>41157099</id>
    <revision>
      <id>1044612974</id>
      <parentid>1044543567</parentid>
      <timestamp>2021-09-16T04:44:59Z</timestamp>
      <contributor>
        <username>Pppery</username>
        <id>28032115</id>
      </contributor>
      <comment>Undid revision 1044543567 by [[Special:Contributions/Tiwutt12|Tiwutt12]] ([[User talk:Tiwutt12|talk]])</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="228" xml:space="preserve">{{Used in system}}
{{Module rating|protected}}
{{#ifeq:{{PAGENAME}}|Message box/configuration/sandbox|
{{Mbox|small=yes|type=notice|text=See related module:
* [[Module:Message box]] ([[Module:Message box/sandbox|sandbox]])
}}
}}</text>
      <sha1>fj3zeas2cqac302rr9ff1x8xdr4obio</sha1>
    </revision>
  </page>
  <page>
    <title>Module:No globals/doc</title>
    <ns>828</ns>
    <id>42567040</id>
    <revision>
      <id>1061323199</id>
      <parentid>1022000984</parentid>
      <timestamp>2021-12-21T01:09:31Z</timestamp>
      <contributor>
        <username>EthanGaming7640</username>
        <id>42316941</id>
      </contributor>
      <minor/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="923" xml:space="preserve">{{used in system}}
{{module rating|protected}}
&lt;!-- Template categories go at the bottom of this page. --&gt;

This module causes an error if any nil [[global variable|global]] is read or if any global is written to, with the exception of &lt;var&gt;arg&lt;/var&gt;. To use, add &lt;syntaxhighlight lang="lua" inline&gt;require('Module:No globals')&lt;/syntaxhighlight&gt; to the top of the module using it. The &lt;var&gt;arg&lt;/var&gt; variable is excluded because it is necessary for Scribunto's [[mw:Extension:Scribunto/Lua reference manual#require|require]] function to work properly. (See the Scribunto source code [[phab:diffusion/ELUA/browse/master/includes/engines/LuaCommon/lualib/package.lua;1fad4da13706f4dbdd0477a834675b9d09757bf6|here]].)

== See also ==
* [[Module:Log globals]] – adds all nil global reads/writes to the Lua log

&lt;includeonly&gt;{{Sandbox other||
&lt;!-- Template categories go here. --&gt;
[[Category:Lua metamodules]]
}}&lt;/includeonly&gt;</text>
      <sha1>4h7oec1hp3umv1zzbntaenb888t73cg</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Transclusion count/data/N</title>
    <ns>828</ns>
    <id>61481068</id>
    <revision>
      <id>1071545058</id>
      <parentid>1070187547</parentid>
      <timestamp>2022-02-13T05:15:36Z</timestamp>
      <contributor>
        <username>Ahechtbot</username>
        <id>26109785</id>
      </contributor>
      <minor/>
      <comment>[[Wikipedia:BOT|Bot]]: Updated page.</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="7724" xml:space="preserve">return {
["N"] = 11000,
["N/A"] = 20000,
["N/a"] = 45000,
["NA-Class"] = 14000,
["NASTRO_comment"] = 29000,
["NBA_Draft_template_list"] = 3200,
["NBA_Year"] = 5400,
["NBA_color"] = 3600,
["NBA_color_cell"] = 4300,
["NBA_color_cell2"] = 3400,
["NBA_player_statistics_legend"] = 3700,
["NBA_player_statistics_start"] = 3300,
["NBbox"] = 3400,
["NCAA_color_cell"] = 8000,
["NCAA_secondary_color_cell"] = 3800,
["NED"] = 9500,
["NEXTYEAR"] = 6300,
["NFLAltPrimaryColor"] = 2100,
["NFLAltPrimaryStyle"] = 5700,
["NFLAltSecondaryColor"] = 2400,
["NFLPrimaryColor"] = 2100,
["NFLPrimaryStyle"] = 27000,
["NFLSecondaryColor"] = 18000,
["NFL_Roster_navbox_template_list"] = 2500,
["NFL_Year"] = 21000,
["NFL_predraft"] = 4200,
["NFL_predraft/check"] = 4200,
["NFL_predraft/ftin"] = 4200,
["NFT"] = 6200,
["NFT_player"] = 30000,
["NGA"] = 2900,
["NGR"] = 2100,
["NHLE"] = 16000,
["NHLS_url"] = 2200,
["NLD"] = 11000,
["NLM_content"] = 2800,
["NOINDEX"] = 418000,
["NOMIS2011"] = 2200,
["NOR"] = 8900,
["NRDB_species"] = 5900,
["NRHP-PA"] = 2600,
["NRHPGoogleMapFootnote"] = 2500,
["NRHP_Focus"] = 75000,
["NRHP_color"] = 3700,
["NRHP_date_for_lists"] = 3100,
["NRHP_date_for_lists/dates"] = 3100,
["NRHP_header"] = 3300,
["NRHP_navigation_box"] = 8000,
["NRHP_row"] = 3400,
["NRHP_style"] = 69000,
["NRHP_url"] = 28000,
["NRHP_url/core"] = 30000,
["NRISref"] = 72000,
["NSWcity"] = 2200,
["NSWcity/core"] = 2200,
["NUMBEROFSECTIONS"] = 3300,
["NYCS_br"] = 2700,
["NYCS_time_2"] = 3100,
["NZL"] = 6700,
["NZ_electorate_link"] = 2200,
["Nac"] = 2200,
["Namespace_detect"] = 522000,
["Namespace_detect_showall"] = 5300,
["Nastaliq"] = 9300,
["Nat_fs_end"] = 2200,
["National_Heritage_List_for_England"] = 20000,
["National_Rail_style"] = 5500,
["National_Register_of_Historic_Places"] = 29000,
["National_Register_of_Historic_Places_in_Massachusetts"] = 4300,
["National_Register_of_Historic_Places_in_New_York"] = 5500,
["National_Register_of_Historic_Places_in_North_Carolina"] = 2900,
["National_Register_of_Historic_Places_in_Pennsylvania"] = 3200,
["National_Register_of_Historic_Places_in_Virginia"] = 3100,
["National_basketball_squad"] = 3300,
["National_field_hockey_squad"] = 3800,
["National_football_squad_end"] = 2800,
["National_football_squad_start/styles.css"] = 2300,
["National_rugby_union_team"] = 3400,
["National_squad"] = 39000,
["National_squad_no_numbers"] = 16000,
["Native_name"] = 13000,
["Native_name_checker"] = 76000,
["Naval"] = 2100,
["Naval/core"] = 2100,
["Navbar"] = 939000,
["Navbar-collapsible"] = 3400,
["Navbar-header"] = 15000,
["Navbar-header/styles.css"] = 15000,
["Navbox"] = 2940000,
["Navbox_GR_munic"] = 3400,
["Navbox_Musical_artist"] = 9600,
["Navbox_bottom"] = 14000,
["Navbox_decade_list"] = 11000,
["Navbox_musical_artist"] = 212000,
["Navbox_musical_artist/color"] = 212000,
["Navbox_rugby_league_squad"] = 5100,
["Navbox_season_by_team"] = 3100,
["Navbox_top"] = 14000,
["Navbox_with_collapsible_groups"] = 130000,
["Navbox_with_collapsible_sections"] = 2200,
["Navbox_with_columns"] = 23000,
["Navboxes"] = 50000,
["Navboxes_colour"] = 7200,
["Navseasoncats"] = 446000,
["Navseasoncats_with_centuries_below_decade"] = 6100,
["Navseasoncats_with_decades_below_year"] = 19000,
["Navsource"] = 2500,
["Navy"] = 18000,
["Navy/core"] = 18000,
["Nay"] = 13000,
["Nbay"] = 5400,
["Nbsp"] = 445000,
["Nbsp_to_space"] = 17000,
["Ndash"] = 17000,
["Nee"] = 5300,
["NeilBrownPlayers"] = 3100,
["New_York_Stock_Exchange"] = 2000,
["New_user_bar"] = 57000,
["Newbot"] = 4100,
["Next_period"] = 19000,
["Nfly"] = 2000,
["Nihongo"] = 98000,
["Nihongo2"] = 12000,
["Nihongo_foot"] = 2200,
["No"] = 7100,
["No."] = 14000,
["No2"] = 9100,
["NoSpam"] = 4100,
["NoSpamEmail"] = 17000,
["No_col_break"] = 2100,
["No_col_break/styles.css"] = 2100,
["No_footnotes"] = 52000,
["No_ping"] = 434000,
["No_plot"] = 4100,
["No_redirect"] = 522000,
["No_spam"] = 241000,
["No_wrap"] = 2100,
["Nobold"] = 360000,
["Nobold/styles.css"] = 360000,
["Nobr"] = 4000,
["Nobreak"] = 28000,
["Nochange"] = 2300,
["Noflag"] = 2100,
["Nofootnotes"] = 2100,
["Noindex"] = 4700,
["Noitalic"] = 4500,
["Noitalic/styles.css"] = 4500,
["Nom"] = 33000,
["Nominated"] = 5900,
["Non-admin_closure"] = 2300,
["Non-diffusing_subcategory"] = 12000,
["Non-free_2D_art"] = 6300,
["Non-free_3D_art"] = 2100,
["Non-free_album_cover"] = 192000,
["Non-free_audio_sample"] = 8600,
["Non-free_biog-pic"] = 21000,
["Non-free_book_cover"] = 52000,
["Non-free_comic"] = 11000,
["Non-free_fair_use"] = 18000,
["Non-free_fair_use_in"] = 15000,
["Non-free_film_screenshot"] = 5100,
["Non-free_game_cover"] = 6500,
["Non-free_game_screenshot"] = 4100,
["Non-free_historic_image"] = 16000,
["Non-free_image_data"] = 8300,
["Non-free_image_rationale"] = 9500,
["Non-free_in_US"] = 2100,
["Non-free_logo"] = 159000,
["Non-free_magazine_cover"] = 7400,
["Non-free_media"] = 698000,
["Non-free_media_data"] = 9400,
["Non-free_media_rationale"] = 11000,
["Non-free_movie_poster"] = 19000,
["Non-free_poster"] = 96000,
["Non-free_promotional"] = 9000,
["Non-free_school_logo"] = 2300,
["Non-free_seal"] = 3500,
["Non-free_symbol"] = 6200,
["Non-free_television_screenshot"] = 16000,
["Non-free_title-card"] = 4700,
["Non-free_use_rationale"] = 449000,
["Non-free_use_rationale_2"] = 190000,
["Non-free_use_rationale_album_cover"] = 127000,
["Non-free_use_rationale_book_cover"] = 17000,
["Non-free_use_rationale_logo"] = 97000,
["Non-free_use_rationale_poster"] = 47000,
["Non-free_use_rationale_title-card"] = 2100,
["Non-free_use_rationale_video_cover"] = 5600,
["Non-free_use_rationale_video_game_cover"] = 9500,
["Non-free_video_cover"] = 16000,
["Non-free_video_game_cover"] = 20000,
["Non-free_video_game_cover/platform"] = 20000,
["Non-free_video_game_screenshot"] = 9800,
["Non-free_video_game_screenshot/platform"] = 9100,
["Non-free_with_permission"] = 2200,
["Nonumtoc"] = 2200,
["Nonumtoc/styles.css"] = 2200,
["Noping"] = 359000,
["Noprint"] = 2800,
["Noredirect"] = 7900,
["Normalwraplink"] = 3100,
["NorthAmNative"] = 2600,
["North_America_topic"] = 3700,
["Northern_Ireland_tasks"] = 19000,
["Nospam"] = 13000,
["Not-PD-US-expired-min-year"] = 26000,
["Not_a_ballot"] = 7400,
["Not_a_forum"] = 7300,
["Not_a_typo"] = 8200,
["Not_around"] = 2700,
["Not_done"] = 18000,
["Notability"] = 59000,
["Notavote"] = 2000,
["Notdone"] = 5200,
["Note"] = 25000,
["NoteFoot"] = 3000,
["NoteTag"] = 3000,
["Note_label"] = 8600,
["Notelist"] = 140000,
["Notelist-lr"] = 3000,
["Notelist-ua"] = 5500,
["Notes"] = 6400,
["Noteslist"] = 2800,
["Notice"] = 104000,
["NovelsWikiProject"] = 19000,
["Nowiki_="] = 3800,
["Nowrap"] = 1390000,
["Npby"] = 2100,
["Nq"] = 2800,
["Nrut"] = 3400,
["Ns"] = 2300,
["Ns0"] = 328000,
["Ns_has_subpages"] = 1820000,
["Nts"] = 15000,
["Ntsh"] = 3000,
["Number_of_defined_parameters"] = 4400,
["Number_table_sorting"] = 27000,
["Number_table_sorting_hidden"] = 3000,
["Nutshell"] = 3700,
["Nw="] = 3800,
["Module:NUMBEROFSECTIONS"] = 3300,
["Module:Namespace_detect"] = 14300000,
["Module:Namespace_detect/config"] = 15600000,
["Module:Namespace_detect/data"] = 15600000,
["Module:National_squad"] = 52000,
["Module:Native_name"] = 85000,
["Module:Navbar"] = 6090000,
["Module:Navbar/configuration"] = 5410000,
["Module:Navbar/styles.css"] = 4790000,
["Module:Navbox"] = 4250000,
["Module:Navbox/configuration"] = 4120000,
["Module:Navbox/styles.css"] = 4120000,
["Module:Navbox_top_and_bottom"] = 14000,
["Module:Navbox_with_collapsible_groups"] = 135000,
["Module:Navboxes"] = 51000,
["Module:Navseasoncats"] = 446000,
["Module:Nihongo"] = 100000,
["Module:No_globals"] = 18000000,
["Module:No_ping"] = 434000,
["Module:Noinclude"] = 368000,
["Module:Ns_has_subpages"] = 1820000,
["Module:Number_table_sorting"] = 29000,
}</text>
      <sha1>iy6voi40ghymue0cyb4o5zma8u59cvh</sha1>
    </revision>
  </page>
  <page>
    <title>Template:Template link with link off</title>
    <ns>10</ns>
    <id>16451586</id>
    <revision>
      <id>989853150</id>
      <parentid>989724556</parentid>
      <timestamp>2020-11-21T12:06:17Z</timestamp>
      <contributor>
        <username>Primefac</username>
        <id>11508456</id>
      </contributor>
      <comment>update</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="231" xml:space="preserve">&lt;includeonly&gt;{{#Invoke:Template link general|main|nowrap=yes|nolink=yes}}&lt;/includeonly&gt;&lt;noinclude&gt;
{{Documentation|1=Template:Tlg/doc
|content = {{tlg/doc|tlf}}
}}
&lt;!-- Add categories to the /doc subpage, not here! --&gt;
&lt;/noinclude&gt;</text>
      <sha1>kmn80yu5079jyyvwn623d36xsqq3dch</sha1>
    </revision>
  </page>
  <page>
    <title>Template:Tlf</title>
    <ns>10</ns>
    <id>63645417</id>
    <redirect title="Template:Template link with link off" />
    <revision>
      <id>950726704</id>
      <timestamp>2020-04-13T14:42:57Z</timestamp>
      <contributor>
        <username>Primefac</username>
        <id>11508456</id>
      </contributor>
      <comment>Primefac moved page [[Template:Tlf]] to [[Template:Template link with link off]]: full name to indicate what it does</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="97" xml:space="preserve">#REDIRECT [[Template:Template link with link off]]

{{Redirect category shell|
{{R from move}}
}}</text>
      <sha1>9mrb4gzoa8i94zzxq5i6opzke6v5ntr</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Category handler/blacklist</title>
    <ns>828</ns>
    <id>43232926</id>
    <revision>
      <id>951673917</id>
      <parentid>948472491</parentid>
      <timestamp>2020-04-18T08:48:05Z</timestamp>
      <contributor>
        <username>Jo-Jo Eumerus</username>
        <id>17449355</id>
      </contributor>
      <comment>Per category talk page</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="761" xml:space="preserve">-- This module contains the blacklist used by [[Module:Category handler]].
-- Pages that match Lua patterns in this list will not be categorised unless
-- categorisation is explicitly requested.

return {
    '^Main Page$', -- don't categorise the main page.

    -- Don't categorise the following pages or their subpages.
    -- "%f[/\0]" matches if the next character is "/" or the end of the string.
    '^Wikipedia:Cascade%-protected items%f[/\0]',
    '^User:UBX%f[/\0]', -- The userbox "template" space.
    '^User talk:UBX%f[/\0]',

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

    -- Don't categorise archives.
    '/[aA]rchive',
    "^Wikipedia:Administrators' noticeboard/IncidentArchive%d+$",
}</text>
      <sha1>fsv1drcay6t25e91hzhqxtyp7pckbpx</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Category handler/config</title>
    <ns>828</ns>
    <id>42291997</id>
    <revision>
      <id>948472494</id>
      <parentid>894414603</parentid>
      <timestamp>2020-04-01T06:12:40Z</timestamp>
      <contributor>
        <username>MusikAnimal</username>
        <id>14882394</id>
      </contributor>
      <minor/>
      <comment>1 revision imported</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="5755" xml:space="preserve">--------------------------------------------------------------------------------
--            [[Module:Category handler]] configuration data                  --
--       Language-specific parameter names and values can be set here.        --
--       For blacklist config, see [[Module:Category handler/blacklist]].     --
--------------------------------------------------------------------------------

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

--------------------------------------------------------------------------------
--                       Start configuration data                             --
--------------------------------------------------------------------------------

--------------------------------------------------------------------------------
--                              Parameter names                               --
-- These configuration items specify custom parameter names.                  --
-- To add one extra name, you can use this format:                            --
--                                                                            --
-- foo = 'parameter name',                                                    --
--                                                                            --
-- To add multiple names, you can use this format:                            --
--                                                                            --
-- foo = {'parameter name 1', 'parameter name 2', 'parameter name 3'},        --
--------------------------------------------------------------------------------

cfg.parameters = {

    -- The nocat and categories parameter suppress
    -- categorisation. They are used with Module:Yesno, and work as follows:
    --
    -- cfg.nocat:
    -- Result of yesno()                        Effect
    -- true                                     Categorisation is suppressed
    -- false                                    Categorisation is allowed, and
    --                                          the blacklist check is skipped
    -- nil                                      Categorisation is allowed
    --
    -- cfg.categories:
    -- Result of yesno()                        Effect
    -- true                                     Categorisation is allowed, and
    --                                          the blacklist check is skipped
    -- false                                    Categorisation is suppressed
    -- nil                                      Categorisation is allowed
    nocat = 'nocat',
    categories = 'categories',

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

    -- cfg.subpage is the parameter name to specify how to behave on subpages.
    subpage = 'subpage',

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

    -- The parameter name for data to return if no data is specified for the
    -- namespace that is detected.
    other = 'other',

    -- The parameter name used to specify a page other than the current page;
    -- used for testing and demonstration.
    demopage = 'page',
}

--------------------------------------------------------------------------------
--                              Parameter values                              --
-- These are set values that can be used with certain parameters. Only one    --
-- value can be specified, like this:                                         --
--                                                                            --
-- cfg.foo = 'value name'                                                     --                                               --
--------------------------------------------------------------------------------

-- The following settings are used with the cfg.category2 parameter. Setting
-- cfg.category2 to cfg.category2Yes skips the blacklist, and if cfg.category2
-- is present but equal to anything other than cfg.category2Yes or
-- cfg.category2Negative then it supresses cateogrisation.
cfg.category2Yes = 'yes'
cfg.category2Negative = '¬'

-- The following settings are used with the cfg.subpage parameter.
-- cfg.subpageNo is the value to specify to not categorise on subpages;
-- cfg.subpageOnly is the value to specify to only categorise on subpages.
cfg.subpageNo = 'no'
cfg.subpageOnly = 'only'

--------------------------------------------------------------------------------
--                           Default namespaces                               --
-- This is a table of namespaces to categorise by default. The keys are the   --
-- namespace numbers.                                                         --
--------------------------------------------------------------------------------

cfg.defaultNamespaces = {
    [  0] = true, -- main
    [  6] = true, -- file
    [ 12] = true, -- help
    [ 14] = true, -- category
    [100] = true, -- portal
    [108] = true, -- book
}

--------------------------------------------------------------------------------
--                                Wrappers                                    --
-- This is a wrapper template or a list of wrapper templates to be passed to  --
-- [[Module:Arguments]].                                                      --
--------------------------------------------------------------------------------

cfg.wrappers = 'Template:Category handler'

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

return cfg -- Don't edit this line.</text>
      <sha1>6ga9hbq2pdwalsvx68i53dmbr421rq5</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Category handler/data</title>
    <ns>828</ns>
    <id>43233647</id>
    <revision>
      <id>948472496</id>
      <parentid>894414581</parentid>
      <timestamp>2020-04-01T06:12:41Z</timestamp>
      <contributor>
        <username>MusikAnimal</username>
        <id>14882394</id>
      </contributor>
      <minor/>
      <comment>1 revision imported</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="631" xml:space="preserve">-- This module assembles data to be passed to [[Module:Category handler]] using
-- mw.loadData. This includes the configuration data and whether the current
-- page matches the title blacklist.

local data = require('Module:Category handler/config')
local mShared = require('Module:Category handler/shared')
local blacklist = require('Module:Category handler/blacklist')
local title = mw.title.getCurrentTitle()

data.currentTitleMatchesBlacklist = mShared.matchesBlacklist(
    title.prefixedText,
    blacklist
)

data.currentTitleNamespaceParameters = mShared.getNamespaceParameters(
    title,
    mShared.getParamMappings()
)

return data</text>
      <sha1>k26mwixuaeijisfddb0sxkg82iux8v4</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Category handler/doc</title>
    <ns>828</ns>
    <id>40436042</id>
    <revision>
      <id>1016534711</id>
      <parentid>966506718</parentid>
      <timestamp>2021-04-07T17:55:55Z</timestamp>
      <contributor>
        <username>GKFX</username>
        <id>14918984</id>
      </contributor>
      <comment>Remove {{high-use}} as now redundant to {{used in system}}</comment>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="17231" xml:space="preserve">{{Used in system}}
{{Module rating|p}}

This module implements the {{tl|category handler}} template. The category handler template helps other templates to automate both categorization and [[Wikipedia:Category suppression|category suppression]]. For information about using the category handler template in other templates, please see the '''[[Template:Category handler|template documentation]]'''. Keep reading for information about using the category handler module in other Lua modules, or for information on exporting this module to other wikis.

== Use from other Lua modules ==

=== When not to use this module ===

For cases where a module only needs to categorise in one of the namespaces main (articles), file (images) or category, then using this module is overkill. Instead, you can simply get a title object using [[mw:Extension:Scribunto/Lua reference manual#mw.title.getCurrentTitle|mw.title.getCurrentTitle]] and check the &lt;code&gt;nsText&lt;/code&gt; field. For example:
&lt;syntaxhighlight lang="lua"&gt;
local title = mw.title.getCurrentTitle()
if title.nsText == 'File' then
    -- do something
end
&lt;/syntaxhighlight&gt;
However, if your module needs to categorize in any other namespace, then we recommend you use this module, since it provides proper category suppression and makes it easy to select how to categorize in the different namespaces.

=== Namespaces ===

This module detects and groups all the different [[Wikipedia:Namespace|namespaces]] used on Wikipedia into several types. These types are used as parameter names in this module.

:'''main''' = Main/article space, as in normal Wikipedia articles.
:'''talk''' = Any talk space, such as page names that start with "Talk:", "User talk:", "File talk:" and so on.
:'''user, wikipedia, file ... = The other namespaces except the talk pages. Namespace aliases are also accepted. See the table below for the full list.'''
:'''other''' = Any namespaces that were not specified as a parameter to the template. See examples below.

;List of possible namespace parameters
(excluding &lt;code&gt;''talk''&lt;/code&gt; and &lt;code&gt;''other''&lt;/code&gt;)
{{#invoke:Namespace detect|table}}

=== Basic usage ===

This module takes two or more parameters. Here's an example using a hello world program:

&lt;syntaxhighlight lang="lua"&gt;
p = {}
local categoryHandler = require( 'Module:Category handler' ).main

function p.main( frame )
    local result = 'Hello world!'
    local category = categoryHandler{
        '[[Category:Somecat]]',
        nocat = frame.args.nocat -- So "nocat=true/false" works
    }
    category = category or '' -- Check that we don't have a nil value for the category variable.
    return result .. category
end

return p
&lt;/syntaxhighlight&gt;

The above example uses the default settings for the category handler module. That means the example module will categorize on pages in the following namespaces:
:'''main''', '''file''', '''help''', '''category''', '''portal''' and '''book'''
But it will ''not'' categorize in any other namespaces, e.g.:
:'''talk''', '''user''', '''wikipedia''', '''mediawiki''', '''template''' ...

And it will ''not'' categorize on blacklisted pages. (See section [[#Blacklist|blacklist]] below.)

The reason the category handler module does not categorize in some of the namespaces is that in those namespaces most modules and templates are just demonstrated or listed, not used. Thus most modules and templates should not categorize in those namespaces.

Any module or template that is meant for one or more of the namespaces where this module categorizes can use the basic syntax as shown above.

=== Advanced usage ===

This module takes one or more parameters named after the different page types as listed in section [[#Namespaces|namespaces]] above. By using those parameters you can specify exactly in which namespaces your template should categorize. Like this:

&lt;syntaxhighlight lang="lua"&gt;
p = {}
local categoryHandler = require( 'Module:Category handler' ).main

function p.main( frame )
    local result = 'This is a module meant for articles and talk pages.'
    local category = categoryHandler{
        main = '[[Category:Somecat1]]', -- Categorize in main (article) space
        talk = '[[Category:Somecat2]]', -- Categorize in talk space
        nocat = frame.args.nocat -- So "nocat=true/false" works
    }
    category = category or '' -- Check that we don't have a nil value for the category variable.
    return result .. category
end

return p
&lt;/syntaxhighlight&gt;

The above module will only categorize in main and talk space. But it will not categorize on /archive pages since they are blacklisted. (See section [[#Blacklist|blacklist]] below.) And if you need to demonstrate (discuss) the module on a talkpage, then you can feed "&lt;code&gt;nocat='true'&lt;/code&gt;" to prevent that template from categorizing. (See section [[#Nocat|nocat]] below.) Like this:

&lt;pre&gt;
== My new module ==
Hey guys, have you seen my new module?
{{#invoke:mymodule|main|nocat=true}}
Nice, isn't it?
--~~~~
&lt;/pre&gt;

Sometimes we want to use the same category in several namespaces, then do like this:

&lt;syntaxhighlight lang="lua"&gt;
p = {}
local categoryHandler = require( 'Module:Category handler' ).main

function p.main( frame )
    local result = 'This is a module used in several namespaces.'
    local category = categoryHandler{
        main = '[[Category:Somecat1]]',
        [ 1 ] = '[[Category:Somecat2]]', -- For help and user space
        help = 1,
        user = 1,
        talk = '', -- No categories on talk pages
        other = '[[Category:Somecat3]]', -- For all other namespaces
        nocat = frame.args.nocat -- So "nocat=true/false" works
    }
    category = category or '' -- Check that we don't have a nil value for the category variable.
    return result .. category
end

return p
&lt;/syntaxhighlight&gt;

In the above example we use a numbered parameter to feed one of the categories, and then we tell this module to use that numbered parameter for both the help and user space.

The category handler module understands an unlimited number of numbered parameters.

The '''other''' parameter defines what should be used in the remaining namespaces that have not explicitly been fed data.

Note the empty but defined '''talk''' parameter. That stops this module from showing what has been fed to the '''other''' parameter, when in talk space.

The category handler module also has a parameter called '''all'''. It works like this:

&lt;syntaxhighlight lang="lua"&gt;
p = {}
local categoryHandler = require( 'Module:Category handler' ).main

function p.main( frame )
    local result = 'This is a module used in all namespaces.'
    local category = categoryHandler{
        all = '[[Category:Somecat1]]', -- Categorize in all namespaces
        nocat = frame.args.nocat -- So "nocat=true/false" works
    }
    category = category or '' -- Check that we don't have a nil value for the category variable.
    return result .. category
end

return p
&lt;/syntaxhighlight&gt;

The above example will categorize in all namespaces, but not on blacklisted pages. If you want to demonstrate that module on a page, then use "&lt;code&gt;nocat=true&lt;/code&gt;" to prevent the template from categorizing.

We suggest avoiding the '''all''' parameter, since modules and templates should preferably only categorize in the namespaces they need to.

The all parameter can also be combined with the rest of the parameters. Like this:

&lt;syntaxhighlight lang="lua"&gt;
p = {}
local categoryHandler = require( 'Module:Category handler' ).main

function p.main( frame )
    local result = 'This is a module used in all namespaces.'
    local category = categoryHandler{
        all = '[[Category:Somecat1]]', -- Categorize in all namespaces
        main = '[[Category:Somecat2]]', -- And add this in main space
        other = '[[Category:Somecat3]]', -- And add this in all other namespaces
        nocat = frame.args.nocat -- So "nocat=true/false" works
    }
    category = category or '' -- Check that we don't have a nil value for the category variable.
    return result .. category
end

return p
&lt;/syntaxhighlight&gt;

If the above module is placed on an article, then it will add the categories "Somecat1" and "Somecat2". But on all other types of pages it will instead add "Somecat1" and "Somecat3". As the example shows, the all parameter works independently of the rest of the parameters.

=== Subpages ===

The category handler module understands the '''subpage''' parameter. Like this:

&lt;syntaxhighlight lang="lua"&gt;
p = {}
local categoryHandler = require( 'Module:Category handler' ).main

function p.main( frame )
    local result = 'This is a module used in all namespaces.'
    local category = categoryHandler{
        subpage = 'no' -- Don't categorize on subpages
        wikipedia = '[[Category:Somecat]]',
        nocat = frame.args.nocat -- So "nocat=true/false" works
    }
    category = category or '' -- Check that we don't have a nil value for the category variable.
    return result .. category
end

return p
&lt;/syntaxhighlight&gt;

If "&lt;code&gt;subpage='no'&lt;/code&gt;" then this template will ''not'' categorize on subpages. For the rare occasion you ''only'' want to categorize on subpages, then use "&lt;code&gt;subpage='only'&lt;/code&gt;". If '''subpage''' is empty or undefined then this template categorizes both on basepages and on subpages.

=== Blacklist ===

This module has a blacklist of the pages and page types where templates should not auto-categorize. Thus modules that use this meta-template will for instance not categorize on /archive pages and on the subpages of [[Wikipedia:Template messages]].

If you want a template to categorize on a blacklisted page, then feed "&lt;code&gt;&lt;nowiki&gt;nocat = false&lt;/nowiki&gt;&lt;/code&gt;" to the module when you place it on the page, thus skipping the blacklist check. Note that this module only categorizes if it has data for the namespace. For instance, if the basic syntax is used (see [[#Basic usage|basic usage]] above), then even if you set "&lt;code&gt;nocat = false&lt;/code&gt;" the template will not categorize on a talk page, since it has no data for talk pages. But it has data for help space, so on a blacklisted help page it will categorize.

The blacklist is located in the configuration table &lt;code&gt;cfg.blacklist&lt;/code&gt; near the top of the module code.

=== The "nocat" parameter ===

This module understands the '''nocat''' parameter:

* If "&lt;code&gt;nocat = true&lt;/code&gt;" then this template does ''not'' categorize.
* If '''nocat''' is &lt;code&gt;nil&lt;/code&gt; then this template categorizes as usual.
* If "&lt;code&gt;nocat = false&lt;/code&gt;" this template categorizes even when on blacklisted pages. (See section [[#Blacklist|blacklist]] above.)
* The nocat parameter also accepts aliases for &lt;code&gt;true&lt;/code&gt; and &lt;code&gt;false&lt;/code&gt; as defined by [[Module:Yesno]], e.g. "yes", "y", "true", and 1 for &lt;code&gt;true&lt;/code&gt;, and "no", "n", "false", and 0 for &lt;code&gt;false&lt;/code&gt;.

Modules and templates that use {{tlf|category handler}} should forward '''nocat''', so they too understand '''nocat'''. The code "&lt;code&gt;nocat = frame.args.nocat&lt;/code&gt;" shown in the examples on this page does that.

=== The "categories" parameter ===

For backwards compatibility this module also understands the '''categories''' parameter. It works the same as '''nocat'''. Like this:

* If "&lt;code&gt;categories = false&lt;/code&gt;" then this template does ''not'' categorize.
* If '''categories''' is empty or undefined then this template categorizes as usual.
* If "&lt;code&gt;categories = true&lt;/code&gt;" this template categorizes even when on blacklisted pages.
* The categories parameter also accepts aliases for &lt;code&gt;true&lt;/code&gt; and &lt;code&gt;false&lt;/code&gt; as defined by [[Module:Yesno]], e.g. "yes", "y", "true", and 1 for &lt;code&gt;true&lt;/code&gt;, and "no", "n", "false", and 0 for &lt;code&gt;false&lt;/code&gt;.

=== The "category2" parameter ===

For backwards compatibility this template kind of supports the old "category =" parameter. But the parameter name "category" is already used in this module to feed category data for when in category space. So instead this template uses '''category2''' for the usage similar to '''nocat'''. Like this:

* If "&lt;code&gt;category2 = "&lt;/code&gt;" (empty but defined), or "&lt;code&gt;category2 = 'no'&lt;/code&gt;", or if '''category2''' is fed any other data (except as described in the next two points), then this template does ''not'' categorize.
* If '''category2''' is undefined or if "&lt;code&gt;category2 = '¬'&lt;/code&gt;", then this template categorizes as usual.
* If "&lt;code&gt;category2 = 'yes'&lt;/code&gt;" this template categorizes even when on blacklisted pages.

=== Categories and text ===

Besides from categories, you can feed anything else to this module, for instance some text. Like this:

&lt;syntaxhighlight lang="lua"&gt;
p = {}
local categoryHandler = require( 'Module:Category handler' ).main

function p.main( frame )
    local result = 'This is a module used on talk pages.'
    local category = categoryHandler{
        talk = '[[Category:Somecat]]',
        other = '&lt;p class="error"&gt;This module should only be used on talk pages.&lt;/p&gt;',
        nocat = frame.args.nocat -- So "nocat=true/false" works
    }
    category = category or '' -- Check that we don't have a nil value for the category variable.
    return result .. category
end

return p
&lt;/syntaxhighlight&gt;

When the module code above is used on anything other than a talk page, it will look like this:

:This is a module used on talk pages.{{#invoke:category handler|main
| talk = [[Category:Somecat]]
| other = &lt;p class="error"&gt;This module should only be used on talk pages.&lt;/p&gt;
| nocat = {{{nocat|}}} &lt;!--So "nocat=true/false" works--&gt;
}}

That text will not show on blacklisted pages, so don't use this method to show any important information. Feeding "&lt;code&gt;nocat = 'true'&lt;/code&gt;" to the template hides the text, just as it suppresses any categories.

=== The "page" parameter ===

For testing and demonstration purposes this module can take a parameter named '''page'''. Like this:

&lt;syntaxhighlight lang="lua"&gt;
p = {}
local categoryHandler = require( 'Module:Category handler' ).main

function p.main( frame )
    local category = categoryHandler{
        main = 'Category:Some cat',
        talk = 'Category:Talk cat',
        nocat = frame.args.nocat, -- So "nocat=true/false" works
        page = 'User talk:Example'
    }
    return category
end

return p
&lt;/syntaxhighlight&gt;

In the above code we on purpose left out the brackets around the category names so we see the output on the page. No matter on what kind of page the code above is used it will return this:

:{{#invoke:category handler|main
| main = Category:Some cat
| talk = Category:Talk cat
| nocat = {{{nocat|}}}   &lt;!--So "nocat=true/false" works--&gt;
| page = User talk:Example
}}

The '''page''' parameter makes this module behave exactly as if on that page. Even the blacklist works. The pagename doesn't have to be an existing page.

If the '''page''' parameter is empty or undefined, the name of the current page determines the result.

You can make it so your module also understands the '''page''' parameter. That means you can test how your template will categorize on different pages, without having to actually edit those pages. Then do like this:

&lt;syntaxhighlight lang="lua"&gt;
p = {}
local categoryHandler = require( 'Module:Category handler' ).main

function p.main( frame )
    local category = categoryHandler{
        main = 'Category:Some cat',
        talk = 'Category:Talk cat',
        nocat = frame.args.nocat, -- So "nocat=true/false" works
        page = frame.args.page -- For testing
    }
    return category
end

return p
&lt;/syntaxhighlight&gt;

=== Parameters ===

List of all parameters:

* First positional parameter - for default settings
* subpage = 'no' / 'only'
* 1, 2, 3 ...
* all = '&lt;nowiki&gt;[[Category:Somecat]]&lt;/nowiki&gt;' / 'Text'
* main = 1, 2, 3 ... / '&lt;nowiki&gt;[[Category:Somecat]]&lt;/nowiki&gt;' / 'Text'
* ...
* other = 1, 2, 3 ... / '&lt;nowiki&gt;[[Category:Somecat]]&lt;/nowiki&gt;' / 'Text'
* nocat = frame.args.nocat / true / false / 'yes' / 'no' / 'y' / 'n' / 'true' / 'false' / 1 / 0
* categories = frame.args.categories / false / true / 'no' / 'yes' / 'n' / 'y' / 'false' / 'true' / 0 / 1
* category2 = frame.args.category or '¬' / 'no' / 'not defined' / '¬' / 'yes'
* page  = frame.args.page / 'User:Example'

Note that empty values to the "main" ... "other" parameters have special meaning (see examples above). The "all" parameter doesn't understand numbered parameters, since there should never be a need for that.

== Exporting to other wikis ==

This module can be exported to other wikis by changing the configuration values in the &lt;code&gt;cfg&lt;/code&gt; table. All the variable values are configurable, so after the configuration values have been set there should be no need to alter the main module code. Details of each configuration value are included in the module code comments. In addition, this module requires [[Module:Namespace detect]] to be available on the local wiki.

== See also ==

* {{tl|Category handler}} – for using this module with templates, rather than Lua modules.
* [[Wikipedia:Category suppression]] – The how-to guide.
* [[Wikipedia:WikiProject Category Suppression]] – The WikiProject.
* [[Wikipedia:Namespace]] – Lists all the namespaces.</text>
      <sha1>gkkejpxqs4okdrj4sjelcpufg10t90l</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Category handler/shared</title>
    <ns>828</ns>
    <id>43232937</id>
    <revision>
      <id>948472498</id>
      <parentid>894414384</parentid>
      <timestamp>2020-04-01T06:12:41Z</timestamp>
      <contributor>
        <username>MusikAnimal</username>
        <id>14882394</id>
      </contributor>
      <minor/>
      <comment>1 revision imported</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="888" xml:space="preserve">-- This module contains shared functions used by [[Module:Category handler]]
-- and its submodules.

local p = {}

function p.matchesBlacklist(page, blacklist)
    for i, pattern in ipairs(blacklist) do
        local match = mw.ustring.match(page, pattern)
        if match then
            return true
        end
    end
    return false
end

function p.getParamMappings(useLoadData)
    local dataPage = 'Module:Namespace detect/data'
    if useLoadData then
        return mw.loadData(dataPage).mappings
    else
        return require(dataPage).mappings
    end
end

function p.getNamespaceParameters(titleObj, mappings)
    -- We don't use title.nsText for the namespace name because it adds
    -- underscores.
    local mappingsKey
    if titleObj.isTalkPage then
        mappingsKey = 'talk'
    else
        mappingsKey = mw.site.namespaces[titleObj.namespace].name
    end
    mappingsKey = mw.ustring.lower(mappingsKey)
    return mappings[mappingsKey] or {}
end

return p</text>
      <sha1>omlsnhudxz6juptvtxz7ns97jutbzc5</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Namespace detect</title>
    <ns>828</ns>
    <id>39762919</id>
    <revision>
      <id>602886406</id>
      <parentid>601020017</parentid>
      <timestamp>2014-04-05T17:01:23Z</timestamp>
      <contributor>
        <username>Mr. Stradivarius</username>
        <id>4708675</id>
      </contributor>
      <comment>use demopage instead of page as the main "page" parameter</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="5992" xml:space="preserve">--[[
--------------------------------------------------------------------------------
--                                                                            --
--                            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| &lt;code&gt;' .. param .. '&lt;/code&gt;'
                    .. '\n| '
            elseif j == 2 then
                ret = ret .. '&lt;code&gt;' .. param .. '&lt;/code&gt;'
            else
                ret = ret .. ', &lt;code&gt;' .. param .. '&lt;/code&gt;'
            end
        end
    end
    ret = ret .. '\n|-'
        .. '\n|}'
    return ret
end

return p</text>
      <sha1>j7kygz1y56jpz4doq0m2c6x1td5d8ar</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Namespace detect/config</title>
    <ns>828</ns>
    <id>42256703</id>
    <revision>
      <id>948472518</id>
      <parentid>948472515</parentid>
      <timestamp>2020-04-01T06:12:44Z</timestamp>
      <contributor>
        <username>MusikAnimal</username>
        <id>14882394</id>
      </contributor>
      <minor/>
      <comment>1 revision imported</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="3545" xml:space="preserve">--------------------------------------------------------------------------------
--                    Namespace detect configuration data                     --
--                                                                            --
-- This module stores configuration data for Module:Namespace detect. Here    --
-- you can localise the module to your wiki's language.                       --
--                                                                            --
-- To activate a configuration item, you need to uncomment it. This means     --
-- that you need to remove the text "-- " at the start of the line.           --
--------------------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

return cfg -- Don't edit this line.</text>
      <sha1>1o6ozz56i8q0xgyl6xa41n2v7kelhli</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Namespace detect/data</title>
    <ns>828</ns>
    <id>42257476</id>
    <revision>
      <id>948472520</id>
      <parentid>948472519</parentid>
      <timestamp>2020-04-01T06:12:45Z</timestamp>
      <contributor>
        <username>MusikAnimal</username>
        <id>14882394</id>
      </contributor>
      <minor/>
      <comment>1 revision imported</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="2569" xml:space="preserve">--------------------------------------------------------------------------------
--                          Namespace detect data                             --
-- This module holds data for [[Module:Namespace detect]] to be loaded per    --
-- page, rather than per #invoke, for performance reasons.                    --
--------------------------------------------------------------------------------

local cfg = require('Module:Namespace detect/config')

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

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

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

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

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

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

return {
    argKeys = argKeys,
    cfg = cfg,
    mappings = getParamMappings()
}</text>
      <sha1>ojp6d3pc8mql5nufaqdg576c9so3479</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Template link general</title>
    <ns>828</ns>
    <id>63673341</id>
    <revision>
      <id>1068594348</id>
      <parentid>1068517629</parentid>
      <timestamp>2022-01-29T09:02:36Z</timestamp>
      <contributor>
        <username>Primefac</username>
        <id>11508456</id>
      </contributor>
      <comment>bit flip per previous</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="3940" xml:space="preserve">-- This implements Template:Tlg
local getArgs = require('Module:Arguments').getArgs
local p = {}

-- Is a string non-empty?
local function _ne(s)
    return s ~= nil and s ~= ""
end

local nw = mw.text.nowiki

local function addTemplate(s)
    local i, _ = s:find(':', 1, true)
    if i == nil then
        return 'Template:' .. s
    end
    local ns = s:sub(1, i - 1)
    if ns == '' or mw.site.namespaces[ns] then
        return s
    else
        return 'Template:' .. s
    end
end

local function trimTemplate(s)
    local needle = 'template:'
    if s:sub(1, needle:len()):lower() == needle then
        return s:sub(needle:len() + 1)
    else
        return s
    end
end

local function linkTitle(args)
    if _ne(args.nolink) then
        return args['1']
    end

    local titleObj
    local titlePart = '[['
    if args['1'] then
        -- This handles :Page and other NS
        titleObj = mw.title.new(args['1'], 'Template')
    else
        titleObj = mw.title.getCurrentTitle()
    end

    titlePart = titlePart .. (titleObj ~= nil and titleObj.fullText or
                addTemplate(args['1']))

    local textPart = args.alttext
    if not _ne(textPart) then
        if titleObj ~= nil then
            textPart = titleObj:inNamespace("Template") and args['1'] or titleObj.fullText
        else
            -- redlink
            textPart = args['1']
        end
    end

    if _ne(args.subst) then
        -- HACK: the ns thing above is probably broken
        textPart = 'subst:' .. textPart
    end

    if _ne(args.brace) then
        textPart = nw('{{') .. textPart .. nw('}}')
    elseif _ne(args.braceinside) then
        textPart = nw('{') .. textPart .. nw('}')
    end

    titlePart = titlePart .. '|' .. textPart .. ']]'
    if _ne(args.braceinside) then
        titlePart = nw('{') .. titlePart .. nw('}')
    end
    return titlePart
end

function p.main(frame)
    local args = getArgs(frame, {
        trim = true,
        removeBlanks = false
    })
    return p._main(args)
end

function p._main(args)
    local bold = _ne(args.bold) or _ne(args.boldlink) or _ne(args.boldname)
    local italic = _ne(args.italic) or _ne(args.italics)
    local dontBrace = _ne(args.brace) or _ne(args.braceinside)
    local code = _ne(args.code) or _ne(args.tt)
    local show_result = _ne(args._show_result)

    -- Build the link part
    local titlePart = linkTitle(args)
    if bold then titlePart = "'''" .. titlePart .. "'''" end
    if _ne(args.nowrapname) then titlePart = '&lt;span class="nowrap"&gt;' .. titlePart .. '&lt;/span&gt;' end

    -- Build the arguments
    local textPart = ""
    local textPartBuffer = ""
    local codeArguments = {}
    local i = 2
    while args[i] do
        local val = args[i]
        textPartBuffer = textPartBuffer .. '&amp;#124;'
        if val ~= "" then
            if _ne(args.nowiki) then
                -- Unstrip nowiki tags first because calling nw on something that already contains nowiki tags will
                -- mangle the nowiki strip marker and result in literal UNIQ...QINU showing up
                val = nw(mw.text.unstripNoWiki(val))
            end
            local k, v = string.match(val, "(.*)=(.*)")
            if not k then
                codeArguments[i - 1] = val
            else
                codeArguments[k] = v
            end
            if italic then val = '&lt;span style="font-style:italic;"&gt;' .. val .. '&lt;/span&gt;' end
            textPart = textPart .. textPartBuffer .. val
            textPartBuffer = ""
        end
        i = i+1
    end

    -- final wrap
    local ret = titlePart .. textPart
    if not dontBrace then ret = nw('{{') .. ret .. nw('}}') end
    if _ne(args.a) then ret = nw('*') .. '&amp;nbsp;' .. ret end
    if _ne(args.kbd) then ret = '&lt;kbd&gt;' .. ret .. '&lt;/kbd&gt;' end
    if code then
        ret = '&lt;code&gt;' .. ret .. '&lt;/code&gt;'
    elseif _ne(args.plaincode) then
        ret = '&lt;code style="border:none;background:transparent;"&gt;' .. ret .. '&lt;/code&gt;'
    end
    if _ne(args.nowrap) then ret = '&lt;span class="nowrap"&gt;' .. ret .. '&lt;/span&gt;' end

    --[[ Wrap as html??
    local span = mw.html.create('span')
    span:wikitext(ret)
    --]]
    if _ne(args.debug) then ret = ret .. '\n&lt;pre&gt;' .. mw.text.encode(mw.dumpObject(args)) .. '&lt;/pre&gt;' end

    if show_result then
        local result = mw.getCurrentFrame():expandTemplate{title = "Template:" .. args[1], args = codeArguments}
        ret = ret .. " → " .. result
    end
    return ret
end

return p</text>
      <sha1>04bt81vpnxlycj9xx6ol27d6jgthsoy</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Transclusion count/data/C</title>
    <ns>828</ns>
    <id>61481071</id>
    <revision>
      <id>1071544600</id>
      <parentid>1070187690</parentid>
      <timestamp>2022-02-13T05:12:55Z</timestamp>
      <contributor>
        <username>Ahechtbot</username>
        <id>26109785</id>
      </contributor>
      <minor/>
      <comment>[[Wikipedia:BOT|Bot]]: Updated page.</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="34820" xml:space="preserve">return {
["C"] = 580000,
["C-Class"] = 71000,
["C-SPAN"] = 12000,
["C-cmn"] = 2500,
["C-pl"] = 52000,
["CAN"] = 20000,
["CANelec"] = 12000,
["CANelec/gain"] = 2400,
["CANelec/hold"] = 4300,
["CANelec/source"] = 6300,
["CANelec/top"] = 5500,
["CANelec/total"] = 5500,
["CAS"] = 3800,
["CBB_Standings_End"] = 13000,
["CBB_Standings_Entry"] = 13000,
["CBB_Standings_Start"] = 13000,
["CBB_Yearly_Record_End"] = 2800,
["CBB_Yearly_Record_Entry"] = 2800,
["CBB_Yearly_Record_Start"] = 2700,
["CBB_Yearly_Record_Subhead"] = 3300,
["CBB_Yearly_Record_Subtotal"] = 2600,
["CBB_roster/Footer"] = 6600,
["CBB_roster/Header"] = 6600,
["CBB_roster/Player"] = 6600,
["CBB_schedule_end"] = 9200,
["CBB_schedule_entry"] = 9300,
["CBB_schedule_start"] = 9300,
["CBB_yearly_record_end"] = 3700,
["CBB_yearly_record_end/legend"] = 3300,
["CBB_yearly_record_entry"] = 3700,
["CBB_yearly_record_start"] = 3600,
["CBB_yearly_record_subhead"] = 3400,
["CBB_yearly_record_subtotal"] = 3500,
["CBSB_Standings_End"] = 3800,
["CBSB_Standings_Entry"] = 3800,
["CBSB_Standings_Start"] = 3800,
["CBSB_link"] = 3200,
["CC0"] = 4700,
["CENTURY"] = 16000,
["CFB_Standings_End"] = 31000,
["CFB_Standings_Entry"] = 31000,
["CFB_Standings_Start"] = 31000,
["CFB_Yearly_Record_End"] = 6300,
["CFB_Yearly_Record_End/legend"] = 2200,
["CFB_Yearly_Record_Entry"] = 6300,
["CFB_Yearly_Record_Start"] = 6300,
["CFB_Yearly_Record_Subhead"] = 6300,
["CFB_Yearly_Record_Subtotal"] = 6200,
["CFB_schedule"] = 24000,
["CFB_schedule_entry"] = 17000,
["CFL_Year"] = 5300,
["CGF_year"] = 2300,
["CHE"] = 10000,
["CHI"] = 2700,
["CHL"] = 3500,
["CHN"] = 11000,
["CN"] = 2200,
["COI"] = 14000,
["COIUL"] = 123000,
["COI_editnotice"] = 6100,
["COL"] = 4600,
["COLON"] = 13000,
["CRI"] = 2100,
["CRO"] = 4000,
["CSK"] = 2800,
["CSS_image_crop"] = 3600,
["CUB"] = 3400,
["CURRENTDATE"] = 3600,
["CURRENTISOYEAR"] = 2000,
["CURRENTMINUTE"] = 2500,
["CZE"] = 13000,
["Calendar"] = 2400,
["California/color"] = 11000,
["Call_sign_disambiguation"] = 2900,
["Campaignbox"] = 21000,
["CanadaByProvinceCatNav"] = 9600,
["CanadaProvinceThe"] = 3900,
["Canadian_English"] = 4800,
["Canadian_Parliament_links"] = 4900,
["Canadian_election_result"] = 12000,
["Canadian_election_result/gain"] = 2400,
["Canadian_election_result/hold"] = 4400,
["Canadian_election_result/source"] = 7300,
["Canadian_election_result/top"] = 11000,
["Canadian_election_result/top/ElectionYearTest"] = 5100,
["Canadian_election_result/total"] = 9400,
["Canadian_party_colour"] = 7500,
["Canadian_party_colour/colour"] = 15000,
["Canadian_party_colour/colour/default"] = 15000,
["Canadian_party_colour/name"] = 13000,
["Canadian_party_colour/name/default"] = 5800,
["Canned_search"] = 3500,
["Cascite"] = 14000,
["Caselaw_source"] = 3800,
["Cast_listing"] = 9600,
["Cat"] = 275000,
["CatAutoTOC"] = 615000,
["CatAutoTOC/core"] = 614000,
["CatRel"] = 3800,
["CatTrack"] = 3000,
["Cat_class"] = 6700,
["Cat_in_use"] = 50000,
["Cat_main"] = 171000,
["Cat_more"] = 108000,
["Cat_more_if_exists"] = 44000,
["Cat_see_also"] = 3300,
["Catalog_lookup_link"] = 483000,
["Category"] = 182000,
["Category-Class"] = 14000,
["Category-inline"] = 7600,
["Category_TOC"] = 70000,
["Category_TOC/tracking"] = 70000,
["Category_U.S._State_elections_by_year"] = 7200,
["Category_U.S._State_elections_by_year/core"] = 7200,
["Category_class"] = 36000,
["Category_class/column"] = 36000,
["Category_class/second_row_column"] = 36000,
["Category_described_in_year"] = 5600,
["Category_diffuse"] = 7500,
["Category_disambiguation"] = 2300,
["Category_disambiguation/category_link"] = 2300,
["Category_explanation"] = 73000,
["Category_handler"] = 3150000,
["Category_ifexist"] = 4700,
["Category_importance"] = 11000,
["Category_importance/column"] = 11000,
["Category_importance/second_row_column"] = 11000,
["Category_link"] = 289000,
["Category_link_with_count"] = 5700,
["Category_ordered_by_date"] = 9300,
["Category_other"] = 836000,
["Category_redirect"] = 102000,
["Category_see_also"] = 33000,
["Category_see_also/Category_pair_check"] = 33000,
["Category_see_also_if_exists"] = 71000,
["Category_see_also_if_exists_2"] = 83000,
["Category_title"] = 2400,
["Catexp"] = 7100,
["CathEncy"] = 2300,
["Catholic"] = 4200,
["Catholic_Encyclopedia"] = 5000,
["Catmain"] = 24000,
["Catmore"] = 9300,
["Caution"] = 2100,
["Cbb_link"] = 7100,
["Cbignore"] = 91000,
["Cc-by-2.5"] = 4500,
["Cc-by-3.0"] = 10000,
["Cc-by-sa-2.5"] = 3200,
["Cc-by-sa-2.5,2.0,1.0"] = 3300,
["Cc-by-sa-3.0"] = 31000,
["Cc-by-sa-3.0,2.5,2.0,1.0"] = 2900,
["Cc-by-sa-3.0-migrated"] = 30000,
["Cc-by-sa-4.0"] = 12000,
["Cc-zero"] = 4600,
["CensusAU"] = 11000,
["Census_2016_AUS"] = 8700,
["Cent"] = 5200,
["Center"] = 224000,
["Centralized_discussion"] = 5500,
["Centralized_discussion/core"] = 5500,
["Centralized_discussion/styles.css"] = 5500,
["Centre"] = 2500,
["Century"] = 2000,
["Century_name_from_decade_or_year"] = 71000,
["Century_name_from_title_decade"] = 7200,
["Century_name_from_title_year"] = 6700,
["Certification_Cite/Title"] = 24000,
["Certification_Cite/URL"] = 27000,
["Certification_Cite/archivedate"] = 4900,
["Certification_Cite/archiveurl"] = 4900,
["Certification_Cite_Ref"] = 24000,
["Certification_Table_Bottom"] = 24000,
["Certification_Table_Entry"] = 25000,
["Certification_Table_Entry/Foot"] = 23000,
["Certification_Table_Entry/Foot/helper"] = 23000,
["Certification_Table_Entry/Region"] = 24000,
["Certification_Table_Entry/Sales"] = 23000,
["Certification_Table_Entry/Sales/DanishPeriod"] = 2600,
["Certification_Table_Entry/Sales/DanishPeriodHelper1"] = 2600,
["Certification_Table_Entry/Sales/DanishPeriodHelper2"] = 2600,
["Certification_Table_Entry/Sales/GermanPeriod"] = 3100,
["Certification_Table_Entry/Sales/ItalianHelper"] = 2800,
["Certification_Table_Top"] = 25000,
["Cfb_link"] = 23000,
["Cfd_result"] = 2400,
["Cfdend"] = 4000,
["Chart"] = 4500,
["Chart/end"] = 4600,
["Chart/start"] = 4600,
["Chart_bottom"] = 2800,
["Chart_top"] = 2800,
["Check_completeness_of_transclusions"] = 5900,
["Check_talk"] = 25000,
["Check_talk_wp"] = 1360000,
["Check_winner_by_scores"] = 12000,
["CheckedSockpuppet"] = 7100,
["Checked_sockpuppet"] = 17000,
["Checkedsockpuppet"] = 5300,
["Checkip"] = 12000,
["Checkuser"] = 68000,
["Checkuserblock-account"] = 8300,
["Chem"] = 4700,
["Chem/atom"] = 4500,
["Chem/link"] = 4700,
["Chem_molar_mass"] = 16000,
["Chem_molar_mass/format"] = 16000,
["Chembox"] = 13000,
["Chembox/styles.css"] = 13000,
["Chembox_3DMet"] = 13000,
["Chembox_3DMet/format"] = 13000,
["Chembox_AllOtherNames"] = 12000,
["Chembox_AllOtherNames/format"] = 12000,
["Chembox_Appearance"] = 5500,
["Chembox_BoilingPt"] = 3600,
["Chembox_CASNo"] = 13000,
["Chembox_CASNo/format"] = 13000,
["Chembox_CalcTemperatures"] = 6300,
["Chembox_ChEBI"] = 13000,
["Chembox_ChEBI/format"] = 13000,
["Chembox_ChEMBL"] = 13000,
["Chembox_ChEMBL/format"] = 13000,
["Chembox_ChemSpiderID"] = 13000,
["Chembox_ChemSpiderID/format"] = 13000,
["Chembox_CompTox"] = 13000,
["Chembox_CompTox/format"] = 13000,
["Chembox_Datapage_check"] = 13000,
["Chembox_Density"] = 4600,
["Chembox_DrugBank"] = 13000,
["Chembox_DrugBank/format"] = 13000,
["Chembox_ECHA"] = 7200,
["Chembox_ECNumber"] = 13000,
["Chembox_ECNumber/format"] = 13000,
["Chembox_Elements"] = 13000,
["Chembox_Elements/molecular_formula"] = 16000,
["Chembox_Footer"] = 13000,
["Chembox_Footer/tracking"] = 13000,
["Chembox_GHS_(set)"] = 3200,
["Chembox_Hazards"] = 11000,
["Chembox_IUPHAR_ligand"] = 13000,
["Chembox_IUPHAR_ligand/format"] = 13000,
["Chembox_Identifiers"] = 13000,
["Chembox_InChI"] = 12000,
["Chembox_InChI/format"] = 12000,
["Chembox_Indexlist"] = 13000,
["Chembox_Jmol"] = 13000,
["Chembox_Jmol/format"] = 13000,
["Chembox_KEGG"] = 13000,
["Chembox_KEGG/format"] = 13000,
["Chembox_MeltingPt"] = 5400,
["Chembox_Properties"] = 13000,
["Chembox_PubChem"] = 13000,
["Chembox_PubChem/format"] = 13000,
["Chembox_RTECS"] = 13000,
["Chembox_RTECS/format"] = 13000,
["Chembox_Related"] = 2900,
["Chembox_SMILES"] = 12000,
["Chembox_SMILES/format"] = 12000,
["Chembox_SolubilityInWater"] = 3600,
["Chembox_UNII"] = 13000,
["Chembox_UNII/format"] = 13000,
["Chembox_headerbar"] = 13000,
["Chembox_image"] = 12000,
["Chembox_image_cell"] = 11000,
["Chembox_image_sbs"] = 12000,
["Chembox_parametercheck"] = 12000,
["Chembox_setDatarow"] = 4200,
["Chembox_setHeader"] = 4200,
["Chembox_templatePar/formatPreviewMessage"] = 13000,
["Chembox_verification"] = 7200,
["Chemicals"] = 7500,
["Chemistry"] = 2900,
["Chemspidercite"] = 11000,
["Chessgames_player"] = 3400,
["Chinese"] = 7600,
["Chr"] = 8900,
["ChristianityWikiProject"] = 6100,
["Circa"] = 46000,
["Circular_reference"] = 4600,
["Citation"] = 343000,
["Citation/make_link"] = 5200,
["Citation/styles.css"] = 44000,
["Citation_needed"] = 489000,
["Citation_needed_span"] = 3100,
["Citation_style"] = 4300,
["Cite_AV_media"] = 37000,
["Cite_AV_media_notes"] = 23000,
["Cite_Appletons'"] = 2400,
["Cite_Australian_Dictionary_of_Biography"] = 2900,
["Cite_Catholic_Encyclopedia"] = 8000,
["Cite_Colledge2006"] = 3100,
["Cite_DCB"] = 2800,
["Cite_DNB"] = 17000,
["Cite_EB1911"] = 23000,
["Cite_GNIS"] = 2500,
["Cite_Gaia_DR2"] = 2400,
["Cite_Jewish_Encyclopedia"] = 2700,
["Cite_NIE"] = 3600,
["Cite_NSW_Parliament"] = 3300,
["Cite_NSW_SHR"] = 2600,
["Cite_ODNB"] = 14000,
["Cite_Q"] = 52000,
["Cite_QHR"] = 3000,
["Cite_QPN"] = 3900,
["Cite_Rowlett"] = 2500,
["Cite_Russian_law"] = 7600,
["Cite_Sports-Reference"] = 53000,
["Cite_WoRMS"] = 4500,
["Cite_arXiv"] = 4100,
["Cite_bcgnis"] = 2900,
["Cite_book"] = 1420000,
["Cite_certification"] = 27000,
["Cite_cgndb"] = 2700,
["Cite_conference"] = 13000,
["Cite_court"] = 4800,
["Cite_dictionary"] = 4600,
["Cite_document"] = 9000,
["Cite_encyclopedia"] = 184000,
["Cite_episode"] = 16000,
["Cite_gnis"] = 34000,
["Cite_interview"] = 6300,
["Cite_iucn"] = 53000,
["Cite_journal"] = 848000,
["Cite_magazine"] = 167000,
["Cite_map"] = 31000,
["Cite_news"] = 1320000,
["Cite_newspaper"] = 3600,
["Cite_newspaper_The_Times"] = 6000,
["Cite_patent"] = 4600,
["Cite_patent/authors"] = 3400,
["Cite_patent/core"] = 5000,
["Cite_peakbagger"] = 3900,
["Cite_podcast"] = 2800,
["Cite_press_release"] = 53000,
["Cite_report"] = 27000,
["Cite_rowlett"] = 2500,
["Cite_simbad"] = 4100,
["Cite_sports-reference"] = 58000,
["Cite_thesis"] = 22000,
["Cite_tweet"] = 26000,
["Cite_video"] = 12000,
["Cite_video_game"] = 2900,
["Cite_web"] = 4170000,
["Cite_wikisource"] = 4900,
["Cite_wikisource/make_link"] = 54000,
["Civil_navigation"] = 2700,
["Cl"] = 107000,
["Clade"] = 6000,
["Clade/styles.css"] = 6000,
["Clarify"] = 38000,
["Class"] = 9410000,
["Class/colour"] = 9470000,
["Class/icon"] = 9420000,
["Class_mask"] = 9650000,
["Class_mask/b"] = 322000,
["Classical"] = 7100,
["Classicon"] = 4600,
["Clc"] = 4800,
["Cleanup"] = 12000,
["Cleanup_bare_URLs"] = 4700,
["Cleanup_reorganize"] = 2600,
["Cleanup_rewrite"] = 5400,
["Clear"] = 3460000,
["Clear-left"] = 19000,
["Clear_left"] = 32000,
["Clear_right"] = 2700,
["Clerk-Note"] = 9000,
["Clerknote"] = 6700,
["Clickable_button"] = 12000,
["Clickable_button_2"] = 837000,
["Clr"] = 3600,
["Cmbox"] = 389000,
["Cn"] = 76000,
["Cnote2_Begin"] = 2000,
["Cnote2_End"] = 2000,
["Coat_of_arms"] = 7800,
["Cob"] = 11000,
["Code"] = 44000,
["Col-1-of-2"] = 2500,
["Col-2"] = 162000,
["Col-2-of-2"] = 2400,
["Col-3"] = 9900,
["Col-4"] = 3500,
["Col-begin"] = 206000,
["Col-break"] = 204000,
["Col-end"] = 205000,
["Col-float"] = 2300,
["Col-float-break"] = 2200,
["Col-float-end"] = 2300,
["Col-float/styles.css"] = 2300,
["Col-start"] = 21000,
["Colbegin"] = 39000,
["Colend"] = 50000,
["Collapse"] = 11000,
["Collapse_bottom"] = 47000,
["Collapse_top"] = 48000,
["Collapsebottom"] = 3800,
["Collapsetop"] = 3800,
["Collapsible_list"] = 48000,
["Collapsible_option"] = 128000,
["College"] = 7600,
["CollegePrimaryHeader"] = 4700,
["CollegePrimaryStyle"] = 88000,
["CollegeSecondaryStyle"] = 2400,
["College_Athlete_Recruit_End"] = 2600,
["College_Athlete_Recruit_Entry"] = 2700,
["College_Athlete_Recruit_Start"] = 2600,
["College_athlete_recruit_end"] = 3600,
["College_athlete_recruit_entry"] = 3800,
["College_athlete_recruit_start"] = 3800,
["College_color_list"] = 3600,
["Colon"] = 17000,
["Color"] = 366000,
["Color_box"] = 68000,
["Colorbox"] = 3200,
["Colorbull"] = 5200,
["Colored_link"] = 31000,
["Colors"] = 3000,
["Colour"] = 10000,
["Coloured_link"] = 4800,
["Column"] = 2000,
["Column/styles.css"] = 2100,
["Columns-list"] = 86000,
["Comedy"] = 2700,
["Comic_Book_DB"] = 3700,
["Comicbookdb"] = 3600,
["Comics-replaceability"] = 2900,
["Comics_infobox_sec"] = 12000,
["Comics_infobox_sec/creator_nat"] = 3000,
["Comics_infobox_sec/formcat"] = 3100,
["Comics_infobox_sec/genre"] = 3800,
["Comics_infobox_sec/genrecat"] = 3500,
["Comicsproj"] = 29000,
["Comicsyrimage"] = 2000,
["Comma_separated_entries"] = 327000,
["Comment"] = 4500,
["Committed_identity"] = 2800,
["Committed_identity/styles.css"] = 2800,
["Commons"] = 64000,
["Commons-inline"] = 15000,
["Commons_cat"] = 48000,
["Commons_category"] = 811000,
["Commons_category-inline"] = 128000,
["Commons_category_inline"] = 6300,
["Commonscat"] = 68000,
["Commonscat-inline"] = 20000,
["Commonscat_inline"] = 2700,
["Commonscatinline"] = 7300,
["Compact_TOC"] = 6800,
["Compact_ToC"] = 5000,
["Compare"] = 8500,
["Compare_image_with_Wikidata"] = 8500,
["Composition_bar"] = 9100,
["Confirmed"] = 14000,
["Confused"] = 2600,
["Confusing"] = 2400,
["CongBio"] = 9800,
["CongLinks"] = 4400,
["Connected_contributor"] = 16000,
["Connected_contributor_(paid)"] = 6200,
["Constellation_navbox"] = 5800,
["Container"] = 9300,
["Container_cat"] = 7200,
["Container_category"] = 37000,
["Containercat"] = 2700,
["Contains_special_characters"] = 3600,
["Contains_special_characters/core"] = 3600,
["Content_category"] = 7300,
["Context"] = 3200,
["Continent2continental"] = 15000,
["Continent_adjective_to_noun"] = 2200,
["Controversial"] = 3100,
["Convert"] = 1110000,
["Convinfobox"] = 191000,
["Convinfobox/2"] = 13000,
["Convinfobox/3"] = 115000,
["Convinfobox/pri2"] = 57000,
["Convinfobox/prisec2"] = 2900,
["Convinfobox/prisec3"] = 23000,
["Convinfobox/sec2"] = 8000,
["Coord"] = 1280000,
["Coord_missing"] = 107000,
["Coord_missing/CheckCat"] = 106000,
["Coords"] = 7400,
["Copied"] = 17000,
["Copy_to_Wikimedia_Commons"] = 134000,
["Copyvios"] = 3600,
["Cospar"] = 3100,
["Cot"] = 10000,
["Count"] = 8100,
["Country2continent"] = 25000,
["Country2continental"] = 2400,
["Country2nationality"] = 73000,
["CountryPrefixThe"] = 101000,
["Country_abbreviation"] = 84000,
["Country_alias"] = 14000,
["Country_at_games_navbox"] = 2500,
["Country_at_games_navbox/below"] = 2500,
["Country_data"] = 5000,
["Country_data_ALB"] = 6200,
["Country_data_ALG"] = 8200,
["Country_data_AND"] = 2600,
["Country_data_ANG"] = 4200,
["Country_data_ARG"] = 44000,
["Country_data_ARM"] = 6300,
["Country_data_AUS"] = 70000,
["Country_data_AUT"] = 41000,
["Country_data_AZE"] = 7700,
["Country_data_Afghanistan"] = 11000,
["Country_data_Alaska"] = 2200,
["Country_data_Albania"] = 17000,
["Country_data_Alberta"] = 3400,
["Country_data_Algeria"] = 21000,
["Country_data_American_Samoa"] = 3100,
["Country_data_Andorra"] = 7400,
["Country_data_Angola"] = 11000,
["Country_data_Anguilla"] = 2700,
["Country_data_Antigua_and_Barbuda"] = 5800,
["Country_data_Apulia"] = 7900,
["Country_data_Argentina"] = 71000,
["Country_data_Arizona"] = 2200,
["Country_data_Arkansas"] = 2000,
["Country_data_Armenia"] = 19000,
["Country_data_Aruba"] = 3900,
["Country_data_Australia"] = 110000,
["Country_data_Austria"] = 66000,
["Country_data_Azerbaijan"] = 24000,
["Country_data_BAH"] = 3900,
["Country_data_BAN"] = 3500,
["Country_data_BAR"] = 2300,
["Country_data_BEL"] = 46000,
["Country_data_BER"] = 2100,
["Country_data_BHR"] = 3800,
["Country_data_BIH"] = 11000,
["Country_data_BLR"] = 23000,
["Country_data_BOL"] = 5800,
["Country_data_BOT"] = 2200,
["Country_data_BRA"] = 53000,
["Country_data_BUL"] = 23000,
["Country_data_Bahamas"] = 9500,
["Country_data_Bahrain"] = 9900,
["Country_data_Bangladesh"] = 16000,
["Country_data_Barbados"] = 7800,
["Country_data_Belarus"] = 37000,
["Country_data_Belgium"] = 76000,
["Country_data_Belize"] = 5200,
["Country_data_Benin"] = 6800,
["Country_data_Bermuda"] = 5600,
["Country_data_Bhutan"] = 4500,
["Country_data_Bolivia"] = 14000,
["Country_data_Bosnia_and_Herzegovina"] = 25000,
["Country_data_Botswana"] = 8800,
["Country_data_Brazil"] = 90000,
["Country_data_British_Columbia"] = 3100,
["Country_data_British_Raj"] = 2000,
["Country_data_British_Virgin_Islands"] = 3700,
["Country_data_Brunei"] = 5800,
["Country_data_Bulgaria"] = 45000,
["Country_data_Burkina_Faso"] = 9600,
["Country_data_Burma"] = 2700,
["Country_data_Burundi"] = 5300,
["Country_data_CAN"] = 55000,
["Country_data_CGO"] = 2100,
["Country_data_CHE"] = 4200,
["Country_data_CHI"] = 16000,
["Country_data_CHN"] = 38000,
["Country_data_CIV"] = 7100,
["Country_data_CMR"] = 7800,
["Country_data_COD"] = 2900,
["Country_data_COL"] = 23000,
["Country_data_CRC"] = 6400,
["Country_data_CRO"] = 30000,
["Country_data_CUB"] = 8800,
["Country_data_CYP"] = 8000,
["Country_data_CZE"] = 42000,
["Country_data_California"] = 6100,
["Country_data_Cambodia"] = 8400,
["Country_data_Cameroon"] = 16000,
["Country_data_Canada"] = 107000,
["Country_data_Cape_Verde"] = 5800,
["Country_data_Catalonia"] = 2900,
["Country_data_Cayman_Islands"] = 4400,
["Country_data_Central_African_Republic"] = 4700,
["Country_data_Chad"] = 5200,
["Country_data_Chile"] = 35000,
["Country_data_China"] = 72000,
["Country_data_Chinese_Taipei"] = 16000,
["Country_data_Colombia"] = 40000,
["Country_data_Colorado"] = 5800,
["Country_data_Comoros"] = 4200,
["Country_data_Confederate_States_of_America"] = 3000,
["Country_data_Connecticut"] = 3200,
["Country_data_Cook_Islands"] = 3500,
["Country_data_Costa_Rica"] = 16000,
["Country_data_Croatia"] = 49000,
["Country_data_Cuba"] = 19000,
["Country_data_Curaçao"] = 3800,
["Country_data_Cyprus"] = 19000,
["Country_data_Czech_Republic"] = 69000,
["Country_data_Czechoslovakia"] = 16000,
["Country_data_DEN"] = 31000,
["Country_data_DEU"] = 8000,
["Country_data_DNK"] = 3300,
["Country_data_DOM"] = 7600,
["Country_data_Democratic_Republic_of_the_Congo"] = 11000,
["Country_data_Denmark"] = 62000,
["Country_data_Djibouti"] = 4400,
["Country_data_Dominica"] = 4200,
["Country_data_Dominican_Republic"] = 16000,
["Country_data_ECU"] = 11000,
["Country_data_EGY"] = 12000,
["Country_data_ENG"] = 42000,
["Country_data_ESA"] = 2300,
["Country_data_ESP"] = 66000,
["Country_data_EST"] = 13000,
["Country_data_ETH"] = 3200,
["Country_data_EU"] = 3600,
["Country_data_East_Germany"] = 11000,
["Country_data_East_Timor"] = 4700,
["Country_data_Ecuador"] = 21000,
["Country_data_Egypt"] = 28000,
["Country_data_El_Salvador"] = 12000,
["Country_data_Empire_of_Japan"] = 3600,
["Country_data_England"] = 85000,
["Country_data_Equatorial_Guinea"] = 5100,
["Country_data_Eritrea"] = 5100,
["Country_data_Estonia"] = 30000,
["Country_data_Eswatini"] = 4700,
["Country_data_Ethiopia"] = 11000,
["Country_data_Europe"] = 2400,
["Country_data_European_Union"] = 7300,
["Country_data_FIJ"] = 3500,
["Country_data_FIN"] = 31000,
["Country_data_FRA"] = 89000,
["Country_data_FRG"] = 13000,
["Country_data_FR_Yugoslavia"] = 3700,
["Country_data_Falkland_Islands"] = 2100,
["Country_data_Faroe_Islands"] = 5100,
["Country_data_Federated_States_of_Micronesia"] = 3000,
["Country_data_Fiji"] = 10000,
["Country_data_Finland"] = 57000,
["Country_data_Florida"] = 6600,
["Country_data_France"] = 185000,
["Country_data_French_Guiana"] = 2000,
["Country_data_French_Polynesia"] = 3500,
["Country_data_GAB"] = 2300,
["Country_data_GBR"] = 49000,
["Country_data_GDR"] = 6000,
["Country_data_GEO"] = 12000,
["Country_data_GER"] = 73000,
["Country_data_GHA"] = 9200,
["Country_data_GRE"] = 23000,
["Country_data_GUA"] = 5000,
["Country_data_GUI"] = 2700,
["Country_data_GUY"] = 2600,
["Country_data_Gabon"] = 7400,
["Country_data_Gambia"] = 6200,
["Country_data_Georgia"] = 11000,
["Country_data_Georgia_(U.S._state)"] = 2700,
["Country_data_Georgia_(country)"] = 25000,
["Country_data_German_Empire"] = 4900,
["Country_data_Germany"] = 132000,
["Country_data_Ghana"] = 21000,
["Country_data_Gibraltar"] = 4700,
["Country_data_Great_Britain"] = 59000,
["Country_data_Greece"] = 50000,
["Country_data_Greenland"] = 2700,
["Country_data_Grenada"] = 4900,
["Country_data_Guadeloupe"] = 2600,
["Country_data_Guam"] = 4900,
["Country_data_Guatemala"] = 12000,
["Country_data_Guernsey"] = 2300,
["Country_data_Guinea"] = 7800,
["Country_data_Guinea-Bissau"] = 4700,
["Country_data_Guyana"] = 7700,
["Country_data_HAI"] = 3300,
["Country_data_HKG"] = 12000,
["Country_data_HON"] = 4300,
["Country_data_HUN"] = 33000,
["Country_data_Haiti"] = 8700,
["Country_data_Honduras"] = 11000,
["Country_data_Hong_Kong"] = 22000,
["Country_data_Hungary"] = 58000,
["Country_data_IDN"] = 4700,
["Country_data_INA"] = 9700,
["Country_data_IND"] = 28000,
["Country_data_IRE"] = 10000,
["Country_data_IRI"] = 4600,
["Country_data_IRL"] = 19000,
["Country_data_IRN"] = 5600,
["Country_data_IRQ"] = 3700,
["Country_data_ISL"] = 7900,
["Country_data_ISR"] = 19000,
["Country_data_ITA"] = 78000,
["Country_data_Iceland"] = 20000,
["Country_data_Idaho"] = 2200,
["Country_data_Illinois"] = 5300,
["Country_data_India"] = 96000,
["Country_data_Indiana"] = 2800,
["Country_data_Indonesia"] = 32000,
["Country_data_Iowa"] = 3000,
["Country_data_Iran"] = 83000,
["Country_data_Iraq"] = 12000,
["Country_data_Ireland"] = 31000,
["Country_data_Isle_of_Man"] = 3000,
["Country_data_Israel"] = 40000,
["Country_data_Italy"] = 126000,
["Country_data_Ivory_Coast"] = 15000,
["Country_data_JAM"] = 9000,
["Country_data_JOR"] = 3500,
["Country_data_JP"] = 8000,
["Country_data_JPN"] = 55000,
["Country_data_Jamaica"] = 18000,
["Country_data_Japan"] = 103000,
["Country_data_Jersey"] = 2700,
["Country_data_Jordan"] = 10000,
["Country_data_KAZ"] = 17000,
["Country_data_KEN"] = 6600,
["Country_data_KGZ"] = 3400,
["Country_data_KOR"] = 29000,
["Country_data_KOS"] = 2000,
["Country_data_KSA"] = 5200,
["Country_data_KUW"] = 3600,
["Country_data_Kazakhstan"] = 29000,
["Country_data_Kenya"] = 17000,
["Country_data_Kingdom_of_Great_Britain"] = 4400,
["Country_data_Kingdom_of_Italy"] = 3700,
["Country_data_Kiribati"] = 2900,
["Country_data_Kosovo"] = 8000,
["Country_data_Kuwait"] = 9700,
["Country_data_Kyrgyzstan"] = 8700,
["Country_data_LAT"] = 13000,
["Country_data_LBN"] = 2100,
["Country_data_LIB"] = 2600,
["Country_data_LIE"] = 2800,
["Country_data_LIT"] = 2900,
["Country_data_LTU"] = 11000,
["Country_data_LUX"] = 9500,
["Country_data_LVA"] = 2300,
["Country_data_Laos"] = 7200,
["Country_data_Latvia"] = 28000,
["Country_data_Lebanon"] = 14000,
["Country_data_Lesotho"] = 4800,
["Country_data_Liberia"] = 6900,
["Country_data_Libya"] = 8300,
["Country_data_Liechtenstein"] = 7300,
["Country_data_Lithuania"] = 27000,
["Country_data_Louisiana"] = 2000,
["Country_data_Luxembourg"] = 20000,
["Country_data_MAC"] = 2400,
["Country_data_MAR"] = 11000,
["Country_data_MAS"] = 9900,
["Country_data_MDA"] = 6600,
["Country_data_MEX"] = 29000,
["Country_data_MGL"] = 2600,
["Country_data_MKD"] = 6600,
["Country_data_MLI"] = 3700,
["Country_data_MLT"] = 5100,
["Country_data_MNE"] = 7100,
["Country_data_MON"] = 3200,
["Country_data_MRI"] = 2100,
["Country_data_MYA"] = 3000,
["Country_data_MYS"] = 3900,
["Country_data_Macau"] = 6200,
["Country_data_Macedonia"] = 4800,
["Country_data_Madagascar"] = 8500,
["Country_data_Malawi"] = 5400,
["Country_data_Malaysia"] = 33000,
["Country_data_Maldives"] = 5800,
["Country_data_Mali"] = 10000,
["Country_data_Malta"] = 15000,
["Country_data_Manitoba"] = 2300,
["Country_data_Marshall_Islands"] = 3600,
["Country_data_Martinique"] = 2600,
["Country_data_Maryland"] = 3000,
["Country_data_Massachusetts"] = 3000,
["Country_data_Mauritania"] = 5400,
["Country_data_Mauritius"] = 7900,
["Country_data_Mexico"] = 55000,
["Country_data_Michigan"] = 4200,
["Country_data_Minnesota"] = 3700,
["Country_data_Missouri"] = 2100,
["Country_data_Moldova"] = 16000,
["Country_data_Monaco"] = 9300,
["Country_data_Mongolia"] = 9000,
["Country_data_Montana"] = 2500,
["Country_data_Montenegro"] = 16000,
["Country_data_Montserrat"] = 2500,
["Country_data_Morocco"] = 23000,
["Country_data_Mozambique"] = 6900,
["Country_data_Myanmar"] = 13000,
["Country_data_NAM"] = 3400,
["Country_data_NED"] = 54000,
["Country_data_NEP"] = 2700,
["Country_data_NGA"] = 7200,
["Country_data_NGR"] = 7800,
["Country_data_NIR"] = 9100,
["Country_data_NLD"] = 5700,
["Country_data_NOR"] = 26000,
["Country_data_NZ"] = 2800,
["Country_data_NZL"] = 30000,
["Country_data_Namibia"] = 9500,
["Country_data_Nauru"] = 2500,
["Country_data_Nazi_Germany"] = 8900,
["Country_data_Nepal"] = 15000,
["Country_data_Netherlands"] = 96000,
["Country_data_Netherlands_Antilles"] = 2300,
["Country_data_New_Brunswick"] = 2400,
["Country_data_New_Caledonia"] = 3300,
["Country_data_New_Jersey"] = 4300,
["Country_data_New_South_Wales"] = 5400,
["Country_data_New_York"] = 4000,
["Country_data_New_York_(state)"] = 6000,
["Country_data_New_Zealand"] = 54000,
["Country_data_Newfoundland_and_Labrador"] = 2200,
["Country_data_Nicaragua"] = 8900,
["Country_data_Niger"] = 5400,
["Country_data_Nigeria"] = 29000,
["Country_data_North_Carolina"] = 3400,
["Country_data_North_Korea"] = 12000,
["Country_data_North_Macedonia"] = 15000,
["Country_data_Northern_Cyprus"] = 2100,
["Country_data_Northern_Ireland"] = 13000,
["Country_data_Northern_Mariana_Islands"] = 2800,
["Country_data_Norway"] = 61000,
["Country_data_Nova_Scotia"] = 2200,
["Country_data_OMA"] = 2400,
["Country_data_Ohio"] = 4900,
["Country_data_Oman"] = 8200,
["Country_data_Ontario"] = 3500,
["Country_data_Ottoman_Empire"] = 2400,
["Country_data_PAK"] = 7500,
["Country_data_PAN"] = 6400,
["Country_data_PAR"] = 9700,
["Country_data_PER"] = 12000,
["Country_data_PHI"] = 11000,
["Country_data_PHL"] = 2900,
["Country_data_PNG"] = 2500,
["Country_data_POL"] = 45000,
["Country_data_POR"] = 28000,
["Country_data_PRC"] = 2900,
["Country_data_PRK"] = 4100,
["Country_data_PRT"] = 2700,
["Country_data_PUR"] = 8000,
["Country_data_Pakistan"] = 26000,
["Country_data_Palau"] = 2900,
["Country_data_Palestine"] = 6300,
["Country_data_Panama"] = 15000,
["Country_data_Papua_New_Guinea"] = 7400,
["Country_data_Paraguay"] = 18000,
["Country_data_Pennsylvania"] = 3600,
["Country_data_People's_Republic_of_China"] = 3100,
["Country_data_Peru"] = 28000,
["Country_data_Philippines"] = 31000,
["Country_data_Poland"] = 133000,
["Country_data_Portugal"] = 56000,
["Country_data_Prussia"] = 2400,
["Country_data_Puerto_Rico"] = 16000,
["Country_data_QAT"] = 6800,
["Country_data_Qatar"] = 15000,
["Country_data_Quebec"] = 4000,
["Country_data_ROC"] = 2300,
["Country_data_ROM"] = 12000,
["Country_data_ROU"] = 23000,
["Country_data_RSA"] = 29000,
["Country_data_RUS"] = 60000,
["Country_data_Republic_of_China"] = 6300,
["Country_data_Republic_of_Ireland"] = 21000,
["Country_data_Republic_of_the_Congo"] = 7100,
["Country_data_Romania"] = 55000,
["Country_data_Russia"] = 102000,
["Country_data_Russian_Empire"] = 4500,
["Country_data_Rwanda"] = 7200,
["Country_data_SAM"] = 2800,
["Country_data_SCG"] = 3000,
["Country_data_SCO"] = 24000,
["Country_data_SEN"] = 6900,
["Country_data_SER"] = 3300,
["Country_data_SGP"] = 2100,
["Country_data_SIN"] = 7100,
["Country_data_SLO"] = 18000,
["Country_data_SLV"] = 3100,
["Country_data_SMR"] = 2800,
["Country_data_SPA"] = 4200,
["Country_data_SRB"] = 24000,
["Country_data_SRI"] = 4600,
["Country_data_SUI"] = 38000,
["Country_data_SVK"] = 26000,
["Country_data_SVN"] = 6100,
["Country_data_SWE"] = 52000,
["Country_data_SWI"] = 4600,
["Country_data_SYR"] = 3200,
["Country_data_Saint_Kitts_and_Nevis"] = 4500,
["Country_data_Saint_Lucia"] = 4900,
["Country_data_Saint_Vincent_and_the_Grenadines"] = 4600,
["Country_data_Samoa"] = 7300,
["Country_data_San_Marino"] = 7900,
["Country_data_Saskatchewan"] = 2700,
["Country_data_Saudi_Arabia"] = 17000,
["Country_data_Scotland"] = 45000,
["Country_data_Senegal"] = 14000,
["Country_data_Serbia"] = 47000,
["Country_data_Serbia_and_Montenegro"] = 4900,
["Country_data_Seychelles"] = 5100,
["Country_data_Sierra_Leone"] = 6800,
["Country_data_Singapore"] = 24000,
["Country_data_Slovakia"] = 44000,
["Country_data_Slovenia"] = 36000,
["Country_data_Solomon_Islands"] = 4400,
["Country_data_Somalia"] = 5700,
["Country_data_South_Africa"] = 57000,
["Country_data_South_Carolina"] = 3300,
["Country_data_South_Korea"] = 55000,
["Country_data_South_Sudan"] = 3600,
["Country_data_South_Vietnam"] = 2000,
["Country_data_Soviet_Union"] = 30000,
["Country_data_Spain"] = 115000,
["Country_data_Sri_Lanka"] = 17000,
["Country_data_Sudan"] = 7500,
["Country_data_Suriname"] = 6100,
["Country_data_Swaziland"] = 2000,
["Country_data_Sweden"] = 88000,
["Country_data_Switzerland"] = 70000,
["Country_data_Syria"] = 14000,
["Country_data_São_Tomé_and_Príncipe"] = 3300,
["Country_data_TAN"] = 2400,
["Country_data_TCH"] = 9500,
["Country_data_THA"] = 20000,
["Country_data_TJK"] = 2300,
["Country_data_TKM"] = 2500,
["Country_data_TPE"] = 14000,
["Country_data_TRI"] = 4700,
["Country_data_TUN"] = 9200,
["Country_data_TUR"] = 24000,
["Country_data_Taiwan"] = 11000,
["Country_data_Tajikistan"] = 8500,
["Country_data_Tanzania"] = 10000,
["Country_data_Texas"] = 5500,
["Country_data_Thailand"] = 39000,
["Country_data_Togo"] = 6400,
["Country_data_Tonga"] = 6000,
["Country_data_Trinidad_and_Tobago"] = 13000,
["Country_data_Tunisia"] = 18000,
["Country_data_Turkey"] = 66000,
["Country_data_Turkmenistan"] = 7400,
["Country_data_Turks_and_Caicos_Islands"] = 2800,
["Country_data_Tuvalu"] = 2600,
["Country_data_U.S."] = 2100,
["Country_data_U.S._Virgin_Islands"] = 4900,
["Country_data_UAE"] = 8300,
["Country_data_UGA"] = 3500,
["Country_data_UK"] = 18000,
["Country_data_UKGBI"] = 2700,
["Country_data_UKR"] = 33000,
["Country_data_URS"] = 11000,
["Country_data_URU"] = 14000,
["Country_data_US"] = 5300,
["Country_data_USA"] = 126000,
["Country_data_USSR"] = 4400,
["Country_data_UZB"] = 10000,
["Country_data_Uganda"] = 11000,
["Country_data_Ukraine"] = 57000,
["Country_data_United_Arab_Emirates"] = 17000,
["Country_data_United_Kingdom"] = 80000,
["Country_data_United_Kingdom_of_Great_Britain_and_Ireland"] = 4000,
["Country_data_United_Nations"] = 3700,
["Country_data_United_States"] = 265000,
["Country_data_United_States_of_America"] = 4600,
["Country_data_Uruguay"] = 26000,
["Country_data_Uzbekistan"] = 18000,
["Country_data_VEN"] = 16000,
["Country_data_VIE"] = 5900,
["Country_data_Vanuatu"] = 4900,
["Country_data_Vatican_City"] = 2300,
["Country_data_Venezuela"] = 30000,
["Country_data_Vietnam"] = 20000,
["Country_data_Virginia"] = 2800,
["Country_data_WAL"] = 16000,
["Country_data_Wales"] = 30000,
["Country_data_Washington"] = 3200,
["Country_data_Washington,_D.C."] = 2200,
["Country_data_Washington_(state)"] = 3500,
["Country_data_West_Germany"] = 19000,
["Country_data_West_Indies"] = 2400,
["Country_data_Wisconsin"] = 5900,
["Country_data_Wyoming"] = 2100,
["Country_data_YUG"] = 8800,
["Country_data_Yemen"] = 6800,
["Country_data_Yugoslavia"] = 16000,
["Country_data_ZAF"] = 4400,
["Country_data_ZAM"] = 3000,
["Country_data_ZIM"] = 7800,
["Country_data_Zambia"] = 8900,
["Country_data_Zimbabwe"] = 16000,
["Country_flagbio"] = 24000,
["Country_name"] = 9200,
["Country_showdata"] = 5700,
["Country_topics"] = 21000,
["County"] = 7400,
["County_(judet)_of_Romania"] = 3300,
["Course_assignment"] = 4300,
["Course_details"] = 5200,
["Course_instructor"] = 2100,
["Cquote"] = 36000,
["Cr"] = 3900,
["Create_taxonomy/link"] = 93000,
["Cref2"] = 2000,
["Cricinfo"] = 22000,
["Cricketarchive"] = 3500,
["Crime_opentask"] = 34000,
["Croatian_Census_2011"] = 2000,
["Cross"] = 3000,
["Crossreference"] = 2200,
["Crossreference/styles.css"] = 2200,
["Csv"] = 2900,
["Ct"] = 11000,
["Curlie"] = 6900,
["Currency"] = 2500,
["Current_events_footer"] = 6100,
["Current_events_header"] = 7100,
["Currentdate"] = 22000,
["Cvt"] = 98000,
["Cycling_Archives"] = 5200,
["Cycling_archives"] = 3600,
["Cycling_team_link"] = 11000,
["Module:CFB_schedule"] = 24000,
["Module:CallAssert"] = 217000,
["Module:CanElecResTopTest"] = 5100,
["Module:CanadaByProvinceCatNav"] = 9600,
["Module:Cat_main"] = 171000,
["Module:Cat_more_if_exists"] = 44000,
["Module:Catalog_lookup_link"] = 483000,
["Module:Category_described_in_year"] = 5600,
["Module:Category_described_in_year/conf"] = 5600,
["Module:Category_handler"] = 4260000,
["Module:Category_handler/blacklist"] = 4260000,
["Module:Category_handler/config"] = 4260000,
["Module:Category_handler/data"] = 4260000,
["Module:Category_handler/shared"] = 4260000,
["Module:Category_pair"] = 5700,
["Module:Category_see_also"] = 33000,
["Module:Celestial_object_quadrangle"] = 2500,
["Module:Check_DYK_hook"] = 109000,
["Module:Check_for_clobbered_parameters"] = 1140000,
["Module:Check_for_unknown_parameters"] = 12600000,
["Module:Check_isxn"] = 473000,
["Module:Check_winner_by_scores"] = 12000,
["Module:Citation/CS1"] = 5130000,
["Module:Citation/CS1/COinS"] = 5130000,
["Module:Citation/CS1/Configuration"] = 5130000,
["Module:Citation/CS1/Date_validation"] = 5130000,
["Module:Citation/CS1/Identifiers"] = 5130000,
["Module:Citation/CS1/Suggestions"] = 30000,
["Module:Citation/CS1/Utilities"] = 5140000,
["Module:Citation/CS1/Whitelist"] = 5130000,
["Module:Citation/CS1/styles.css"] = 5260000,
["Module:Cite_Q"] = 52000,
["Module:Cite_iucn"] = 53000,
["Module:Cite_tweet"] = 26000,
["Module:Cite_web"] = 29000,
["Module:Clade"] = 6000,
["Module:Clickable_button_2"] = 837000,
["Module:Collapsible_list"] = 50000,
["Module:College_color"] = 118000,
["Module:College_color/data"] = 118000,
["Module:Color_contrast"] = 473000,
["Module:Color_contrast/colors"] = 475000,
["Module:Commons_link"] = 228000,
["Module:Complex_date"] = 65000,
["Module:Convert"] = 1150000,
["Module:Convert/data"] = 1150000,
["Module:Convert/helper"] = 6600,
["Module:Convert/text"] = 1150000,
["Module:Convert/wikidata"] = 2500,
["Module:Convert/wikidata/data"] = 2500,
["Module:ConvertNumeric"] = 26000,
["Module:Convert_character_width"] = 2800,
["Module:Convert_character_width/data"] = 2800,
["Module:Coordinates"] = 1290000,
["Module:Coordinates/styles.css"] = 1290000,
["Module:Copied"] = 17000,
["Module:CountryAdjectiveDemonym"] = 42000,
["Module:CountryAdjectiveDemonym/Adjectives"] = 42000,
["Module:CountryAdjectiveDemonym/Demonyms"] = 42000,
["Module:CountryAdjectiveDemonym/The"] = 42000,
["Module:CountryData"] = 18000,
["Module:CountryData/summary"] = 18000,
["Module:Country_adjective"] = 3900,
["Module:Country_alias"] = 49000,
["Module:Country_alias/data"] = 49000,
["Module:Currency"] = 2600,
["Module:Currency/Presentation"] = 2600,
}</text>
      <sha1>32dp4ozqz2nqvm93a9ej329uu72fh49</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Transclusion count/data/Y</title>
    <ns>828</ns>
    <id>61481074</id>
    <revision>
      <id>1071545150</id>
      <parentid>1070187821</parentid>
      <timestamp>2022-02-13T05:16:05Z</timestamp>
      <contributor>
        <username>Ahechtbot</username>
        <id>26109785</id>
      </contributor>
      <minor/>
      <comment>[[Wikipedia:BOT|Bot]]: Updated page.</comment>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="2588" xml:space="preserve">return {
["Y"] = 14000,
["YEAR"] = 5200,
["YUG"] = 2100,
["YYYY_beginnings_or_endings_category_header"] = 3900,
["YYYY_beginnings_or_endings_category_header/core"] = 3900,
["YYYY_crimes_in_countryname_category_header"] = 2300,
["YYYY_crimes_in_countryname_category_header/inner_core"] = 2300,
["YYYY_crimes_in_countryname_category_header/outer_core"] = 2300,
["YYYY_elections_in_countryname_category_header"] = 3100,
["YYYY_elections_in_countryname_category_header/inner_core"] = 3100,
["YYYY_elections_in_countryname_category_header/outer_core"] = 3100,
["YYYY_in_nationality_sport_category_header"] = 12000,
["YYYY_in_nationality_sport_category_header/inner_core"] = 12000,
["YYYY_in_nationality_sport_category_header/outer_core"] = 12000,
["Year"] = 4700,
["YearInCountryPortalBox"] = 89000,
["YearInCountryPortalBox/make"] = 89000,
["YearInCountryPortalBox/parse"] = 89000,
["Year_article"] = 6600,
["Year_box"] = 2100,
["Year_box/core"] = 2100,
["Year_box/outer_core"] = 2100,
["Year_category_header"] = 3100,
["Year_category_header/core"] = 3100,
["Year_category_name"] = 2500,
["Year_category_name/AD_year"] = 2500,
["Year_in_Europe"] = 5500,
["Year_in_Europe/expr"] = 5500,
["Year_in_US_state_category"] = 9400,
["Year_in_US_state_category/core"] = 9400,
["Year_in_continent/expr"] = 7500,
["Year_in_continent/link"] = 7500,
["Year_in_continent_category"] = 3700,
["Year_in_continent_category/core"] = 3700,
["Year_in_country_category"] = 38000,
["Year_in_country_category/inner_core"] = 38000,
["Year_in_country_category/outer_core"] = 38000,
["Year_in_football"] = 2200,
["Year_in_nationality_television_category"] = 3100,
["Year_in_nationality_television_category/core"] = 3100,
["Year_in_region"] = 11000,
["Year_in_region/link"] = 11000,
["Year_in_various_calendars"] = 2800,
["Year_nationality_television_series_debuts_or_endings_category"] = 4600,
["Year_nationality_television_series_debuts_or_endings_category/core"] = 4600,
["Year_nav"] = 2800,
["Year_nav_topic"] = 7200,
["Year_nav_topic5"] = 7100,
["Yearly_archive_list"] = 519000,
["Yearly_archive_list/display"] = 519000,
["YearsProject"] = 2200,
["Years_or_months_ago"] = 63000,
["Yel"] = 13000,
["Yes"] = 8700,
["Yes2"] = 9400,
["YesNo-Yes"] = 57000,
["Yesno"] = 12800000,
["Yesno-no"] = 1910000,
["Yesno-yes"] = 9690000,
["Yo"] = 13000,
["You've_got_mail"] = 9900,
["YouTube"] = 53000,
["Youtube"] = 7400,
["Yy"] = 10000,
["Yybottom"] = 10000,
["Yycat"] = 2400,
["Yyend"] = 10000,
["Yytop"] = 10000,
["Module:Year_category_type"] = 3100,
["Module:Year_in_various_calendars"] = 2800,
["Module:Yesno"] = 25700000,
}</text>
      <sha1>kd0hgsm3oh8tfd4jjvem2wi55xrkg5d</sha1>
    </revision>
  </page>
  <page>
    <title>Module:Yesno/doc</title>
    <ns>828</ns>
    <id>40585364</id>
    <revision>
      <id>1061900054</id>
      <parentid>1061886579</parentid>
      <timestamp>2021-12-24T18:54:34Z</timestamp>
      <contributor>
        <username>Pppery</username>
        <id>28032115</id>
      </contributor>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="4316" xml:space="preserve">{{used in system}}
{{Module rating|protected}}
This module provides a consistent interface for processing boolean or boolean-style string input. While Lua allows the &lt;code&gt;true&lt;/code&gt; and &lt;code&gt;false&lt;/code&gt; boolean values, wikicode templates can only express boolean values through strings such as "yes", "no", etc. This module processes these kinds of strings and turns them into boolean input for Lua to process. It also returns &lt;code&gt;nil&lt;/code&gt; values as &lt;code&gt;nil&lt;/code&gt;, to allow for distinctions between &lt;code&gt;nil&lt;/code&gt; and &lt;code&gt;false&lt;/code&gt;. The module also accepts other Lua structures as input, i.e. booleans, numbers, tables, and functions. If it is passed input that it does not recognise as boolean or &lt;code&gt;nil&lt;/code&gt;, it is possible to specify a default value to return.

== Syntax ==

&lt;syntaxhighlight lang="lua"&gt;yesno(value, default)&lt;/syntaxhighlight&gt;

&lt;code&gt;value&lt;/code&gt; is the value to be tested. Boolean input or boolean-style input (see below) always evaluates to either &lt;code&gt;true&lt;/code&gt; or &lt;code&gt;false&lt;/code&gt;, and &lt;code&gt;nil&lt;/code&gt; always evaluates to &lt;code&gt;nil&lt;/code&gt;. Other values evaluate to &lt;code&gt;default&lt;/code&gt;.

== Usage ==

First, load the module. Note that it can only be loaded from other Lua modules, not from normal wiki pages. For normal wiki pages you can use {{tl|yesno}} instead.

&lt;syntaxhighlight lang="lua"&gt;
local yesno = require('Module:Yesno')
&lt;/syntaxhighlight&gt;

Some input values always return &lt;code&gt;true&lt;/code&gt;, and some always return &lt;code&gt;false&lt;/code&gt;. &lt;code&gt;nil&lt;/code&gt; values always return &lt;code&gt;nil&lt;/code&gt;.

&lt;syntaxhighlight lang="lua"&gt;
-- These always return true:
yesno('yes')
yesno('y')
yesno('true')
yesno('t')
yesno('1')
yesno(1)
yesno(true)

-- These always return false:
yesno('no')
yesno('n')
yesno('false')
yesno('f')
yesno('0')
yesno(0)
yesno(false)

-- A nil value always returns nil:
yesno(nil)
&lt;/syntaxhighlight&gt;

String values are converted to lower case before they are matched:

&lt;syntaxhighlight lang="lua"&gt;
-- These always return true:
yesno('Yes')
yesno('YES')
yesno('yEs')
yesno('Y')
yesno('tRuE')

-- These always return false:
yesno('No')
yesno('NO')
yesno('nO')
yesno('N')
yesno('fALsE')
&lt;/syntaxhighlight&gt;

===Undefined input ('foo')===
You can specify a default value if yesno receives input other than that listed above. If you don't supply a default, the module will return &lt;code&gt;nil&lt;/code&gt; for these inputs.

&lt;syntaxhighlight lang="lua"&gt;
-- These return nil:
yesno('foo')
yesno({})
yesno(5)
yesno(function() return 'This is a function.' end)
yesno(nil, true)
yesno(nil, 'bar')

-- These return true:
yesno('foo', true)
yesno({}, true)
yesno(5, true)
yesno(function() return 'This is a function.' end, true)

-- These return "bar":
yesno('foo', 'bar')
yesno({}, 'bar')
yesno(5, 'bar')
yesno(function() return 'This is a function.' end, 'bar')
&lt;/syntaxhighlight&gt;

Note that the empty string also functions this way:
&lt;syntaxhighlight lang="lua"&gt;
yesno('')        -- Returns nil.
yesno('', true)  -- Returns true.
yesno('', 'bar') -- Returns "bar".
&lt;/syntaxhighlight&gt;

Although the empty string usually evaluates to false in wikitext, it evaluates to true in Lua. This module prefers the Lua behaviour over the wikitext behaviour. If treating the empty string as false is important for your module, you will need to convert empty strings to a value that evaluates to false before passing them to this module. In the case of arguments received from wikitext, this can be done by using [[Module:Arguments]].

===Handling nil results===
By definition
:&lt;syntaxhighlight lang="lua"&gt;
yesno(nil)         -- Returns nil.
yesno('foo')       -- Returns nil.
yesno(nil, true)   -- Returns nil.
yesno(nil, false)  -- Returns nil.
yesno('foo', true) -- Returns true.
&lt;/syntaxhighlight&gt;

To get the binary &lt;syntaxhighlight lang="lua" inline&gt;true/false&lt;/syntaxhighlight&gt;-only values, use code like:
&lt;syntaxhighlight lang="lua"&gt;
myvariable = yesno(value) or false -- When value is nil, result is false.
myvariable = yesno(value) or true  -- When value is nil, result is true.
myvariable = yesno('foo') or false  -- Unknown string returns nil, result is false.
myvariable = yesno('foo', true) or false  -- Default value (here: true) applies, result is true.
&lt;/syntaxhighlight&gt;&lt;!--

--&gt;&lt;includeonly&gt;{{sandbox other||
[[Category:Lua metamodules]]
}}&lt;/includeonly&gt;</text>
      <sha1>nrpba7al4tg6jf69dmn4yqegiu1jctj</sha1>
    </revision>
  </page>
</mediawiki>