cardbot.wiki - User contributions [en]

MediaWiki:Common.css

2026-04-15T19:55:40Z

Cabalex:

/* CSS placed here will be applied to all skins */
.image-buttons, .image-buttons ul {
display: flex;
align-items: stretch;
justify-content: space-evenly;
gap: 1rem;
list-style: none;
}
.image-buttons ul li {
width: 100%;
flex-shrink: 1;
flex-grow: 1;
}
.image-button-container {
display: flex;
border: 1px solid #aaa;
width: 100%;
height: 100%;
}
.image-button-container img {
width: 100%;
height: 100%;
object-fit: contain;
}

MediaWiki:Common.css

2026-04-15T19:53:59Z

Cabalex:

/* CSS placed here will be applied to all skins */
.image-buttons, .image-buttons ul {
display: flex;
align-items: stretch;
justify-content: space-evenly;
gap: 1rem;
list-style: none;
}
.image-button-container {
display: flex;
border: 1px solid #aaa;
width: 100%;
height: 100%;
}
.image-button-container img {
width: 100%;
height: 100%;
object-fit: contain;
}

MediaWiki:Common.css

2026-04-15T19:52:46Z

Cabalex:

/* CSS placed here will be applied to all skins */
.image-buttons, .image-buttons ul {
display: flex;
align-items: stretch;
justify-content: space-evenly;
gap: 1rem;
}
.image-button-container {
display: flex;
border: 1px solid #aaa;
}
.image-button-container img {
width: 100%;
height: 100%;
}

Template:Image button

2026-04-15T19:49:18Z

Cabalex:

<includeonly>
<div class="image-button-container {{#if:{{{label|}}}|has-text}}">

