Module:Languages

Lua

Code Discussion Edit History Links Link count Subpages:Documentation Tests Results Sandbox Live code All modules

This module is rated as ready for general use. It has reached a mature form and is thought to be bug-free and ready for use wherever appropriate. To reduce server load and bad output, it should be improved by sandbox testing rather than repeated trial-and-error editing.

Supported languages (mappings in "MediaWiki:Lang/code" for {{int:lang}}, and their current native names)

(sma) åarjelsaemien
(ace) Acèh
(ang) Ænglisc
(af) Afrikaans
(ak) Akan
(agq) Aghem
(gsw) Alemannisch
(als) Alemannisch
(en-us) American English
(smn) anarâškielâ
(ase) American sign language
(an) aragonés
(aae) Arbërisht
(rup) armãneashti
(roa-rup) armãneashti
(frp) arpetan
(ast) asturianu
(atj) Atikamekw
(gn) Avañe'ẽ
(ay) Aymar aru
(az) azərbaycanca
(ksf) Bafia
(bfd) Bafut
(abs) bahasa ambon
(gor) Bahasa Hulontalo
(id) Bahasa Indonesia
(ms) Bahasa Melayu
(bdr) Bajau Sama
(bkc) Baka
(bkh) Bakoko
(bm) bamanankan
(bax) Bamum
(zh-min-nan) 閩南語 / Bân-lâm-gú
(nan-latn-pehoeji) Bân-lâm-gú (Pe̍h-ōe-jī)
(bjn) Banjar
(nan-latn-tailo) Bân-lâm-gú (Tâi-lô)
(ban) Basa Bali
(map-bms) Basa Banyumasan
(bug) Basa Ugi
(mui) Baso Palembang
(bas) Basaa
(btm) Batak Mandailing
(bbc) Batak Toba
(bbc-latn) Batak Toba
(bew) Betawi
(sje) bidumsámegiella
(bcl) Bikol Central
(bi) Bislama
(bar) Boarisch
(bs) bosanski
(brh) Bráhuí
(br) brezhoneg
(en-gb) British English
(en-ca) Canadian English
(cps) Capiceño
(⧼lang/cal⧽) Carolinian
(ca) català
(ceb) Cebuano
(cs) čeština
(cho) Chahta anumpa
(cbk-zam) Chavacano de Zamboanga
(ch) Chamoru
(ny) Chi-Chewa
(chn) chinuk wawa
(sn) chiShona
(tum) chiTumbuka
(lua) ciluba
(sei) Cmique Itom
(co) corsu
(cy) Cymraeg
(dga) Dagaare
(dag) dagbanli
(da) dansk
(se) davvisámegiella
(se-no) davvisámegiella (Norgga bealde)
(se-se) davvisámegiella (Ruoŧa bealde)
(se-fi) davvisámegiella (Suoma bealde)
(pdc) Deitsch
(de) Deutsch
(de-formal) Deutsch (Sie-Form)
(nv) Diné bizaad
(dsb) dolnoserbski
(na) Dorerin Naoero
(dua) Duala
(mh) Ebon
(et) eesti
(efi) Efịk
(etu) Ejagham
(vmw) emakhuwa
(eml) emiliàn e rumagnòl
(egl) emiliàn e rumagnòl
(en) English
(es) español
(es-formal) español (formal)
(es-419) español de América Latina
(eo) Esperanto
(ext) estremeñu
(eto) Eton
(eu) euskara
(ee) eʋegbe
(ewo) Ewondo
(wls) Fakaʻuvea
(gur) farefare
(fmp) Fe'fe'
(hif) Fiji Hindi
(hif-latn) Fiji Hindi
(fon) fɔ̀ngbè
(fr) français
(fo) føroyskt
(frc) français cadien
(fy) Frysk
(ff) Fulfulde
(fur) furlan
(gaa) Ga
(ga) Gaeilge
(gv) Gaelg
(sm) Gagana Samoa
(gag) Gagauz
(gd) Gàidhlig
(gl) galego
(gya) Gbaya
(aln) Gegë
(gpe) Ghanaian Pidgin
(bbj) Ghomála'
(ki) Gĩkũyũ
(gom-latn) Gõychi Konknni
(guw) gungbe
(hak-latn) Hak-kâ-ngî (Pha̍k-fa-sṳ)
(cnh) Hakha Chin
(ha) Hausa
(haw) Hawaiʻi
(ho) Hiri Motu
(hsb) hornjoserbsce
(hrx) Hunsrik
(hr) hrvatski
(ibb) ibibio
(io) Ido
(igl) Igala
(ig) Igbo
(rw) Ikinyarwanda
(rn) ikirundi
(ilo) Ilokano
(hil) Ilonggo
(ia) interlingua
(ie) Interlingue
(ike-latn) inuktitut
(ik) Iñupiatun
(bto) Iriga Bicolano
(nr) isiNdebele seSewula
(xh) isiXhosa
(it) italiano
(zu) isiZulu
(is) íslenska
(isu) Isu
(iba) Jaku Iban
(jv) Jawa
(smj) julevsámegiella
(jut) jysk
(rmf) kaalengo tšimb
(kbp) Kabɩyɛ
(kl) kalaallisut
(kea) kabuverdianu
(dtp) Kadazandusun
(kr) kanuri
(pam) Kapampangan
(cak) Kaqchikel
(krl) karjal
(kai) Karai-karai
(csb) kaszëbsczi
(ker) Kera
(kw) kernowek
(hke) kihunde
(krj) Kinaray-a
(kiu) Kırmancki
(sw) Kiswahili
(kg) Kongo
(bkm) Kom
(avk) Kotava
(ses) Koyraboro Senni
(ht) Kreyòl ayisyen
(gcf) kréyòl Gwadloup
(kri) Krio
(gcr) kriyòl gwiyannen
(kge) Kumoring
(ku) kurdî
(ku-latn) kurdî (latînî)
(kus) Kʋsaal
(fkv) kvääni
(kj) Kwanyama
(nmg) Kwasio
(acf) Kwéyòl Sent Lisi
(jbo) la .lojban.
(lad) Ladino
(lld) Ladin
(lns) Lamnso'
(⧼lang/ljp⧽) Lampung Api
(ltg) latgaļu
(la) Latina
(lv) latviešu
(lzz) Lazuri
(to) lea faka-Tonga
(lb) Lëtzebuergesch
(nia) Li Niha
(lt) lietuvių
(lij) Ligure
(li) Limburgs
(ln) lingála
(lfn) Lingua Franca Nova
(liv) Līvõ kēļ
(olo) livvinkarjala
(lmo) lombard
(mad) Madhurâ
(lg) Luganda
(hu) magyar
(hu-formal) magyar (formal)
(vmf) Mainfränkisch
(mcp) Maka
(mg) Malagasy
(mt) Malti
(mnc) manju gisun
(mnc-latn) manju gisun
(mi) Māori
(arn) mapudungun
(mrh) Mara
(srq) mbia cheë
(fit) meänkieli
(byv) Medumba
(isv-latn) medžuslovjansky
(fat) mfantse
(min) Minangkabau
(cdo-latn) Mìng-dĕ̤ng-ngṳ̄ (Bàng-uâ-cê)
(mwl) Mirandés
(lus) Mizo ţawng
(bqz) Mka'a
(mos) moore
(mus) Mvskoke
(mua) Mundang
(fj) Na Vosa Vakaviti
(nah) Nāhuatl
(pcm) Naijá
(nap) Napulitano
(nmz) nawdm
(nnz) Nda'nda'
(nl) Nederlands
(nl-informal) Nederlands (informeel)
(nds-nl) Nedersaksies
(cr) Nēhiyawēwin / ᓀᐦᐃᔭᐍᐏᐣ
(nge) Ngémba
(nnh) Ngiemboon
(nla) Ngombala
(yrl) Nhẽẽgatú
(niu) Niuē
(lem) Nomaande
(frr) Nordfriisk
(pih) Norfuk / Pitkern
(nb) norsk
(nb) norsk bokmål
(nn) norsk nynorsk
(nrm) Nouormand
(nov) Novial
(yas) Nugunu
(sms) nuõrttsääʹmǩiõll
(nup) Nupe
(nys) Nyunga
(uz-latn) oʻzbekcha
(uz) oʻzbekcha / ўзбекча
(ann) Obolo
(oc) occitan
(ojb) Ojibwemowin
(om) Oromoo
(nyo) Orunyoro
(de-at) Österreichisches Deutsch
(ttj) Orutooro
(ng) Oshiwambo
(hz) Otsiherero
(pfl) Pälzisch
(pag) Pangasinan
(ami) Pangcah
(pap-aw) Papiamento
(pap) Papiamentu
(jam) Patois
(pcd) Picard
(wes) Pidgin (Cameroon)
(pwn) pinayuanan
(pms) Piemontèis
(nds) Plattdüütsch
(pdt) Plautdietsch
(cpx-latn) Pó-sing-gṳ̂ (Báⁿ-uā-ci̍)
(pl) polski
(⧼lang/fvr⧽) poor’íŋ belé’ŋ
(pt) português
(pt-br) português do Brasil
(prg) prūsiskan
(aa) Qafár af
(kaa) Qaraqalpaqsha
(quc) Qatzijob\ʼal
(kk-latn) qazaqşa (latın)
(kk-tr) qazaqşa (Türkïya)
(crh) qırımtatarca
(crh-latn) qırımtatarca (Latin)
(ty) reo tahiti
(ro) română
(ksh) Ripoarisch
(rmc) romaňi čhib
(rmy) romani čhib
(rgn) Rumagnôl
(qu) Runa Simi
(rm) rumantsch
(qug) Runa shimi
(nyn) runyankore
(xsy) saisiyat
(szy) Sakizaya
(sg) Sängö
(sc) sardu
(sro) sardu campidanesu
(sdc) Sassaresu
(sli) Schläsch
(de-ch) Schweizer Hochdeutsch
(sco) Scots
(trv) Seediq
(stq) Seeltersk
(st) Sesotho
(nso) Sesotho sa Leboa
(tn) Setswana
(sq) shqip
(scn) sicilianu
(ss) SiSwati
(loz) Silozi
(simple) Simple English
(sk) slovenčina
(sl) slovenščina
(szl) ślůnski
(so) Soomaaliga
(srn) Sranantongo
(sr-el) srpski (latinica)
(sh) srpskohrvatski / српскохрватски
(sh-latn) srpskohrvatski (latinica)
(su) Sunda
(fi) suomi
(sv) svenska
(shy) tacawit
(shy-latn) tacawit
(shi) Taclḥit
(shi-latn) Taclḥit
(tl) Tagalog
(zgh-latn) tamaziɣt tanawayt
(⧼lang/tpv⧽) Tanapag
(kab) Taqbaylit
(roa-tara) tarandíne
(rif) Tarifit
(tt-latn) tatarça
(crh-ro) tatarşa
(tay) Tayal
(tet) tetun
(din) Thuɔŋjäŋ
(vi) Tiếng Việt
(tg-latn) tojikī
(tpi) Tok Pisin
(tok) toki pona
(tly) tolışi
(chy) Tsetsêhestâhese
(ve) Tshivenda
(bag) Tuki
(tvu) Tunen
(aeb-latn) Tûnsî
(tr) Türkçe
(tk) Türkmençe
(tru) Ṫuroyo
(tw) Twi
(kcg) Tyap
(sju) ubmejesámiengiälla
(ug-latn) Uyghurche
(vot) Vaďďa
(za) Vahcuengh
(vec) vèneto
(vep) vepsän kel’
(ruq) Vlăheşte
(ruq-latn) Vlăheşte
(vo) Volapük
(vro) võro
(fiu-vro) võro
(mcn) vùn màsànà
(vut) Vute
(⧼lang/wlx⧽) waale
(wa) walon
(bci) wawle
(guc) wayuunaiki
(osa-latn) Wažáže íe
(vls) West-Vlams
(wal) wolaytta
(war) Winaray
(wo) Wolof
(wya) Wyandot
(ts) Xitsonga
(yat) Yambeta
(yav) Yangben
(ybb) Yemba
(knc) Yerwa Kanuri
(yo) Yorùbá
(diq) Zazaki
(zea) Zeêuws
(sgs) žemaitėška
(bat-smg) žemaitėška
(grc) Ἀρχαία ἑλληνικὴ
(el) Ελληνικά
(pnt) Ποντιακά
(cop) ϯⲙⲉⲧⲣⲉⲙⲛ̀ⲭⲏⲙⲓ
(av) авар
(ady-cyrl) адыгабзэ
(ady) адыгабзэ
(kbd) адыгэбзэ
(kbd-cyrl) адыгэбзэ
(alt) алтай тил
(ab) аԥсшәа
(ba) башҡортса
(be) беларуская
(be-tarask) беларуская (тарашкевіца)
(bg) български
(be-x-old) беларуская (тарашкевіца)
(bxr) буряад
(ruq-cyrl) Влахесте
(inh) гӀалгӀай
(os) ирон
(krc) къарачай-малкъар
(sjd) кӣллт са̄мь кӣлл
(kv) коми
(kum) къумукъ
(crh-cyrl) къырымтатарджа (Кирилл)
(ky) кыргызча
(mrj) кырык мары
(kk) қазақша
(kk-cyrl) қазақша (кирил)
(kk-kz) қазақша (Қазақстан)
(lbe) лакку
(lez) лезги
(mk) македонски
(isv-cyrl) меджусловјанскы
(mdf) мокшень
(mo) молдовеняскэ
(mn) монгол
(rut) мыхаӀбишды
(gld) на̄ни
(nog) ногайша
(ce) нохчийн
(mhr) олык марий
(koi) перем коми
(rue) русиньскый
(rsk) руски
(ru) русский
(sah) саха тыла
(sty) себертатар
(cu) словѣньскъ / ⰔⰎⰑⰂⰡⰐⰠⰔⰍⰟ
(sr-ec) српски (ћирилица)
(sr) српски / srpski
(sh-cyrl) српскохрватски (ћирилица)
(tt-cyrl) татарча
(tt) татарча / tatarça
(tly-cyrl) толыши
(tg-cyrl) тоҷикӣ
(tyv) тыва дыл
(tg) тоҷикӣ
(udm) удмурт
(uz-cyrl) ўзбекча
(uk) українська
(kjh) хакас
(xal) хальмг
(cv) чӑвашла
(myv) эрзянь
(xmf) მარგალური
(ka) ქართული
(hyw) Արեւմտահայերէն
(⧼lang/hoc⧽) 𑢹𑣉𑣉 𑣎𑣋𑣜
(hy) հայերեն
(anp) अंगिका
(awa) अवधी
(⧼lang/thq⧽) काेचिला थारु
(ks-deva) कॉशुर
(ks) कॉशुर / کٲشُر
(⧼lang/gju-deva⧽) गुज्जरी
(⧼lang/kgg⧽) गेम्येहाक़ गिपन
(gom-deva) गोंयची कोंकणी
(gom) गोंयची कोंकणी / Gõychi Konknni
(new) नेपाल भाषा
(dty) डोटेली
(ne) नेपाली
(pi) पालि
(bho) भोजपुरी
(bh) भोजपुरी
(mag) मगही
(mr) मराठी
(sa) संस्कृतम्
(rwr) मारवाड़ी
(mai) मैथिली
(bgc) हरियाणवी
(hi) हिन्दी
(as) অসমীয়া
(bn) বাংলা
(bpy) বিষ্ণুপ্রিয়া মণিপুরী
(pa) ਪੰਜਾਬੀ
(syl) ꠍꠤꠟꠐꠤ
(gu) ગુજરાતી
(or) ଓଡ଼ିଆ
(⧼lang/dso⧽) ଦେଶିଆ
(⧼lang/bfw⧽) ରେମସାମ୍
(ta) தமிழ்
(nit) కొలామి
(te) తెలుగు
(kn) ಕನ್ನಡ
(tcy) ತುಳು
(ml) മലയാളം
(si) සිංහල
(dz) ཇོང་ཁ
(bo) བོད་ཡིག
(mni) ꯃꯤꯇꯩ ꯂꯣꯟ
(ksw) စှီၤ
(blk) ပအိုဝ်ႏဘာႏသာႏ
(kjp) ဖၠုံလိက်
(shn) တႆး
(mnw) ဘာသာမန်
(my) မြန်မာဘာသာ
(rki) ရခိုင်
(ccp) 𑄌𑄋𑄴𑄟𑄳𑄦
(km) ភាសាខ្មែរ
(lo) ລາວ
(tdd) ᥖᥭᥰ ᥖᥬᥲ ᥑᥨᥒᥰ
(nod) ᨣᩤᩴᨾᩮᩬᩥᨦ
(th) ไทย
(ban-bali) ᬩᬲᬩᬮᬶ
(sat) ᱥᱟᱱᱛᱟᱲᱤ
(got) 𐌲𐌿𐍄𐌹𐍃𐌺
(chr) ᏣᎳᎩ
(ike-cans) ᐃᓄᒃᑎᑐᑦ
(iu) ᐃᓄᒃᑎᑐᑦ / inuktitut
(tzm) ⵜⴰⵎⴰⵣⵉⵖⵜ
(zgh) ⵜⴰⵎⴰⵣⵉⵖⵜ ⵜⴰⵏⴰⵡⴰⵢⵜ
(shi-tfng) ⵜⴰⵛⵍⵃⵉⵜ
(tig) ትግሬ
(ti) ትግርኛ
(am) አማርኛ
(ii) ꆇꉙ
(ko-kp) 조선말
(ko) 한국어
(ja) 日本語
(ryu) 沖縄口
(zh) 中文
(zh-cn) 中文（中国大陆）
(zh-sg) 中文（新加坡）
(zh-hans) 中文（简体）
(zh-mo) 中文（澳門）
(zh-hant) 中文（繁體）
(zh-tw) 中文（臺灣）
(zh-hk) 中文（香港）
(wuu-hant) 吳語（正體）
(zh-my) 中文（马来西亚）
(wuu) 吴语
(wuu-hans) 吴语（简体）
(hak) 客家語 / Hak-kâ-ngî
(hak-hans) 客家语（简体）
(hak-hant) 客家語（繁體）
(lzh) 文言
(zh-classical) 文言
(hsn) 湘語
(yue) 粵語
(zh-yue) 粵語
(yue-hant) 粵語（繁體）
(yue-hans) 粵语（简体）
(cpx) 莆仙語 / Pó-sing-gṳ̂
(cpx-hant) 莆仙語（繁體）
(cpx-hans) 莆仙语（简体）
(gan) 贛語
(gan-hant) 贛語（繁體）
(gan-hans) 赣语（简体）
(nan-hani) 閩南語
(nan) 閩南語 / Bân-lâm-gú
(nan-hant) 閩南語（傳統漢字）
(cdo) 閩東語 / Mìng-dĕ̤ng-ngṳ̄
(cdo-hant) 閩東語（傳統漢字）
(mnc-mong) ᠮᠠᠨᠵᡠ ᡤᡳᠰᡠᠨ
(yi) ייִדיש
(he) עברית
(ug-arab) ئۇيغۇرچە
(ug) ئۇيغۇرچە / Uyghurche
(ur) اردو
(ary) الدارجة
(ar) العربية
(bqi) بختیاری
(ms-arab) بهاس ملايو
(ps) پښتو
(pnb) پنجابی
(aeb-arab) تونسي
(azb) تۆرکجه
(aeb) تونسي / Tûnsî
(arq) جازايرية
(bcc) جهلسری بلوچی
(bgn) روچ کپتین بلوچی
(skr) سرائیکی
(skr-arab) سرائیکی
(sd) سنڌي
(apc) شامي
(acm) عراقي
(fa) فارسی
(kk-arab) قازاقشا (تٴوتە)
(kk-cn) قازاقشا (جۇنگو)
(ku-arab) کوردی (عەرەبی)
(ks-arab) کٲشُر
(khw) کھوار
(ckb) کوردی
(sdh) کوردی خوارگ
(⧼lang/gju-arab⧽) گوجری
(ota) لسان عثمانى
(glk) گیلکی
(lrc) لۊری شومالی
(luz) لئری دوٙمینی
(lki) لەکی
(mzn) مازِرونی
(arz) مصرى
(hno) ہندکو
(arc) ܐܪܡܝܐ
(dv) ދިވެހިބަސް
(nqo) ߒߞߏ