<div class="image {{{image-hover|hide-on-hover}}}">[[File:{{{image}}}|{{{size|330px}}}|link={{{link|}}}|class={{{imageClass|}}} ]]</div>{{#if:{{{image-hover|}}}|<div class="hover-image">[[File:{{{image-hover}}}|{{{size|330px}}}|link={{{link}}}|class={{{imageClass|}}}]]</div>}}<div class="image-button--gloss"></div>{{#if:{{{label|}}}|<div class="image-button--text">[[{{{link}}}|{{{label}}}]]</div>}}</div></includeonly><noinclude>
{{doc}}
</noinclude>

Template:Image button

2026-04-15T19:47:58Z

Cabalex:

<includeonly>
<div class="image-button-container {{#if:{{{label|}}}|has-text}}">

<div class="image {{{image-hover|hide-on-hover}}}">[[File:{{{image}}}|{{{size|330px}}}|link={{link}}|class={{{imageClass|}}} ]]</div>{{#if:{{{image-hover|}}}|<div class="hover-image">[[File:{{{image-hover}}}|{{{size|330px}}}|link={{{link}}}|class={{{imageClass|}}}]]</div>}}<div class="image-button--gloss"></div>{{#if:{{{label|}}}|<div class="image-button--text">[[{{{link}}}|{{{label}}}]]</div>}}</div></includeonly><noinclude>
{{doc}}
</noinclude>

Template:Image button

2026-04-15T19:45:57Z

Cabalex:

<includeonly>
<div class="image-button-container {{#if:{{#var:label}}|has-text}}">

<div class="image {{{image-hover|hide-on-hover}}}">[[File:{{{image}}}|{{{size|330px}}}|link={{link}}|class={{{imageClass|}}} ]]</div>{{#if:{{{image-hover|}}}|<div class="hover-image">[[File:{{{image-hover}}}|{{{size|330px}}}|link={{{link}}}|class={{{imageClass|}}}]]</div>}}<div class="image-button--gloss"></div>{{#if:{{{label}}}|<div class="image-button--text">[[{{{link}}}|{{{label}}}]]</div>}}</div></includeonly><noinclude>
{{doc}}
</noinclude>

Template:MainPage

2026-04-15T19:39:26Z

Cabalex:

<div class="image-buttons">
<ul>
<li>{{Image button|link=Metal Cardbot (season)|image=Metal Cardbot logo.png}}</li>
<li>{{Image button|link=Metal Cardbot S|image=Metal Cardbot S logo.png}}</li>
<li>{{Image button|link=Metal Cardbot W|image=Metal Cardbot W logo.png}}</li>
</ul>
</div>

'''Metal Cardbot''' is a 2023 Korean animated mecha series created by [[SAMG Entertainment]], directed by [[OSROCTION]] and animated by [[NAVY Co, Ltd.]]. A boy named [[Jun]] discovers the [[Metal Breath]], a mysterious device that allows him to capture and command a species of transforming robots known as [[Metal Cardbots]], who take refuge on [[Earth]] after their home planet [[Machina]] was destroyed.

Metal Cardbot currently has three main seasons ([[Metal Cardbot (series)|Metal Cardbot]], [[Metal Cardbot S]], [[Metal Cardbot W]]) and two Chinese spinoff seasons ([[Metal Cardbot: Beast Energy]], [[Metal Cardbot: Zerg Crisis]]). The first season has been dubbed in a variety of languages, including [[English localization|English]], [[Chinese localization|Chinese]], [[Russian localization|Russian]], [[Indonesian localization|Indonesian]], and [[Spanish localization|Spanish]]).

== Contributions ==
As this wiki is currently under construction, and we want to ensure cardbot.wiki remains a reliable source of Metal Cardbot info, this wiki isn't open for direct contributions at this time. However, we're always open to suggestions and corrections! If you have something to add, [https://forms.gle/cAYv3CQWy4yfakws7 please use this form].

Template:Image button

2026-04-15T19:35:59Z

Cabalex:

<includeonly>{{#vardefine:link|{{{link|}}}}}{{#vardefine:label|{{{label|}}}}}<div class="image-button-container {{#if:{{#var:label}}|has-text}}"><div class="image {{#if:{{{image-hover|}}}|hide-on-hover}}">{{#if:{{{image|}}}|[[File:{{#replace:{{{image|}}}|File:}}|{{{size|330px}}}|link={{#var:link}}|class={{{imageClass|}}} ]]}}</div>{{#if:{{{image-hover|}}}|<div class="hover-image">[[File:{{#replace:{{{image-hover|}}}|File:}}|{{{size|330px}}}|link={{#var:link}}|class={{{imageClass|}}}]]</div>}}<div class="image-button--gloss"></div>{{#if:{{#var:label}}|<div class="image-button--text">[[{{#var:link}}|{{#var:label}}]]</div>}}</div></includeonly><noinclude>
{{doc}}
</noinclude>

Template:MainPage

2026-04-15T19:34:48Z

Cabalex:

<div class="portal-buttons">{{Template:Image button|Metal Cardbot (season)|image=File:Metal Cardbot logo}}{{Template:Image button|Metal Cardbot S|image=File:Metal Cardbot S logo}}{{Template:Image button|Metal Cardbot W|image=File:Metal Cardbot W logo}}</div>

'''Metal Cardbot''' is a 2023 Korean animated mecha series created by [[SAMG Entertainment]], directed by [[OSROCTION]] and animated by [[NAVY Co, Ltd.]]. A boy named [[Jun]] discovers the [[Metal Breath]], a mysterious device that allows him to capture and command a species of transforming robots known as [[Metal Cardbots]], who take refuge on [[Earth]] after their home planet [[Machina]] was destroyed.

Metal Cardbot currently has three main seasons ([[Metal Cardbot (series)|Metal Cardbot]], [[Metal Cardbot S]], [[Metal Cardbot W]]) and two Chinese spinoff seasons ([[Metal Cardbot: Beast Energy]], [[Metal Cardbot: Zerg Crisis]]). The first season has been dubbed in a variety of languages, including [[English localization|English]], [[Chinese localization|Chinese]], [[Russian localization|Russian]], [[Indonesian localization|Indonesian]], and [[Spanish localization|Spanish]]).

== Contributions ==
As this wiki is currently under construction, and we want to ensure cardbot.wiki remains a reliable source of Metal Cardbot info, this wiki isn't open for direct contributions at this time. However, we're always open to suggestions and corrections! If you have something to add, [https://forms.gle/cAYv3CQWy4yfakws7 please use this form].

Template:Image button

2026-04-15T19:32:47Z

Cabalex: Created page with "This creates one of the stylized and formatted buttons on the main page. == Usage == Groups of this template should be wrapped inside of <code><nowiki><div class="image-buttons"></div></nowiki></code> and each entry should be a separate line in an unordered list. This div can be given one of the classes <code>columns-x</code> where x is a number from 1 to 9, and the links will line up in that many columns if..."

This creates one of the stylized and formatted buttons on the [[{{MediaWiki:Mainpage}}|main page]].

== Usage ==
Groups of this template should be wrapped inside of <code><nowiki><div class="image-buttons"></div></nowiki></code> and each entry should be a separate line in an [[wikipedia:Help:Lists#Basically|unordered list]]. This div can be given one of the classes <code>columns-x</code> where x is a number from 1 to 9, and the links will line up in that many columns if space permits (default is 3). See [[Template:Image_button/styles.css]] for the full definitions of these classes and styling for this template.

===Parameters===
<templatedata>
{
"description": {
"en": "Creates stylized and formatted buttons."
},
"format": "inline",
"params": {
"link": {
"label": {
"en": "Link"
},
"description": {
"en": "The target page for the link."
},
"required": true,
"example": "Main Page",
"type": "wiki-page-name"
},
"label": {
"label": {
"en": "Label"
},
"description": {
"en": "Text to display as image label."
},
"required": false,
"suggested": true,
"type": "string"
},
"image": {
"label": {
"en": "Image"
},
"description": {
"en": "Button image to display."
},
"required": true,
"suggested": true,
"type": "wiki-file-name"
},
"image-hover": {
"label": {
"en": "Image on Hover"
},
"description": {
"en": "Button image to display when hovered."
},
"required": false,
"suggested": true,
"type": "wiki-file-name"
},
"size": {
"label": {
"en": "Image size"
},
"description": {
"en": "The size of the image, in px."
},
"required": false,
"default": "576px",
"type": "string"
},
"imageClass": {
"label": "Image class",
"description": "A class to give directly to the image",
"example": "invert-on-dark",
"type": "string",
"suggestedvalues": [
"invert-on-dark",
"invert-on-light"
]
}
},
"paramOrder": [
"link",
"label",
"image",
"image-hover",
"size",
"imageClass"
]
}
</templatedata>

<noinclude>
[[Category:Template documentation]]
</noinclude>

Template:Clickable button

2026-04-15T19:27:23Z

Cabalex:

<onlyinclude>{{#if:{{{3|{{{external|}}}}}}
| <span class="plainlinks" {{#if:{{{id|}}}|id="{{{id}}}"}}>[{{{1|{{{target|//parameter_target_is_empty.de}}}}}} <span class="submit ui-button ui-widget ui-state-default ui-corner-all {{Clickable button/iconclass
|{{{4|{{{iconPrimary|}}}}}}
|{{{5|{{{iconSecondary|}}}}}}
|{{{2|{{{text|<noinclude>x</noinclude>}}}}}}
}} {{{class|}}}" role="button" aria-disabled="false">{{#if:{{{4|{{{iconPrimary|}}}}}}
|<span class="ui-button-icon-primary ui-icon {{{4|{{{iconPrimary}}}}}}"> </span>
}}<span class="ui-button-text">{{{2|{{{text|Parameter '''text''' is empty}}}}}}</span>{{#if:{{{5|{{{iconSecondary|}}}}}}
|<span class="ui-button-icon-secondary ui-icon {{{5|{{{iconSecondary|}}}}}}"> </span>
}}</span>]</span>
| [[{{{1|{{{target|Parameter target is empty!}}}}}}|<span class="submit ui-button ui-widget ui-state-default ui-corner-all {{Clickable button/iconclass
|{{{4|{{{iconPrimary|}}}}}}
|{{{5|{{{iconSecondary|}}}}}}
|{{{2|{{{text|<noinclude>x</noinclude>}}}}}}
}} {{{class|}}}" role="button" aria-disabled="false" {{#if:{{{id|}}}|id="{{{id}}}"}}>{{#if:{{{4|{{{iconPrimary|}}}}}}
|<span class="ui-button-icon-primary ui-icon {{{4|{{{iconPrimary}}}}}}"> </span>
}}<span class="ui-button-text">{{{2|{{{text|Parameter '''text''' is empty}}}}}}</span>{{#if:{{{5|{{{iconSecondary|}}}}}}
|<span class="ui-button-icon-secondary ui-icon {{{5|{{{iconSecondary|}}}}}}"> </span>
}}</span>]]
}}</onlyinclude>
{{documentation}}

Template:MainPage

2026-04-15T19:23:16Z

Cabalex:

<div class="portal-buttons">{{Template:Clickable button|Metal Cardbot (season)|[[File:Metal Cardbot logo.png]]|class=mw-ui-{{{class|button}}}}}{{Template:Clickable button|Metal Cardbot S|[[File:Metal Cardbot S logo.png]]|class=mw-ui-{{{class|button}}}}}{{Template:Clickable button|Metal Cardbot W|[[File:Metal Cardbot W logo.png]]|class=mw-ui-{{{class|button}}}}}</div>

'''Metal Cardbot''' is a 2023 Korean animated mecha series created by [[SAMG Entertainment]], directed by [[OSROCTION]] and animated by [[NAVY Co, Ltd.]]. A boy named [[Jun]] discovers the [[Metal Breath]], a mysterious device that allows him to capture and command a species of transforming robots known as [[Metal Cardbots]], who take refuge on [[Earth]] after their home planet [[Machina]] was destroyed.

Metal Cardbot currently has three main seasons ([[Metal Cardbot (series)|Metal Cardbot]], [[Metal Cardbot S]], [[Metal Cardbot W]]) and two Chinese spinoff seasons ([[Metal Cardbot: Beast Energy]], [[Metal Cardbot: Zerg Crisis]]). The first season has been dubbed in a variety of languages, including [[English localization|English]], [[Chinese localization|Chinese]], [[Russian localization|Russian]], [[Indonesian localization|Indonesian]], and [[Spanish localization|Spanish]]).

== Contributions ==
As this wiki is currently under construction, and we want to ensure cardbot.wiki remains a reliable source of Metal Cardbot info, this wiki isn't open for direct contributions at this time. However, we're always open to suggestions and corrections! If you have something to add, [https://forms.gle/cAYv3CQWy4yfakws7 please use this form].

Template:PortalButton

2026-04-15T06:34:37Z

Cabalex:

<span style="display: inline-block; position:absolute; height:2.4em; overflow:hidden; margin-top: 1px; margin-left: 1px;">[[{{{file|{{{File|{{{image|{{{icon|{{{3|File:Icon.png}}}}}}}}}}}}}}}|link={{{link|{{{page|{{{url|{{{2|Main Page}}}}}}}}}}}}|frameless|upright={{{upright|{{{scale|1}}}}}}]]</span>{{Template:Clickable button|{{{link|}}}|<span style{{=}}"display: inline-block; padding-left: {{{offset|0}}}">{{{text|}}}</span>|class=mw-ui-{{{class|button}}}}}

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

Main Page

2026-04-15T06:32:41Z

Cabalex:

{{DISPLAYTITLE:<span style="position: absolute; clip: rect(1px 1px 1px 1px); clip: rect(1px, 1px, 1px, 1px);">{{FULLPAGENAME}}</span>}}

{{MainPage}}

Template:MainPage

2026-04-15T06:32:27Z

Cabalex:

<div class="portal-buttons">{{PortalButton|image=File:Metal Cardbot logo.png|link=Metal Cardbot (season)}}{{PortalButton|image=File:Metal Cardbot S logo.png|link=Metal Cardbot S}}{{PortalButton|image=File:Metal Cardbot W logo.png|link=Metal Cardbot W}}</div>

'''Metal Cardbot''' is a 2023 Korean animated mecha series created by [[SAMG Entertainment]], directed by [[OSROCTION]] and animated by [[NAVY Co, Ltd.]]. A boy named [[Jun]] discovers the [[Metal Breath]], a mysterious device that allows him to capture and command a species of transforming robots known as [[Metal Cardbots]], who take refuge on [[Earth]] after their home planet [[Machina]] was destroyed.

Metal Cardbot currently has three main seasons ([[Metal Cardbot (series)|Metal Cardbot]], [[Metal Cardbot S]], [[Metal Cardbot W]]) and two Chinese spinoff seasons ([[Metal Cardbot: Beast Energy]], [[Metal Cardbot: Zerg Crisis]]). The first season has been dubbed in a variety of languages, including [[English localization|English]], [[Chinese localization|Chinese]], [[Russian localization|Russian]], [[Indonesian localization|Indonesian]], and [[Spanish localization|Spanish]]).

== Contributions ==
As this wiki is currently under construction, and we want to ensure cardbot.wiki remains a reliable source of Metal Cardbot info, this wiki isn't open for direct contributions at this time. However, we're always open to suggestions and corrections! If you have something to add, [https://forms.gle/cAYv3CQWy4yfakws7 please use this form].

MediaWiki:Common.css

2026-04-15T06:31:43Z

Cabalex: Created page with "/* CSS placed here will be applied to all skins */ .portal-buttons { display: flex; gap: 1rem; }"

/* CSS placed here will be applied to all skins */
.portal-buttons {
display: flex;
gap: 1rem;
}

Template:MainPage

2026-04-15T06:30:57Z

Cabalex: Created page with "<div class="portal-buttons"> {{PortalButton|image=File:Metal Cardbot logo.png|link=Metal Cardbot (season)}} {{PortalButton|image=File:Metal Cardbot S logo.png|link=Metal Cardbot S}} {{PortalButton|image=File:Metal Cardbot W logo.png|link=Metal Cardbot W}} </div> '''Metal Cardbot''' is a 2023 Korean animated mecha series created by SAMG Entertainment, directed by OSROCTION and animated by NAVY Co, Ltd.. A boy named Jun discovers the Metal Breath, a my..."

<div class="portal-buttons">
{{PortalButton|image=File:Metal Cardbot logo.png|link=Metal Cardbot (season)}}
{{PortalButton|image=File:Metal Cardbot S logo.png|link=Metal Cardbot S}}
{{PortalButton|image=File:Metal Cardbot W logo.png|link=Metal Cardbot W}}
</div>

'''Metal Cardbot''' is a 2023 Korean animated mecha series created by [[SAMG Entertainment]], directed by [[OSROCTION]] and animated by [[NAVY Co, Ltd.]]. A boy named [[Jun]] discovers the [[Metal Breath]], a mysterious device that allows him to capture and command a species of transforming robots known as [[Metal Cardbots]], who take refuge on [[Earth]] after their home planet [[Machina]] was destroyed.

Metal Cardbot currently has three main seasons ([[Metal Cardbot (series)|Metal Cardbot]], [[Metal Cardbot S]], [[Metal Cardbot W]]) and two Chinese spinoff seasons ([[Metal Cardbot: Beast Energy]], [[Metal Cardbot: Zerg Crisis]]). The first season has been dubbed in a variety of languages, including [[English localization|English]], [[Chinese localization|Chinese]], [[Russian localization|Russian]], [[Indonesian localization|Indonesian]], and [[Spanish localization|Spanish]]).

== Contributions ==
As this wiki is currently under construction, and we want to ensure cardbot.wiki remains a reliable source of Metal Cardbot info, this wiki isn't open for direct contributions at this time. However, we're always open to suggestions and corrections! If you have something to add, [https://forms.gle/cAYv3CQWy4yfakws7 please use this form].

MediaWiki:Spam-whitelist

2026-04-15T06:30:53Z

Cabalex:

# <pre>
# External URLs matching this list will *not* be blocked even if they would
# have been blocked by block list entries.
#
# Syntax is as follows:
# * Everything from a "#" character to the end of the line is a comment
# * Every non-blank line is a regex fragment which will only match hosts inside URLs
forms.gle
#</pre>

MediaWiki:Spam-whitelist

2026-04-15T06:30:33Z

Cabalex:

# <pre>
# External URLs matching this list will *not* be blocked even if they would
# have been blocked by block list entries.
#
# Syntax is as follows:
# * Everything from a "#" character to the end of the line is a comment
# * Every non-blank line is a regex fragment which will only match hosts inside URLs
https:\/\/forms\.gle
#</pre>

File:Metal Cardbot W logo EN.png

2026-04-15T06:29:02Z

Cabalex:

== Licensing ==
{{Fairuse}}

File:Metal Cardbot W logo.png

2026-04-15T06:28:07Z

Cabalex:

== Licensing ==
{{Fairuse}}

File:Metal Cardbot S logo EN.png

2026-04-15T06:24:43Z

Cabalex:

== Licensing ==
{{Fairuse}}

File:Metal Cardbot S logo.png

2026-04-15T06:23:59Z

Cabalex:

== Licensing ==
{{Fairuse}}

Template:PortalButton

2026-04-15T06:22:39Z

Cabalex:

<span style="display: inline-block; position:absolute; height:2.4em; overflow:hidden; margin-top: 1px; margin-left: 1px;">[[{{{file|{{{File|{{{image|{{{icon|{{{3|File:Icon.png}}}}}}}}}}}}}}}|link={{{link|{{{page|{{{url|{{{2|Main Page}}}}}}}}}}}}|frameless|upright={{{upright|{{{scale|0.135}}}}}}]]</span>{{Template:Clickable button|{{{link|}}}|<span style{{=}}"display: inline-block; padding-left: {{{offset|0}}}">{{{text|{{{name|{{{title|{{{content|{{{1|Test button name}}}}}}}}}}}}}}}</span>|class=mw-ui-{{{class|button}}}}}

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

File:Metal Cardbot logo EN.png

2026-04-15T06:19:17Z

Cabalex: The English version of the Metal Cardbot logo.

== Summary ==
The English version of the Metal Cardbot logo.
== Licensing ==
{{Fairuse}}

MediaWiki:Licenses

2026-04-15T06:17:19Z

Cabalex: Created page with "- * Fair use: ** Fairuse|This will be used in a way that qualifies as fair use under US law * Own image: ** Self|I created this image myself. * Wikimedia: ** From Wikimedia|I got this from Wikipedia or another Wikimedia project * Free licenses: ** CC-BY-SA|This is licensed under the Creative Commons Attribution-Share Alike License ** Other free|This is licensed under another free license * Other ** PD|This is in the public domain ** Permission|This is copyrighted, but u..."

-
* Fair use:
** Fairuse|This will be used in a way that qualifies as fair use under US law
* Own image:
** Self|I created this image myself.
* Wikimedia:
** From Wikimedia|I got this from Wikipedia or another Wikimedia project
* Free licenses:
** CC-BY-SA|This is licensed under the Creative Commons Attribution-Share Alike License
** Other free|This is licensed under another free license
* Other
** PD|This is in the public domain
** Permission|This is copyrighted, but use is permitted by the copyright holder

File:Metal Cardbot logo.png

2026-04-15T06:15:53Z

Cabalex:

Template:PortalButton

2026-04-15T06:14:27Z

Cabalex: Created page with "<span style="display: inline-block; position:absolute; opacity:{{{opacity|0.3}}}; height:2.4em; overflow:hidden; margin-top: 1px; margin-left: 1px;">0.135}}}}}}</span>{{Template:Clickable button|{{{link|{{{page|{{{2|{{{utrl|Main Page}}}}}}}}}}}}|<span style{{=}}"display: inline-block; padding-left: {{{offset|0..."

<span style="display: inline-block; position:absolute; opacity:{{{opacity|0.3}}}; height:2.4em; overflow:hidden; margin-top: 1px; margin-left: 1px;">[[{{{file|{{{File|{{{image|{{{icon|{{{3|File:Icon.png}}}}}}}}}}}}}}}|link={{{link|{{{page|{{{url|{{{2|Main Page}}}}}}}}}}}}|frameless|upright={{{upright|{{{scale|0.135}}}}}}]]</span>{{Template:Clickable button|{{{link|{{{page|{{{2|{{{utrl|Main Page}}}}}}}}}}}}|<span style{{=}}"display: inline-block; padding-left: {{{offset|0}}}">{{{text|{{{name|{{{title|{{{content|{{{1|Test button name}}}}}}}}}}}}}}}</span>|class=mw-ui-{{{class|button}}}}}

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

Template:Clickable button

2026-04-15T06:13:18Z

Cabalex: Created page with "<span class="mw-ui-button {{#switch: {{{color|white}}} | red = mw-ui-destructive | green = mw-ui-progressive | white = | blue = mw-ui-progressive}}" role="button" aria-disabled="false">{{{text|{{{1|Button text}}}}}}</span><noinclude>{{Documentation}} </noinclude>"

<span class="mw-ui-button {{#switch: {{{color|white}}} | red = mw-ui-destructive | green = mw-ui-progressive | white = | blue = mw-ui-progressive}}" role="button" aria-disabled="false">{{{text|{{{1|Button text}}}}}}</span><noinclude>{{Documentation}}
</noinclude>

Main Page

2026-04-15T05:58:04Z

Cabalex:

{{DISPLAYTITLE:<span style="position: absolute; clip: rect(1px 1px 1px 1px); clip: rect(1px, 1px, 1px, 1px);">{{FULLPAGENAME}}</span>}}

'''Metal Cardbot''' is a 2023 Korean animated mecha series created by [[SAMG Entertainment]], directed by [[OSROCTION]] and animated by [[NAVY Co, Ltd.]]. A boy named [[Jun]] discovers the [[Metal Breath]], a mysterious device that allows him to capture and command a species of transforming robots known as [[Metal Cardbots]], who take refuge on [[Earth]] after their home planet [[Machina]] was destroyed.

Metal Cardbot currently has three main seasons ([[Metal Cardbot (series)|Metal Cardbot]], [[Metal Cardbot S]], [[Metal Cardbot W]]) and two Chinese spinoff seasons ([[Metal Cardbot: Beast Energy]], [[Metal Cardbot: Zerg Crisis]]). The first season has been dubbed in a variety of languages, including [[English localization|English]], [[Chinese localization|Chinese]], [[Russian localization|Russian]], [[Indonesian localization|Indonesian]], and [[Spanish localization|Spanish]]).

== Contributions ==
As this wiki is currently under construction, and we want to ensure cardbot.wiki remains a reliable source of Metal Cardbot info, this wiki isn't open for direct contributions at this time. However, we're always open to suggestions and corrections! If you have something to add, [https://forms.gle/cAYv3CQWy4yfakws7 please use this form].

Metal Cardbot (series)

2026-04-15T05:54:35Z

Cabalex: Created page with "{{Season }} {{about|the first season of Metal Cardbot}} '''Metal Cardbot''' is a 2023 animated mecha show produced by SAMG Entertainment in cooperation with Navy Co., Ltd. and OSROCTION. ==Episodes=="

{{Season }}

{{about|the first season of Metal Cardbot}}

'''Metal Cardbot''' is a 2023 animated mecha show produced by [[SAMG Entertainment]] in cooperation with [[Navy Co., Ltd.]] and [[OSROCTION]].

==Episodes==

Template:About

2026-04-15T05:54:22Z

Cabalex:

''This page is about {{{1}}}. {{#if:{{{2|}}}|For {{{2}}}, see {{{3}}}.|}} {{#if:{{{4|}}}|For {{{4}}}, see {{{5}}}.|}}''

Template:About

2026-04-15T05:53:51Z

Cabalex:

''This page is about {{{1}}}. {{#if:{{{2|}}}|For {{{2}}}, see {{{3}}}|}}. {{#if:{{{4|}}}|For {{{4}}}, see {{{5}}}|}}''

Template:About

2026-04-15T05:52:30Z

Cabalex: Created page with "''This page is about {{{1}}}. {{#if:{{{2}}}|For {{{2}}}, see {{{3}}}|}}. {{#if:{{{4}}}|For {{{4}}}, see {{{5}}}|}}''"

''This page is about {{{1}}}. {{#if:{{{2}}}|For {{{2}}}, see {{{3}}}|}}. {{#if:{{{4}}}|For {{{4}}}, see {{{5}}}|}}''

Template:TOC limit

2026-04-15T05:28:11Z

Cabalex: 1 revision imported

<templatestyles src="Template:TOC limit/styles.css" /><div class="toclimit-{{{1|{{{limit|3}}}}}}">__TOC__</div><noinclude>
{{documentation}}
</noinclude>

Template:Navbox

2026-04-15T05:28:11Z

Cabalex: 1 revision imported

<includeonly>{{#invoke:Navbox|navbox}}</includeonly><noinclude>
{{Documentation}}
</noinclude>

Template:Icon

2026-04-15T05:28:11Z

Cabalex: 1 revision imported

{{#invoke:Icon|main}}<noinclude>
{{documentation}}

</noinclude>

Template:Template other

2026-04-15T05:28:10Z

Cabalex: 1 revision imported

{{#switch:

{{#if:{{{demospace|}}}
| {{lc: {{{demospace}}} }} 
| {{#ifeq:{{NAMESPACE}}|{{ns:Template}}
| template
| other
}}
}}
| template = {{{1|}}}
| other
| #default = {{{2|}}}
}}<noinclude>

{{documentation}}

</noinclude>

Module:Template link general

2026-04-15T05:28:10Z

Cabalex: 1 revision imported

-- This implements Template:Template link general and various other templates in its family
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

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

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

local titlePart
if _ne(args.nolink) then
titlePart = textPart
else
titlePart = '[[' .. (titleObj ~= nil and titleObj.fullText or addTemplate(args['1'])) ..
'|' .. textPart .. ']]'
end
if _ne(args.braceinside) then
titlePart = nw('{') .. titlePart .. nw('}')
end
local bold = _ne(args.bold) or _ne(args.boldlink) or _ne(args.boldname)
if bold then
titlePart = "'''" .. titlePart .. "'''"
end
if _ne(args.nowrapname) then
titlePart = '<span class="nowrap">' .. titlePart .. '</span>'
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 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)
local expand = _ne(args._expand)

local titlePart = linkTitle(args)

-- Build the arguments
local textPart = ""
local textPartBuffer = "|"
local codeArguments = {}
local codeArgumentsString = ""
local i = 2
local j = 1
while args[i] do
local val = args[i]
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[j] = val
j = j + 1
else
codeArguments[k] = v
end
codeArgumentsString = codeArgumentsString .. textPartBuffer .. val
if italic then
val = '<span style="font-style:italic;">' .. val .. '</span>'
end
textPart = textPart .. textPartBuffer .. val
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('*') .. ' ' .. ret end
if _ne(args.kbd) then ret = '<kbd>' .. ret .. '</kbd>' end
if code then
ret = '<code>' .. ret .. '</code>'
elseif _ne(args.plaincode) then
ret = '<code style="border:none;background:transparent;color:inherit">' .. ret .. '</code>'
end
if _ne(args.nowrap) then ret = '<span class="nowrap">' .. ret .. '</span>' end

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

if show_result then
if _ne(args.nocat) then codeArguments['nocat'] = true end
local result = mw.getCurrentFrame():expandTemplate{title = addTemplate(args[1]), args = codeArguments}
ret = ret .. " → " .. result
end

if expand then
local query = mw.text.encode('{{' .. addTemplate(args[1]) .. string.gsub(codeArgumentsString, textPartBuffer, "|") .. '}}')
local url = mw.uri.fullUrl('special:ExpandTemplates', 'wpInput=' .. query)
mw.log()
ret = ret .. " [" .. tostring(url) .. "]"
end

return ret
end

return p

Template:Template link expanded

2026-04-15T05:28:07Z

Cabalex: 1 revision imported

{{#Invoke:Template link general|main|code=on}}<noinclude>
{{Documentation|1=Template:Tlg/doc
|content = {{tlg/doc|tlx}}
}}

</noinclude>

Template:Tlx

2026-04-15T05:28:06Z

Cabalex: 1 revision imported

#REDIRECT [[Template:Template link expanded]]

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

Module:TableTools

2026-04-15T05:28:05Z

Cabalex: 1 revision imported

------------------------------------------------------------------------------------
-- 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 >= 1 and floor(v) == v and v < 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
elseif not exists[v] then
ret[#ret + 1] = v
exists[v] = true
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 <= 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" < "string", so numbers will be sorted before strings.
local type1, type2 = type(item1), type(item2)
if type1 ~= type2 then
return type1 < type2
elseif type1 == 'table' or type1 == 'boolean' or type1 == 'function' then
return tostring(item1) < tostring(item2)
else
return item1 < 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"} ->
-- {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"} ->
-- {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)
if type(orig) ~= "table" then
return orig
end

-- already_seen stores copies of tables indexed by the original table.
local copy = already_seen[orig]
if copy ~= nil then
return copy
end

copy = {}
already_seen[orig] = copy -- memoize before any recursion, to avoid infinite loops

for orig_key, orig_value in pairs(orig) do
copy[_deepCopy(orig_key, includeMetatable, already_seen)] = _deepCopy(orig_value, includeMetatable, already_seen)
end

if includeMetatable then
local mt = getmetatable(orig)
if mt ~= nil then
setmetatable(copy, _deepCopy(mt, true, already_seen))
end
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 or {})
end

------------------------------------------------------------------------------------
-- sparseConcat
--
-- Concatenates all values in the table that are indexed by a number, in order.
-- sparseConcat{a, nil, c, d} => "acd"
-- sparseConcat{nil, b, c, d} => "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 searchElement is a member of the array, and false otherwise.
-- Equivalent to JavaScript array.includes(searchElement) or
-- array.includes(searchElement, fromIndex), except fromIndex is 1 indexed
------------------------------------------------------------------------------------
function p.inArray(array, searchElement, fromIndex)
checkType("inArray", 1, array, "table")
-- if searchElement is nil, error?

fromIndex = tonumber(fromIndex)
if fromIndex then
if (fromIndex < 0) then
fromIndex = #array + fromIndex + 1
end
if fromIndex < 1 then fromIndex = 1 end
for _, v in ipairs({unpack(array, fromIndex)}) do
if v == searchElement then
return true
end
end
else
for _, v in pairs(array) do
if v == searchElement then
return true
end
end
end
return false
end

------------------------------------------------------------------------------------
-- merge
--
-- Given the arrays, returns an array containing the elements of each input array
-- in sequence.
------------------------------------------------------------------------------------
function p.merge(...)
local arrays = {...}
local ret = {}
for i, arr in ipairs(arrays) do
checkType('merge', i, arr, 'table')
for _, v in ipairs(arr) do
ret[#ret + 1] = v
end
end
return ret
end

------------------------------------------------------------------------------------
-- extend
--
-- Extends the first array in place by appending all elements from the second
-- array.
------------------------------------------------------------------------------------
function p.extend(arr1, arr2)
checkType('extend', 1, arr1, 'table')
checkType('extend', 2, arr2, 'table')

for _, v in ipairs(arr2) do
arr1[#arr1 + 1] = v
end
end

return p

Module:List

2026-04-15T05:27:59Z

Cabalex: 1 revision imported

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 and TemplateStyles
data.classes = {}
data.templatestyles = ''
if listType == 'horizontal' or listType == 'horizontal_ordered' then
table.insert(data.classes, 'hlist')
data.templatestyles = mw.getCurrentFrame():extensionTag{
name = 'templatestyles', args = { src = 'Hlist/styles.css' }
}
elseif listType == 'unbulleted' then
table.insert(data.classes, 'plainlist')
data.templatestyles = mw.getCurrentFrame():extensionTag{
name = 'templatestyles', args = { src = 'Plainlist/styles.css' }
}
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 > 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 _, 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 < 1 then
return ''
end

-- Render the main div tag.
local root = mw.html.create('div')
for _, 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 _, 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 data.templatestyles .. 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:Pages using module:list 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, {
frameOnly = ((frame and frame.args and frame.args.frameonly or '') ~= ''),
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

Module:String

2026-04-15T05:27:55Z

Cabalex: 1 revision imported

--[[

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 first index of the substring to return, defaults to 1.
j: The last index of the string to return, defaults to the last character.

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

If the requested indices are out of range for the given string, an error is
reported.
]]
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 < 0 then
i = len + i + 1
end
if j < 0 then
j = len + j + 1
end

if i > len or j > len or i < 1 or j < 1 then
return str._error( 'String subset index out of range' )
end
if j < 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) < 1 or math.abs(start) > 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 > 1 then
s = mw.ustring.sub( s, start )
end

local iterator = mw.ustring.gmatch(s, pattern)
if match_index > 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) > 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 >= "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 = string.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

-- findpagetext returns the position of a piece of text in a page
-- First positional parameter or |text is the search text
-- Optional parameter |title is the page title, defaults to current page
-- Optional parameter |plain is either true for plain search (default) or false for Lua pattern search
-- Optional parameter |nomatch is the return value when no match is found; default is nil
function str._findpagetext(args)
-- process parameters
local nomatch = args.nomatch or ""
if nomatch == "" then nomatch = nil end
--
local text = mw.text.trim(args[1] or args.text or "")
if text == "" then return nil end
--
local title = args.title or ""
local titleobj
if title == "" then
titleobj = mw.title.getCurrentTitle()
else
titleobj = mw.title.new(title)
end
--
local plain = args.plain or ""
if plain:sub(1, 1) == "f" then plain = false else plain = true end
-- get the page content and look for 'text' - return position or nomatch
local content = titleobj and titleobj:getContent()
return content and mw.ustring.find(content, text, 1, plain) or nomatch
end
function str.findpagetext(frame)
local args = frame.args
local pargs = frame:getParent().args
for k, v in pairs(pargs) do
args[k] = v
end
if not (args[1] or args.text) then return nil end
-- just the first value
return (str._findpagetext(args))
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 = '<strong class="error">String Module Error: ' .. error_str .. '</strong>'
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 ( string.gsub( pattern_str, "[%(%)%.%%%+%-%*%?%[%^%$%]]", "%%%0" ) )
end

return str

Module:Check for unknown parameters

2026-04-15T05:27:51Z

Cabalex: 1 revision imported

-- This module may be used to compare the arguments passed to the parent
-- with a list of arguments, returning a specified result if an argument is
-- not on the list

require ('strict');

local p = {}

local mapframe_params = {
'coord',
'coordinates',
'id',
'qid',
'mapframe',
'mapframe-area_km2',
'mapframe-area_mi2',
'mapframe-caption',
'mapframe-coord',
'mapframe-coordinates',
'mapframe-custom',
'mapframe-frame-coord',
'mapframe-frame-coordinates',
'mapframe-frame-height',
'mapframe-frame-width',
'mapframe-geomask',
'mapframe-geomask-fill',
'mapframe-geomask-fill-opacity',
'mapframe-geomask-stroke-color',
'mapframe-geomask-stroke-colour',
'mapframe-geomask-stroke-width',
'mapframe-height',
'mapframe-id',
'mapframe-length_km',
'mapframe-length_mi',
'mapframe-line',
'mapframe-line-stroke-color',
'mapframe-line-stroke-colour',
'mapframe-marker',
'mapframe-marker-color',
'mapframe-marker-colour',
'mapframe-point',
'mapframe-population',
'mapframe-shape',
'mapframe-shape-fill',
'mapframe-shape-fill-opacity',
'mapframe-shape-stroke-color',
'mapframe-shape-stroke-colour',
'mapframe-stroke-color',
'mapframe-stroke-colour',
'mapframe-stroke-width',
'mapframe-switcher',
'mapframe-type',
'mapframe-width',
'mapframe-wikidata',
'mapframe-zoom'
}

local function trim(s)
return s:match('^%s*(.-)%s*$')
end

local function isnotempty(s)
return s and s:match('%S')
end

local function clean(text)
-- Return text cleaned for display and truncated if too long.
-- Strip markers are replaced with dummy text representing the original wikitext.
local pos, truncated
local function truncate(text)
if truncated then
return ''
end
if mw.ustring.len(text) > 25 then
truncated = true
text = mw.ustring.sub(text, 1, 25) .. '...'
end
return mw.text.nowiki(text)
end
local parts = {}
for before, tag, remainder in text:gmatch('([^\127]*)\127[^\127]*%-(%l+)%-[^\127]*\127()') do
pos = remainder
table.insert(parts, truncate(before) .. '<' .. tag .. '>...</' .. tag .. '>')
end
table.insert(parts, truncate(text:sub(pos or 1)))
return table.concat(parts)
end

function p._check(args, pargs)
if type(args) ~= "table" or type(pargs) ~= "table" then
-- TODO: error handling
return
end

-- create the list of known args, regular expressions, and the return string
local knownargs = {}

if isnotempty(args['mapframe_args']) then
for _, v in ipairs(mapframe_params) do
knownargs[v] = 1
end
end

local regexps = {}
for k, v in pairs(args) do
if type(k) == 'number' then
v = trim(v)
knownargs[v] = 1
elseif k:find('^regexp[1-9][0-9]*$') then
table.insert(regexps, '^' .. v .. '$')
end
end

-- loop over the parent args, and make sure they are on the list
local ignoreblank = isnotempty(args['ignoreblank'])
local showblankpos = isnotempty(args['showblankpositional'])
local values = {}
for k, v in pairs(pargs) do
if type(k) == 'string' and knownargs[k] == nil then
local knownflag = false
for _, regexp in ipairs(regexps) do
if mw.ustring.match(k, regexp) then
knownflag = true
break
end
end
if not knownflag and ( not ignoreblank or isnotempty(v) ) then
table.insert(values, clean(k))
end
elseif type(k) == 'number' and knownargs[tostring(k)] == nil then
local knownflag = false
for _, regexp in ipairs(regexps) do
if mw.ustring.match(tostring(k), regexp) then
knownflag = true
break
end
end
if not knownflag and ( showblankpos or isnotempty(v) ) then
table.insert(values, k .. ' = ' .. clean(v))
end
end
end

-- add results to the output tables
local res = {}
if #values > 0 then
local unknown_text = args['unknown'] or 'Found _VALUE_, '

if mw.getCurrentFrame():preprocess( "{{REVISIONID}}" ) == "" then
local preview_text = args['preview']
if isnotempty(preview_text) then
preview_text = require('Module:If preview')._warning({preview_text})
elseif preview_text == nil then
preview_text = unknown_text
end
unknown_text = preview_text
end
for _, v in pairs(values) do
-- Fix odd bug for | = which gets stripped to the empty string and
-- breaks category links
if v == '' then v = ' ' end

-- avoid error with v = 'example%2' ("invalid capture index")
local r = unknown_text:gsub('_VALUE_', {_VALUE_ = v})
table.insert(res, r)
end
end

return table.concat(res)
end

function p.check(frame)
local args = frame.args
local pargs = frame:getParent().args
return p._check(args, pargs)
end

return p

Template:Main other

2026-04-15T05:27:48Z

Cabalex: 1 revision imported

{{safesubst:<noinclude/>#switch:
<noinclude></noinclude>
{{safesubst:<noinclude/>#if:{{{demospace|}}}
| {{safesubst:<noinclude/>lc: {{{demospace}}} }} <noinclude></noinclude>
| {{safesubst:<noinclude/>#ifeq:{{safesubst:<noinclude/>NAMESPACE}}|{{safesubst:<noinclude/>ns:0}}
| main
| other
}}
}}
| main = {{{1|}}}
| other
| #default = {{{2|}}}
}}<noinclude>

{{documentation}}

</noinclude>

Template:Yesno

2026-04-15T05:27:48Z

Cabalex: 1 revision imported

{{<includeonly>safesubst:</includeonly>#switch: {{<includeonly>safesubst:</includeonly>lc: {{{1|¬}}} }}
|no
|n
|f
|false
|off
|0 = {{{no|}}}
| = {{{blank|{{{no|}}}}}}
|¬ = {{{¬|}}}
|yes
|y
|t
|true
|on
|1 = {{{yes|yes}}}
|#default = {{{def|{{{yes|yes}}}}}}
}}<noinclude>
{{Documentation}}
</noinclude>

Module:Unsubst

2026-04-15T05:27:47Z

Cabalex: 1 revision imported

local checkType = require('libraryUtil').checkType

local p = {}

local BODY_PARAM = '$B'

local specialParams = {
['$params'] = 'parameter list',
['$aliases'] = 'parameter aliases',
['$flags'] = 'flags',
['$B'] = 'template content',
['$template-name'] = 'template invocation name override',
}

function p.main(frame, body)
-- If we are substing, this function returns a template invocation, and if
-- not, it returns the template body. The template body can be specified in
-- the body parameter, or in the template parameter defined in the
-- BODY_PARAM variable. This function can be called from Lua or from
-- #invoke.

-- Return the template body if we aren't substing.
if not mw.isSubsting() then
if body ~= nil then
return body
elseif frame.args[BODY_PARAM] ~= nil then
return frame.args[BODY_PARAM]
else
error(string.format(
"no template content specified (use parameter '%s' from #invoke)",
BODY_PARAM
), 2)
end
end

-- Sanity check for the frame object.
if type(frame) ~= 'table'
or type(frame.getParent) ~= 'function'
or not frame:getParent()
then
error(
"argument #1 to 'main' must be a frame object with a parent " ..
"frame available",
2
)
end

-- Find the invocation name.
local mTemplateInvocation = require('Module:Template invocation')
local name

if frame.args['$template-name'] and '' ~= frame.args['$template-name'] then
name = frame.args['$template-name'] -- override whatever the template name is with this name
else
name = mTemplateInvocation.name(frame:getParent():getTitle())
end

-- Combine passed args with passed defaults
local args = {}
if string.find( ','..(frame.args['$flags'] or '')..',', ',%s*override%s*,' ) then
for k, v in pairs( frame:getParent().args ) do
args[k] = v
end
for k, v in pairs( frame.args ) do
if not specialParams[k] then
if v == '__DATE__' then
v = mw.getContentLanguage():formatDate( 'F Y' )
end
args[k] = v
end
end
else
for k, v in pairs( frame.args ) do
if not specialParams[k] then
if v == '__DATE__' then
v = mw.getContentLanguage():formatDate( 'F Y' )
end
args[k] = v
end
end
for k, v in pairs( frame:getParent().args ) do
args[k] = v
end
end

-- Trim parameters, if not specified otherwise
if not string.find( ','..(frame.args['$flags'] or '')..',', ',%s*keep%-whitespace%s*,' ) then
for k, v in pairs( args ) do args[k] = mw.ustring.match(v, '^%s*(.*)%s*$') or '' end
end

-- Pull information from parameter aliases
local aliases = {}
if frame.args['$aliases'] then
local list = mw.text.split( frame.args['$aliases'], '%s*,%s*' )
for k, v in ipairs( list ) do
local tmp = mw.text.split( v, '%s*>%s*' )
aliases[tonumber(mw.ustring.match(tmp[1], '^[1-9][0-9]*$')) or tmp[1]] = ((tonumber(mw.ustring.match(tmp[2], '^[1-9][0-9]*$'))) or tmp[2])
end
end
for k, v in pairs( aliases ) do
if args[k] and ( not args[v] or args[v] == '' ) then
args[v] = args[k]
end
args[k] = nil
end

-- Remove empty parameters, if specified
if string.find( ','..(frame.args['$flags'] or '')..',', ',%s*remove%-empty%s*,' ) then
local tmp = 0
for k, v in ipairs( args ) do
if v ~= '' or ( args[k+1] and args[k+1] ~= '' ) or ( args[k+2] and args[k+2] ~= '' ) then
tmp = k
else
break
end
end
for k, v in pairs( args ) do
if v == '' then
if not (type(k) == 'number' and k < tmp) then args[k] = nil end
end
end
end

-- Order parameters
if frame.args['$params'] then
local params, tmp = mw.text.split( frame.args['$params'], '%s*,%s*' ), {}
for k, v in ipairs(params) do
v = tonumber(mw.ustring.match(v, '^[1-9][0-9]*$')) or v
if args[v] then tmp[v], args[v] = args[v], nil end
end
for k, v in pairs(args) do tmp[k], args[k] = args[k], nil end
args = tmp
end

return mTemplateInvocation.invocation(name, args)
end

p[''] = p.main -- For backwards compatibility

return p

Template:Ifsubst

2026-04-15T05:27:44Z

Cabalex: 1 revision imported

{{ safesubst:<noinclude/>#if:{{{demo|}}}
|{{ safesubst:<noinclude/>#ifeq:{{{demo}}} |no
|{{{no|{{{2|}}}}}}
|{{{yes|{{{1|}}}}}}
}}
|{{ safesubst:<noinclude/>#ifeq:{{ safesubst:<noinclude/>NAMESPACE}}|{{NAMESPACE}}
|{{{no|{{{2|}}}}}}
|{{{yes|{{{1|}}}}}}
}}}}<noinclude>
{{Documentation}}
</noinclude>

Module:Redirect

2026-04-15T05:27:43Z

Cabalex: 1 revision imported

-- This module provides functions for getting the target of a redirect page.

local p = {}

-- Gets a mw.title object, using pcall to avoid generating script errors if we
-- are over the expensive function count limit (among other possible causes).
local function getTitle(...)
local success, titleObj = pcall(mw.title.new, ...)
if success then
return titleObj
else
return nil
end
end

-- Gets the name of a page that a redirect leads to, or nil if it isn't a
-- redirect.
function p.getTargetFromText(text)
local target = string.match(
text,
"^%s*#[Rr][Ee][Dd][Ii][Rr][Ee][Cc][Tt]%s*:?%s*%[%[([^%[%]|]-)%]%]"
) or string.match(
text,
"^%s*#[Rr][Ee][Dd][Ii][Rr][Ee][Cc][Tt]%s*:?%s*%[%[([^%[%]|]-)|[^%[%]]-%]%]"
)
return target and mw.uri.decode(target, 'PATH')
end

-- Gets the target of a redirect. If the page specified is not a redirect,
-- returns nil.
function p.getTarget(page, fulltext)
-- Get the title object. Both page names and title objects are allowed
-- as input.
local titleObj
if type(page) == 'string' or type(page) == 'number' then
titleObj = getTitle(page)
elseif type(page) == 'table' and type(page.getContent) == 'function' then
titleObj = page
else
error(string.format(
"bad argument #1 to 'getTarget'"
.. " (string, number, or title object expected, got %s)",
type(page)
), 2)
end
if not titleObj then
return nil
end
local targetTitle = titleObj.redirectTarget
if targetTitle then
if fulltext then
return targetTitle.fullText
else
return targetTitle.prefixedText
end
else
return nil
end
end

--[[
-- Given a single page name determines what page it redirects to and returns the
-- target page name, or the passed page name when not a redirect. The passed
-- page name can be given as plain text or as a page link.
--
-- Returns page name as plain text, or when the bracket parameter is given, as a
-- page link. Returns an error message when page does not exist or the redirect
-- target cannot be determined for some reason.
--]]
function p.luaMain(rname, bracket, fulltext)
if type(rname) ~= "string" or not rname:find("%S") then
return nil
end
bracket = bracket and "[[%s]]" or "%s"
rname = rname:match("%[%[(.+)%]%]") or rname
local target = p.getTarget(rname, fulltext)
local ret = target or rname
ret = getTitle(ret)
if ret then
if fulltext then
ret = ret.fullText
else
ret = ret.prefixedText
end
return bracket:format(ret)
else
return nil
end
end

-- Provides access to the luaMain function from wikitext.
function p.main(frame)
local args = require('Module:Arguments').getArgs(frame, {frameOnly = true})
return p.luaMain(args[1], args.bracket, args.fulltext) or ''
end

-- Returns true if the specified page is a redirect, and false otherwise.
function p.luaIsRedirect(page)
local titleObj = getTitle(page)
if not titleObj then
return false
end
if titleObj.isRedirect then
return true
else
return false
end
end

-- Provides access to the luaIsRedirect function from wikitext, returning 'yes'
-- if the specified page is a redirect, and the blank string otherwise.
function p.isRedirect(frame)
local args = require('Module:Arguments').getArgs(frame, {frameOnly = true})
if p.luaIsRedirect(args[1]) then
return 'yes'
else
return ''
end
end

return p