The previous list was generated by:

{{#invoke:Languages|forEachLanguage|preprocess=yes|pattern=<nowiki />
* <span style="font-size:smaller;">([[MediaWiki:Lang/$lc|<span style="font-family:monospace,monospace;" title="{{((}}#language:$lc{{!}}en{{))}}">{{((}}int{{!}}lang/$lc{{))}}</span>]])</span> <bdi lang="$lc" class="autonym lang-$lc">{{((}}#language:$lc{{))}}</bdi>
}}

Tracked in Phabricator
Task T49137

Note that as of 2020-10-18, there's a new bug in Scribunto, which causes the standard "table.sort()" function to no longer accept a standard comparison function. Now when "table.sort()" fails, the error is correctly catched (instead of producing a visible error), but the list may not be sorted correctly (temporarily) in some cases. The bug is tracked and corrected in Mediawiki but waiting to be deployed with the fix. Nothing will need to be changed (using "perror()" will then no longer have any effect, it is just needed for now and the bug was not a bug of this module which was properly tested and sudddently failed unexpectedly). Thanks.

Note:

The list is retrieved using Module:Languages/List and sorted in native language name (LTR languages before RTL languages, then each one sorted by native script and then a locale-neutral sort order within each script) using Module:Multilingual description/sort (which is the consistant sort order used for multilingual navigation navigation boxes, or for showing lists of translations in multilingual descriptions, in a user-friendly way). For seeing the complete list of languages, tested with their directionality, look at the tests results table on Module talk:Multilingual description/sort/testcases.

Code

--[=[
Not globally exposed. Internal function only.

language_subpages( frame, transform, options )
Parameters
    frame:     The frame that was passed to the method invoked. The first argument or the page argument will be respected.
    transform: A transform function. Example: function( basepagename, subpagename, code, langname ) end
    options:   An object with options. Example: { abort= { on=function() end, time=0.8 }  }
        Following options are available:
        abort: Aborts iterating over the subpages if one of the conditions is met. If the process is aborted, nil is returned!
            on: Function to be called if an abort-condition was met.
            cycles: The maximum number of subpages to run over.
            time: Maximum time to spend running over the subpages.

]=]
local function language_subpages( frame, transform, options )
    local args, pargs, options = frame.args, ( frame:getParent() or {} ).args or {}, options or {};
    local title = args.page or args[1] or pargs.page or pargs[1] or "";
    local abort = options.abort or {};
    local at, clock = type( abort.on ), os.clock();
    local ac = function()
        if  at == 'function' or ( at == 'table' and getmetatable(abort.on).__call ) then
            abort.on();
        end
    end
    local tt = type( transform );
    local page = require( 'Module:Page' );

    title = page.clean(title);

    if tt == 'function' or ( tt == 'table' and getmetatable(transform).__call ) then
        local fetch, pages, langcode, langname = mw.language.fetchLanguageName, {};
--[==[

     / \
    / | \
   /  ·  \
   ¯¯¯¯¯¯¯
   Page.subpages() no longer works because it attempted to parse the HTML content generated by
   calling the parser function "Special:Prefixindex:" which is no longer expanded in Lua but
   converted to a "stripped tag" (containing a unique identifier surrounded by ASCII DEL characters)
   representing the tag name and its parameters.
   The actual expansion of stripped tags can no longer be performed in Lua.
   Now unstripping these tags just kills ALL these tags (except "wiki" tags) instead of performing
   their expansion by running the extension code. Only MediaWiki can unstrip these tags in texts after
   they have been returned by Lua.
   For this reason, page.subpages() is now completely empty (Module:Page no longer works).
   This cannot be bypassed, except by using a Scribunto extension library if lifting the limits set by mw.unstrip.
   Note that "Special:Prefixindex:" is also costly, even if it just requires a single database query to
   get all subpages, instead of one costly #ifexist or one costly mw.title() property reading per
   tested subpage to know if it exists.
   For now there's still no reliable way to get a list of subpages, or performing queries similar to
   the [[Special:Prefixindex]] page or list members of a category like when viewing a category page.
   Ideally, there should exist a method for such queries on Title objects returned by the mw.title library;
   but for now there's none.
   In Lua now, the only expansion possible with an immediate effect is the expansion of standard templates,
   all special tags or special pages, or parser function extensions do not work (Only the #expr parser
   function is supported by using an external Scribunto library).
--]==]
        for pg in page.subpages( title, { ignoreNS=true } ) do
            if abort.cycles then
                abort.cycles = abort.cycles - 1
                if 0 == abort.cycles then return ac()  end
            end
            if abort.time then
                if (os.clock() - clock) > abort.time then return ac()  end
            end
            if mw.ustring.len( pg ) <= 12 then
                langcode = string.lower( pg );
                langname = fetch( langcode );
                if langname ~= '' then
                    table.insert( pages, transform( title, pg, langcode, langname ) );
                end
            end
        end
        return pages;
    end
    return {};
end

local function cloneArgs(frame)
    local args, pargs = {}, {}
    for k,v in pairs( frame.args ) do args[k] = v end
    if frame:getParent() then
        for k,v in pairs( frame:getParent().args ) do pargs[k] = v end
    end
    return args, pargs
end



local p = {};

--[=[
Usage:
{{#invoke:languages|internal|Template:Adjective}}
]=]
function p.internal(frame)
    return table.concat(
        language_subpages( frame,
            function( title, page, code, name )
                return mw.ustring.format(
                    '<bdi class="language lang-%s" lang="%s">[[%s/%s|%s]]</bdi>',
                    code, code,
                    title, page,
                    name
                );
            end
        ),
        '&nbsp;<b>·</b>&#32;'
    );
end

--[=[
Usage:
{{#invoke:languages|external|Template:Adjective}}
]=]
function p.external(frame)
    return table.concat(
        language_subpages( frame,
            function( title, page, code, name )
                return mw.ustring.format(
                    '<bdi class="language lang-%s" lang="%s">[%s/%s %s]</bdi>',
                    code, code,
                    tostring( mw.uri.fullUrl( title ) ), page:gsub( ' ', '_' ),
                    name
                );
            end
        ),
        '&nbsp;<b>·</b>&#32;'
    );
end

--[=[
forEachLanguage

This function iterates over all language codes known to MediaWiki based on a maintained list
replacing patterns in a pattern-string for each language

Usage
{{#invoke:Languages|forEachLanguage
  |pattern=patternstring
  |before=string to insert before iteration
  |after=string added after iteration
  |sep=separator string between iterations
  |inLang=langcode used for $lnTrP and $lnTrUC1
}}

Parameters
    pattern: A pattern string which is processed for each language and which is concatenated at the end and returned as one string
    before: A string that is inserted before the concatenated result
    after: A string that is inserted after the concatenated result
    sep: A string that is inserted between each line created from the pattern while iterating (like ProcessedPattern_sep_ProcessedPattern_sep_ProcessedPattern)
    inLang: Langcode to use for $lnTrP and $lnTrUC1
    preprocess: if set to a non-empty value, the output will be preprocessed before being returned.

Warning
    The output is still not prepreprocessed by default: so parser functions and magic keywords generated by the pattern are still not executed and replaced,
    and template transclusions are still not expanded (see examples in other functions in this module).
    When using this function directly from a MediaWiki page or template, this means it is only possible to use patterns generating basic MediaWiki formatting
    or HTML tags. It you want the output to be preprocessed (in the given frame), set the preprocess parameter to a non-empty string.
    
Patterns
    $lc - language code such as en or de
    $lnP - language name in own language (autonym)
    $lnUC1 - language name in own language (autonym), first letter upper case
    $lnTrP - language name translated to the language requested by language code passed to inLang
    $lnTrUC1 - language name translated to the language requested by language code passed to inLang, first letter upper case

Example
    {{#invoke:Languages|forEachLanguage|pattern=<span lang="$lc" xml:lang="$lc" class="language lang-$lc">[[Page/$lc|$lnP]]</span>}}
]=]

-- =p.forEachLanguage({ args= { pattern = "$lc - $lnTrP\n", inLang = "en" } })
function p.forEachLanguage(frame)
    local l = require("Module:Languages/List")

    local ret = {}
    local lang    = mw.language
    local line
    local pattern = frame.args.pattern   or frame.args[1] or ""
    local prefix  = frame.args.before    or frame.args[2] or ""
    local postfix = frame.args.after     or frame.args[3] or ""
    local sep     = frame.args.sep       or frame.args.separator or frame.args[4] or ""
    local inLang  = frame.args.inLang    or frame.args[5] or nil
    local preprocess = frame.args.preprocess or frame.args[6] or ""

    local langNameUCFirstReq           = not not pattern:find( "$lnUC1", 1, true )
    local langNameReq                  = not not pattern:find( "$lnP", 1, true ) or langNameUCFirstReq
    local langNameTranslatedUCFirstReq = not not pattern:find( "$lnTrUC1", 1, true )
    local langNameTranslatedReq        = not not pattern:find( "$lnTrP", 1, true ) or langNameTranslatedUCFirstReq
    local contentLangInstance = mw.language.getContentLanguage()
    local inLangLangInstance
    local l = mw.language.fetchLanguageNames() -- autonyms
    local lTr
    local lcIdList = require('Module:Languages/List').getSortedList( l )

    if langNameTranslatedReq then
        inLangLangInstance = --[==[
            mw.getLanguage( inLang ) -- Quota hit in :ucfirst() if using too many langInstances
            --]==] contentLangInstance
        lTr = mw.language.fetchLanguageNames( inLang ) -- translated names
    end

    for _, lcId in pairs( lcIdList ) do
        local subst = lcId:gsub('%%', '%%%%')
        line = pattern:gsub( "%$lc", subst )
        local langName, langInstance
        -- autonym (name of lcId in locale lcId)
        if langNameReq then
            langName = l[lcId]
            subst = langName:gsub('%%', '%%%%')
            line = line:gsub( "%$lnP", subst )
        end
        if langNameUCFirstReq then
            langInstance = --[==[
                mw.getLanguage( lcId ) -- Quota hit in :ucfirst() if using too many langInstances
                --]==] contentLangInstance
            langName = langInstance:ucfirst( langName )
            subst = langName:gsub('%%', '%%%%')
            line = line:gsub( "%$lnUC1", subst )
        end

        -- translated name (name of lcId in locale inLang)
        if langNameTranslatedReq then
            langName = lTr[lcId]
            subst = langName:gsub('%%', '%%%%')
            line = line:gsub( "%$lnTrP", subst )
        end
        if langNameTranslatedUCFirstReq then
            langName = inLangLangInstance:ucfirst( langName )
            subst = langName:gsub('%%', '%%%%')
            line = line:gsub( "%$lnTrUC1", subst )
        end

        table.insert(ret, line)
    end
    ret = prefix .. table.concat( ret, sep ) .. postfix
    if preprocess ~= '' then
        ret = frame:preprocess(ret)
    end
    return ret
end

--[=[
 Provide logic for [[Template:Lle]] (Language Links external, to be substituted, language names written exactly as #language would provide them)
 Warning: may expands too many costly #ifexist without limitation (if not substituted into a separate "/lang" template)
]=]
function p.lle(frame)
    return frame:preprocess(
        p.forEachLanguage({
            args = {
                pattern = '{{subst:#ifexist:{{{1}}}/$lc|[{{subst:fullurl:{{{1}}}/$lc}} <bdi class="language lang-$lc" lang="$lc">$lnP</bdi>]&nbsp;<b>∙</b>&#32;<!--\n-->}}'
            }
        })
    )
end

--[=[
 Provide logic for [[Template:Ll]] (Language Links internal, to be substituted, language names written exactly as #language would provide them)
 Warning: may expands too many costly #ifexist without limitation (if not substituted into a separate "/lang" template)
]=]
function p.ll(frame)
    return frame:preprocess(
        p.forEachLanguage({
            args = {
                pattern = '{{subst:#ifexist:{{{1}}}/$lc|[[{{{1}}}/$lc|<bdi class="language lang-$lc" lang="$lc">$lnP</bdi>]]&nbsp;<b>∙</b>&#32;<!--\n-->}}'
            }
        })
    )
end


--------------------------------------------------------
--- Different approaches for [[Template:Lang links]] ---
--------------------------------------------------------

--[=[
 Provide logic for [[Template:Lang links]]
 Using a cute Hybrid-Method:
    First check the subpages which is quite fast; if there are too many fall back to checking for each language page individually
]=]

-- =p.langLinksNonExpensive({ args= { page='Commons:Picture of the Year/2010' }, getParent=function() end })
-- =p.langLinksNonExpensive({ args= { page='Main Page' }, getParent=function() end })
-- =p.langLinksNonExpensive({ args= { page='Template:No_source_since' }, getParent=function() end })
-- =p.langLinksNonExpensive({ args= { page='MediaWiki:Gadget-HotCat' }, getParent=function() end })
function p.langLinksNonExpensive(frame)
    local args, pargs = frame.args, ( frame:getParent() or {} ).args or {};
    local title = args.page or args[1] or pargs.page or pargs[1] or "";
    local contentLangInstance = mw.language.getContentLanguage();
    local pages2
    if frame.preprocess == nil then
        frame = mw.getCurrentFrame()
    end
--[==[
    local options = {
        abort = {
            time = 3.5,
            on = function()
                pages2 = p.forEachLanguage({
                    args = {
                       pattern = '{{#ifexist:' .. title .. '/$lc|[[' .. title .. '/$lc|<bdi lang="$lc">$lnP</bdi>]]&nbsp;<b>∙</b>&#32;}}'
                    }
                })
            end
        }
    }
    local pages = language_subpages( frame,
        function( title, page, code, langname )
            return mw.ustring.format(
                '[[%s/%s|<bdi lang="%s">%s</bdi>]]</span>&nbsp;<b>∙</b>&#32;',
                title, page, code, langname
            )
        end, options );
    return pages2 and frame:preprocess(pages2) or table.concat(pages, '');
--]==]
    return frame:preprocess(
        p.forEachLanguage( {
            args = {
                pattern = '{{#ifexist:' .. title .. '/$lc|[[' .. title .. '/$lc|<bdi lang="$lc">$lnP</bdi>]]&nbsp;<b>∙</b>&#32;}}'
            }
        })
    )
end

---------------------------------------------------------
----------------- [[Template:Autolang]] -----------------
---------------------------------------------------------
--[[
  Works like {{autotranslate}} just allowing an unlimited number of arguments, even named arguments.
  It's doing Magic! No arguments should be passed to {{#invoke:}}
]]

function p.autolang(frame)
    local args, pargs = cloneArgs( frame )
    if nil == args.useargs then
        if not args.base then args = pargs end
    elseif 'both' == args.useargs then
        for k,v in pairs(args) do pargs[k] = v end
        args = pargs
    elseif 'parent' == args.useargs then
        args = pargs
        if pargs.base and not args.base then
            args.base = pargs.base
        end
    end
    local base = args.base
    local userlang = frame:callParserFunction('int', 'lang')
    local tl, tlns = 'Template:', 10
    local tlb, fallback1, currenttemplate, currenttemplatepage
    local fallback, contentlang = mw.text.split( userlang, '-', true )[1], mw.language.getContentLanguage():getCode()

    local function createReturn(title)
        local ret
        local tlargs = {}
         -- When LUA is invoked, templates are already expanded. This must be respected.
        return frame:expandTemplate{ title = title, args = args }
    end

    if not base then
        return ("'autolang' in [[Module:Languages]] was called but the 'base' parameter could not be found." ..
            "The base parameter specifies the template that's subpages will be sought for a suitable translation.")
    end
    tlb = tl .. base .. '/'

    currenttemplate = tlb .. userlang
    currenttemplatepage = mw.title.new( currenttemplate, tlns )
    if currenttemplatepage and currenttemplatepage.exists then
        return createReturn(currenttemplate)
    end

    fallback1 = frame:preprocess( '{{Fallback|1=' .. base .. '|2=' .. userlang .. '}}' )
    if fallback1 ~= contentlang then
        return createReturn(tlb .. fallback1)
    end

    currenttemplate = tlb .. fallback
    currenttemplatepage = mw.title.new( currenttemplate, tlns )
    if currenttemplatepage and currenttemplatepage.exists then
        return createReturn(currenttemplate)
    end

    currenttemplate = tlb .. contentlang
    currenttemplatepage = mw.title.new( currenttemplate, tlns )
    if currenttemplatepage and currenttemplatepage.exists then
        return createReturn(currenttemplate)
    end
    return createReturn(tl .. base)
end

--[=[
Usage:
{{#invoke:languages|isKnownLanguageTag|gsw}} -> 1
{{#invoke:languages|isKnownLanguageTag|doesNotExist}} ->
]=]
function p.isKnownLanguageTag(frame)
    return mw.language.isKnownLanguageTag( frame.args[1] or frame.args.tag or frame.args.code or '' ) and '1' or ''
end

function p.file_languages(frame)
    local M_link = require( 'Module:Link' )
    local contentLangInstance = mw.language.getContentLanguage()
    local pattern = frame.args.pattern or '%s (%s)'
    local original = frame.args.original or mw.title.getCurrentTitle().text
    local ext_start, _ = string.find( original, '\.%w+$' )
    local file_ext = string.sub( original, ext_start )
    original = string.sub( original, 0, ext_start - 1 )
    return frame:preprocess(
        '<gallery>\n' ..
        (table.concat(
            M_link.forEachLink(
                p.forEachLanguage({
                    args = { pattern = '[[$lc]]' }
                }),
                function( linkInfo )
                    local filename = mw.ustring.format( pattern, original, linkInfo.text ) .. file_ext
                    local filepage = mw.title.new( filename, 6 )
                    if filepage and filepage.exists then
                        return mw.ustring.format( '%s|%s',
                            filename,
                            mw.language.fetchLanguageName( linkInfo.text )
                        )
                    else
                        return nil
                    end
                end
            ), '\n'
        )) ..
        '\n</gallery>'
    )
end

function p.runTests()
    return p.langLinksNonExpensive({
        args = {
            page = 'Module:Languages/testcases/test'
        },
        getParent = function() end
    }) ==
        '[[Module:Languages/testcases/test/de|<bdi lang="de">Deutsch</bdi>]]&nbsp;<b>∙</b>&#32;' ..
        '[[Module:Languages/testcases/test/en|<bdi lang="en">English</bdi>]]&nbsp;<b>∙</b>&#32;'
end

return p;