مايو

<mediawiki xmlns="http://www.mediawiki.org/xml/export-0.11/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.mediawiki.org/xml/export-0.11/ http://www.mediawiki.org/xml/export-0.11.xsd" version="0.11" xml:lang="ms">
  <siteinfo>
    <sitename>Wikikamus</sitename>
    <dbname>mswiktionary</dbname>
    <base>https://ms.wiktionary.org/wiki/Wikikamus:Laman_Utama</base>
    <generator>MediaWiki 1.47.0-wmf.2</generator>
    <case>case-sensitive</case>
    <namespaces>
      <namespace key="-2" case="case-sensitive">Media</namespace>
      <namespace key="-1" case="first-letter">Khas</namespace>
      <namespace key="0" case="case-sensitive" />
      <namespace key="1" case="case-sensitive">Perbincangan</namespace>
      <namespace key="2" case="first-letter">Pengguna</namespace>
      <namespace key="3" case="first-letter">Perbincangan pengguna</namespace>
      <namespace key="4" case="case-sensitive">Wikikamus</namespace>
      <namespace key="5" case="case-sensitive">Perbincangan Wikikamus</namespace>
      <namespace key="6" case="case-sensitive">Fail</namespace>
      <namespace key="7" case="case-sensitive">Perbincangan fail</namespace>
      <namespace key="8" case="first-letter">MediaWiki</namespace>
      <namespace key="9" case="first-letter">Perbincangan MediaWiki</namespace>
      <namespace key="10" case="case-sensitive">Templat</namespace>
      <namespace key="11" case="case-sensitive">Perbincangan templat</namespace>
      <namespace key="12" case="case-sensitive">Bantuan</namespace>
      <namespace key="13" case="case-sensitive">Perbincangan bantuan</namespace>
      <namespace key="14" case="case-sensitive">Kategori</namespace>
      <namespace key="15" case="case-sensitive">Perbincangan kategori</namespace>
      <namespace key="100" case="case-sensitive">Lampiran</namespace>
      <namespace key="101" case="case-sensitive">Perbincangan lampiran</namespace>
      <namespace key="102" case="case-sensitive">Rima</namespace>
      <namespace key="103" case="case-sensitive">Perbincangan rima</namespace>
      <namespace key="104" case="case-sensitive">Tesaurus</namespace>
      <namespace key="105" case="case-sensitive">Perbincangan tesaurus</namespace>
      <namespace key="106" case="case-sensitive">Indeks</namespace>
      <namespace key="107" case="case-sensitive">Perbincangan indeks</namespace>
      <namespace key="108" case="case-sensitive">Petikan</namespace>
      <namespace key="109" case="case-sensitive">Perbincangan petikan</namespace>
      <namespace key="110" case="case-sensitive">Rekonstruksi</namespace>
      <namespace key="111" case="case-sensitive">Perbincangan rekonstruksi</namespace>
      <namespace key="112" case="case-sensitive">Padanan isyarat</namespace>
      <namespace key="113" case="case-sensitive">Perbincangan padanan isyarat</namespace>
      <namespace key="114" case="case-sensitive">Konkordans</namespace>
      <namespace key="115" case="case-sensitive">Perbincangan konkordans</namespace>
      <namespace key="710" case="case-sensitive">TimedText</namespace>
      <namespace key="711" case="case-sensitive">TimedText talk</namespace>
      <namespace key="828" case="case-sensitive">Modul</namespace>
      <namespace key="829" case="case-sensitive">Perbincangan modul</namespace>
      <namespace key="1728" case="case-sensitive">Acara</namespace>
      <namespace key="1729" case="case-sensitive">Perbincangan acara</namespace>
    </namespaces>
  </siteinfo>
  <page>
    <title>مايو</title>
    <ns>0</ns>
    <id>9228</id>
    <revision>
      <id>342804</id>
      <parentid>263644</parentid>
      <timestamp>2026-05-16T12:29:22Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <origin>342804</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="334" sha1="m3k4kbfkdcedobjt88l47k2q6c4ewe4" xml:space="preserve">==Bahasa Arab==
==== Kata nama ====
'''{{ARchar|مَايُو}}''' • (māyu) 
# [[Mei]] {{qualifier|Kalendar barat}}

=== Etimologi ===
Akhirnya daripada {{der|ar|la|Maius}}.

=== Tesaurus ===
; Sinonim: {{l|ar|أَيَّار|sc=Arab}}, {{l|ar|ماي|sc=Arab}}.

[[Kategori:Kata nama bahasa Arab]]
[[Kategori:ar:Bulan takwim Masihi]]</text>
      <sha1>m3k4kbfkdcedobjt88l47k2q6c4ewe4</sha1>
    </revision>
  </page>
  <page>
    <title>July</title>
    <ns>0</ns>
    <id>9394</id>
    <revision>
      <id>342806</id>
      <parentid>321226</parentid>
      <timestamp>2026-05-16T12:30:54Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <origin>342806</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1176" sha1="hrqo7xnab7dl9e9xplq6q8rn50j7v68" xml:space="preserve">{{also|july}}
==Bahasa Inggeris==
{{wikipedia|lang=en}}
====Kata nama khas====
{{en-knk}}

# [[bulan|Bulan]] ketujuh dalam [[kalendar Masihi]], selepas [[Jun]] dan sebelum [[Ogos]]. Kependekan: '''[[Jul]]''' atau '''[[Jul.]]'''

===Etimologi===
Daripada {{inh|en|enm|Julie}}, {{m|enm|julye}}, {{m|enm|iulius}}, daripada {{der|en|xno|julie}}, daripada {{der|en|fro|jule}}, {{m|fro|juil}}, daripada {{der|en|la|iūlius}} (bulan {{w|Julius Caesar|Gaius Julius Caesar}}), mungkin pemendekan bagi ''*Iovilios'', &quot;diturunkan daripada [[Jove]]&quot;.

===Sebutan===
* {{enPR|jo͝o-līʹ}}, {{IPA|en|/d͡ʒʊˈlaɪ/}}
* {{audio|en|en-us-July.ogg|Audio (US)}}
* {{rhymes|en|aɪ}}

===Terbitan===
{{atas3}}
* [[Black July]]
* [[Christmas in July]]
* [[Fourth of July]]
* [[Holiday in July]]
* [[w:en:July 1 marches|July 1 marches]]
* [[w:en:July 7 bombings|July 7 bombings]]
* [[July 20 Plot]]
* [[w:en:July Column|July Column]]
* [[July Cup]]
{{tengah3}}
* [[July Days]]
* [[July Monarchy]]
* [[July Morning]]
* [[July Ordinances]]
* [[July Revolution]]
* [[July Stakes]]
* [[July Ultimatum]]
* [[mid-July]]
{{bawah}}

[[Kategori:en:Bulan takwim Masihi]]
[[Kategori:Eponim bahasa Inggeris]]</text>
      <sha1>hrqo7xnab7dl9e9xplq6q8rn50j7v68</sha1>
    </revision>
  </page>
  <page>
    <title>يوليو</title>
    <ns>0</ns>
    <id>9396</id>
    <revision>
      <id>342802</id>
      <parentid>241535</parentid>
      <timestamp>2026-05-16T12:29:04Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <origin>342802</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="290" sha1="drif8kp7dme79fj1u2fiaxchh5b2pvz" xml:space="preserve">{{ar}}
==== Kata nama ====
&lt;big&gt;'''يُولْيُو'''&lt;/big&gt; • (yúlyu) 
# [[Julai]] {{qualifier|Kalendar barat}}

=== Tesaurus ===
; Sinonim:  [[تموز]], [[يُولِيُوز]].

=== Lihat juga ===
* [[رجب]]

[[Kategori:Kata nama bahasa Arab]]
[[Kategori:ar:Bulan takwim Masihi|7]]</text>
      <sha1>drif8kp7dme79fj1u2fiaxchh5b2pvz</sha1>
    </revision>
  </page>
  <page>
    <title>August</title>
    <ns>0</ns>
    <id>9451</id>
    <revision>
      <id>342805</id>
      <parentid>322511</parentid>
      <timestamp>2026-05-16T12:30:37Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <origin>342805</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="4860" sha1="tizm04yk5jxod0hpfx8fimrs4l6rs4z" xml:space="preserve">{{also|august}}
==Bahasa Inggeris==
{{wikipedia|lang=en}}
====Kata nama khas====
'''August''' (''jamak'' '''[[Augusts]]''')
# Bulan kelapan [[kalendar Masihi]], selepas [[Julai]] dan sebelum [[September]]. Kependekan: '''[[Aug]]''' atau '''[[Aug.]]'''
# ''Nama berian perempuan'' diterbit daripada bulannya (penggunaan moden jarang).
# ''Nama berian lelaki''.

===Etimologi===
Daripada perkembangan awal {{der|en|enm|August|August(us)}}, dilatinkan semula daripada {{der|en|ang|Agustus}}, daripada {{cog|LL.|Agustus}}, daripada {{der|en|la|augustus||bulan Ogos}}, daripada agnomen {{m|la|Augustus||mulia}} kepada {{w|Augustus|Gaius Julius Caesar Augustus}}, yang berkemungkinan daripada sama ada bahasa Latin Kuno {{m|itc-ola|*augos|t=meningkat}}, daripada {{der|en|itc-pro|*augos}}, daripada bentuk dasar {{der|en|ine-pro|-}} {{m|ine-pro|*h₂ewg-||untuk meningkat}}; atau gubahan {{cog|la|avis||burung}} + {{m|la|garrio|garrīre|t=berceloteh}} yang merujuk kepada ramalan dengan memerhati penerbangan burung, menyanyi, memberi makan atau isi perut.

===Sebutan===
* {{enPR|ôʹgəst}}, {{AFA|en|/ˈɔːɡəst/}}
* {{audio|en|en-us-August.ogg|Audio (US)}}

===Terbitan===
{{atas3}}
* [[august]] {{qualifier|kata kerja}}
* [[August Bank Holiday]]
* {{w|en:August Coup|August Coup}}
* {{w|en:Mid-Autumn Festival|August Moon Festival}}
{{tengah3}}
* {{w|en:August Penguin|August Penguin}}
* [[August plum]]
* {{w|en:August Putsch|August Putsch}}
* {{w|en:August Revolution|August Revolution}}
{{tengah3}}
* [[August rooster]]
* {{w|en:Operation August Storm|Operation August Storm}}
* {{w|en:August Uprising in Georgia|August Uprising in Georgia}}
* [[mid-August]]
{{ter-bawah}}

===Tesaurus===
; Sinonim: [[Augost]] {{qualifier|Inggeris Jamaica}}
===Anagram===
* [[Tausug#Bahasa Inggeris|Tausug]]

[[Kategori:Kata nama khas bahasa Inggeris]]
[[Kategori:Kata nama khas terhitung bahasa Inggeris]]
[[Kategori:en:Bulan takwim Masihi]]
[[Kategori:Nama berian perempuan bahasa Inggeris daripada bahasa Inggeris]]
[[Kategori:Nama berian lelaki bahasa Inggeris daripada bahasa Latin]]
[[Kategori:Eponim bahasa Inggeris]]

==Bahasa Denmark==
====Kata nama khas====
{{head|da|kata nama khas}}

# ''Nama berian lelaki''. Bentuk feminin: [[Augusta]].

===Etimologi===
Daripada {{der|da|la|Augustus}}.

[[Kategori:Nama berian lelaki bahasa Denmark]]

==Bahasa Estonia==
====Kata nama khas====
{{head|et|kata nama khas}}

# ''Nama berian lelaki''.

===Etimologi===
Daripada {{der|et|la|Augustus}}.

[[Kategori:Nama berian lelaki bahasa Estonia]]

==Bahasa Ewe==
====Kata nama khas====
{{head|ee|kata nama khas}}

# [[Ogos]]

{{C|ee|Bulan dalam tahun}}

==Bahasa Finland==
====Kata nama khas====
{{head|fi|kata nama khas}}

# ''Nama berian lelaki''

===Etimologi===
Daripada {{bor|fi|sv|August}}, daripada {{der|fi|la|Augustus}}.

[[Kategori:Nama berian lelaki bahasa Finland]]

==Bahasa Jerman==
====Kata nama====
{{de-noun|m,-:s:es}}

# [[Ogos]] {{gloss|bulan}}

====Kata nama khas====
{{de-proper noun|m,(s)}}

# ''Nama berian lelaki'', serumpun dengan Inggeris [[Augustus]].

===Sebutan===
* {{AFA|de|/aʊ̯ˈɡʊst/}} {{i|bulan}}
* {{AFA|de|/ˈaʊ̯ɡʊst/}} {{i|nama berian}}
* {{audio|de|De-August.ogg|audio}}

===Terbitan===
{{atas3}}
* [[Augustabend]]
* [[Augustabende]]
* [[Augustfeier]]
* [[Augustfeiern]]
* [[Augustferien]]
* [[Augustheu]]
{{tengah3}}
* [[Augustmorgen]]
* [[Augustnacht]]
* [[Augustnächte]]
* [[Augusttag]]
* [[Augusttage]]
* [[Augusttraube]]
{{tengah3}}
* [[Augusttrauben]]
* [[Augustwoche]]
* [[Augustwochen]]
* [[Augustwochenende]]
* [[Augustwochenenden]]
* {{qualifier|entomologi}} [[Eichenzackenrandspanner]] ([[Eichen-Zackenrandspanner]])
{{ter-bawah}}

===Tesaurus===
; Sinonim: 
* [[Erntemonat]] {{i|arkaik}}
* [[Erntemond]] {{i|arkaik}}
* [[Ernting]] {{i|arkaik}}

===Keturunan===
* Armenia: [[Ավգուստ]]
* Rusia: [[А́вгуст]]

{{C|de|Bulan dalam tahun}}
[[Kategori:Nama berian bahasa Jerman]]

==Bahasa Luxembourg==
====Kata nama khas====
{{head|lb|kata nama khas}}

# [[Ogos]]

{{C|lb|Bulan dalam tahun}}

==Bahasa Norway==
====Kata nama khas====
{{head|no|kata nama khas}}

# ''Nama berian lelaki''.

===Etimologi===
Daripada {{der|no|la|Augustus}}

[[Kategori:Nama berian lelaki bahasa Norway]]

==Bahasa Prusia Kuno==

====Kata nama khas====
{{head|prg|kata nama khas}}

# [[Ogos]] {{gloss|bulan}}

===Lihat juga===
* [[Daggis]]

{{C|prg|Bulan dalam tahun}}

==Bahasa Scots==
====Kata nama khas====
{{head|sco|kata nama khas}}

# [[Ogos]]

===Etimologi===
Daripada {{der|sco|la|augustus}}.

===Lihat juga===
* {{sense|bulan}} Sebelum: [[Julie]]. Selepas: [[September]]

{{C|sco|Bulan dalam tahun}}

==Bahasa Sweden==
====Kata nama khas====
{{head|sv|kata nama khas}}

# ''Nama berian lelaki''. Bentuk feminin:: [[Augusta]]

===Etimologi===
Daripada {{der|sv|la|Augustus}}.

[[Kategori:Nama berian lelaki bahasa Sweden]]</text>
      <sha1>tizm04yk5jxod0hpfx8fimrs4l6rs4z</sha1>
    </revision>
  </page>
  <page>
    <title>أغسطس</title>
    <ns>0</ns>
    <id>9454</id>
    <revision>
      <id>342803</id>
      <parentid>241544</parentid>
      <timestamp>2026-05-16T12:29:13Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <origin>342803</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="256" sha1="hru1x3vlfg55tzcgmvtu9if5yljzth7" xml:space="preserve">{{ar}}
{{wikipedia|lang=ar}}
==== Kata nama ====
'''أغُسْطُسْ''' • (ʾaġúsṭus) 
# [[Ogos]] {{qualifier|Kalendar barat}}

=== Lihat juga ===
* [[شعبان]]
* [[آب]]

[[Kategori:Kata nama bahasa Arab]]
[[Kategori:ar:Bulan takwim Masihi|8]]</text>
      <sha1>hru1x3vlfg55tzcgmvtu9if5yljzth7</sha1>
    </revision>
  </page>
  <page>
    <title>September</title>
    <ns>0</ns>
    <id>9456</id>
    <revision>
      <id>342809</id>
      <parentid>334087</parentid>
      <timestamp>2026-05-16T12:32:15Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <origin>342809</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="9809" sha1="lit7lsj4tdu1un0u160i9rz58msojqe" xml:space="preserve">{{also|september}}
{{Pautan Projek Wikimedia}}
==Bahasa Melayu==
{{wikipedia}}
===Kata nama khas===
{{ms-knk}}
# Bulan kesembilan dalam tahun Masihi yang mengandungi 30 hari, antara [[Ogos]] dan [[Oktober]].

===Etimologi===
{{bor+|ms|en|September}}, daripada bahasa {{inh|en|enm|-}}, daripada bahasa {{der|en|ang|-}} Akhir, daripada perkataan bahasa {{der|ms|fro|septembre}}, {{der|ms|la|September||bulan ketujuh}}, daripada {{m|la|septem||tujuh}}, daripada {{der|en|ine-pro|*septḿ̥||tujuh}}; + {{der|en|la|-ber}}, daripada {{m|la|-bris}} yang merupakan akhiran bersifat; September merupakan bulan ketujuh dalam kalendar Rom.

===Sebutan===
* {{dewan|sép|tém|ber}}
* {{AFA|ms|[sɛptɛmbə(r)]}}
* {{rhymes|ms|bə(r)|ə(r)}}

===Tulisan Jawi===
{{ARchar|[[سيڤتيمبر]]}}

===Terjemahan===
{{ter-atas|bulan kesembilan kalendar Masihi}}
* Abaza: {{t|abq|сентябрь}}
* Abkhaz: {{t|ab|цәыббра|tr=cwəbbra}}
* Afrikaans: {{t+|af|September}}
* Alabama: {{t|akz|hasiholtina istachákkàali}}
* Albania: {{t|sq|shtator}}
* Alutiiq: {{t|ems|Qakiiyat Iraluat}}
* Amhara: {{t|am|ሰፕቴምበር|tr=septembär|sc=Ethi}}
* Apache:
*: Apache Barat: {{t|apw|Binestʼánchoh}}
* Arab: {{t+|ar|سبْتمْبر|tr=sibtímbir, sibtámbir, sabtámbar|m}}, {{t|ar|ايلول|alt=أيْلولٌ|tr=’éilūl|m}}
*: Arab Mesir: {{t|arz|سبتمبر|m|tr=sebtamber|sc=Arab}}
* Armenia: {{t+|hy|սեպտեմբեր|tr=september}}
*: Armenia Lama: {{t|xcl|սեպտեմբեր|tr=september|sc=Armn}}
* Aromania: {{t|rup|septemvriu}}, {{t|rup|ghismãciuni}}, {{t|rup|stavru}}
* Asturia: {{t+|ast|septiembre|m}}
* Azeri: {{t+|az|sentyabr}}
* Basque: {{t+|eu|irail}}
* Belanda: {{t+|nl|september}}
* Benggali: {{t|bn|সেপ্টেম্বর|tr=Sepţembôr|sc=Beng}}
* Bislama: {{t|bi|septemba}}
* Breton: {{t+|br|Gwengolo}}, miz Gwengolo
* Bulgaria: {{t+|bg|септември|m|tr=septémvri}}
* Burma: {{t+|my|စက်တင်ဘာ|sc=Mymr|tr=settinba}}
* Catalonia: {{t+|ca|setembre|m}}
* Chechen: {{t|ce|Гезгмашан-бутт|sc=Cyrl}}
* Cherokee: {{t|chr|ᏚᎵᏍᏗ|tr=Dulisdi|sc=Cher}}
* Cina:
*: Mandarin: {{t+|cmn|九月|tr=jiǔyuè}}
* Corsican: {{t+|co|settembre}}
* Czech: {{t+|cs|září|n}}
* Dakota: {{t|dak|Wiinapciŋwaŋka}}
* Denmark: {{t+|da|september}}
* Esperanto: {{t+|eo|septembro}}, {{t|eo|Septembro}}
* Ewe: {{t|ee|Anyɔnyɔ}}, {{t|ee|September}}
* Faroe: {{t|fo|september|m}}, {{t|fo|septembur|m}}
* Fiji: {{t|fj|Seviteba}}
* Finland: {{t+|fi|syyskuu}}
* Frisia Barat: {{t+|fy|septimber}}, {{t+|fy|hjerstmoanne}}
* Friulia: {{t|fur|Setembar}}
* Galicia: {{t+|gl|setembro|m}}
* Georgia: {{t+|ka|სექტემბერი|sc=Geor}}
* Greek: {{t+|el|Σεπτέμβριος|m|tr=Septémvrios}}, {{t+|el|Σεπτέμβρης|m|tr=Septémvris}}, {{t|el|Τρυγητής|m|tr=Trygitís}}
* Greenland: {{t+|kl|Septembari}}
* Hawaii: {{t|haw|Kepakemapa}}
* Hindi: {{t+|hi|सितम्बर|tr=sitambar}}
* Hungary: {{t+|hu|szeptember}}
* Ibrani: {{t+|he|סֶפְּטֶמְבֶּר|tr=septémber}}
* Iceland: {{t+|is|september|m}}, {{t|is|septembermánuður|m}}
* Ido: {{t+|io|septembro}}
* Inari Sami: {{t|smn|čohčâmáánu}}
* Indonesia: {{t|id|September}}
* Inggeris: {{t+|en|September}}
* Inggeris Kuno: {{t|ang|hærfestmōnaþ|m}}, {{t|ang|hāliġmōnaþ|m}}
* Interlingua: {{t|ia|septembre}}
* Ireland: {{t+|ga|Meán Fómhair|m}}
* Itali: {{t+|it|settembre|m}}
* Jepun: {{t+|ja|九月|tr=くがつ, kugatsu}}, {{t+|ja|長月|tr=ながつき, nagatsuki}}
* Jerman: {{t+|de|September|m}}, {{t+|de|Scheiding|m}}
* Jerman Rendah:
*: Jerman Rendah Jerman: {{t|nds-de|September|m}}, {{t|nds-de|Harvstmaand|m}}
* Kazakh: {{t+|kk|қыркүйек|tr=qırküyek|sc=Cyrl}}
* Khmer: {{t+|km|កញ្ញា|tr=kăññā}}
* Kiribati: {{t|gil|Tebetembwa|sc=Cyrl}}
* Korea: {{t+|ko|구월|sc=Kore}}
* Kreol Haiti: {{t|ht|septanm}}
* Ladin: {{t|lld|setember}}
* Lao: {{t|lo|ເດືອນກັນຍາ|sc=Laoo}}
* Latin: {{t+|la|september}}
* Latvia: {{t+|lv|septembris|m}}
* Lezgi: {{t|lez|мара|tr=mara|sc=Cyrl}}
* Lithuania: {{t+|lt|rugsėjis|m}}, {{t+|lt|rugsėjo|f}}
* Livonia: {{t|liv|septembõr}}, {{t|liv|sigžkū}}
* Luxembourg: {{t+|lb|September|m}}, {{t+|lb|Hierschtmount|m}}
* Macedonia: {{t+|mk|септември|m|tr=septémvri}}
* Malagasy: {{t+|mg|septambra}}
* Malta: {{t|mt|Settembru}}
* Manchu: (uyun biya)
* Maori: {{t|mi|Hepetema}}
* Montagnais: {{t|moe|ushkau-pishimᵘ}}
* Navajo: {{t|nv|Biniʼantʼą́ą́tsoh}}
* Neapolitan: {{t|nap|settiembre|m}}, {{t|nap|settembre|m}}
* Norway: {{t+|no|september}}
* Novial: {{t|nov|septembre}}
* Occitan: {{t+|oc|setembre|m}}
* Ojibwe: {{t|oj|waatebagaa-giizis}}
* Oriya: {{t|or|ସେପ୍ଟେମ୍ବର|sc=Orya}}
* Ossetia: {{t|os|сентябрь|tr=sentjabr’|sc=Cyrl}}
* Parsi: {{t+|fa|سپتامبر|tr=septâmbr}}
* Perancis: {{t+|fr|septembre|m}}
* Poland: {{t+|pl|wrzesień|m}}
* Portugis: {{t+|pt|setembro|m}}
* Romania: {{t+|ro|septembrie}}, {{qualifier|popular}} {{t+|ro|răpciune}}, {{qualifier|popular}} {{t|ro|vincer}}
* Romansch: {{t|rm|satember|m}}, {{t|rm|settember|m}}
* Rusia: {{t+|ru|сентябрь|m|tr=sentjábr’}}
* Samoa: {{t|sm|setema}}
* Sardinia: {{t|sc|cabidanne}}, {{t|sc|cabidanni}}
* Sepanyol: {{t+|es|septiembre|m}}
* Serbo-Croatia:
*: Cyril: {{t|sh|септембар|m|sc=Cyrl}}
*: Rumi: {{t+|sh|septembar|m}}, {{t+|sh|rujan|m}} {{qualifier|Croatia}}
* Sicilia: {{t+|scn|sittèmmiru}}
* Skolt Sami: {{t|sms|čõhččmään}}
* Slovak: {{t+|sk|september|m}}
* Slovene: {{t|sl|septêmber|m}}
* Sotho: {{t+|st|Lwetse}}
* Sweden: {{t+|sv|september}}
* Tahiti: {{t|ty|tetepa}}
* Tajik: {{t+|tg|сентябр|tr=sentjabr|sc=Cyrl}}
* Telugu: {{t|te|సెప్టెంబరు|tr=sepTeMbaru}}
* Thai: {{t+|th|กันยายน|tr=gan yaa yohn}}
* Tok Pisin: {{t|tpi|septemba}}
* Tonga: {{t|to|sēpitema}}
* Turki: {{t+|tr|eylül}}
* Ukraine: {{t+|uk|вересень|m|tr=véresen’}}
* Venetian: {{t+|vec|setenbre}}
* Volapük: {{t+|vo|setul}}
* Võro: {{t|vro|süküskuu}}
* Wales: {{t+|cy|Medi|m}}
* Wolof: {{t|wo|Sattumbar}}
* Yiddish: {{t+|yi|סעפּטעמבער|m|tr=september|sc=Hebr}}
* Yup'ik: {{t|esu|Amiraayaaq}}
* Zuni: {{t|zun|Mola: Akwapba}}, {{t|zun|Łi'dekwakkya Ts'ana}}
{{ter-bawah}}

[[Kategori:ms:Bulan takwim Masihi]]

==Bahasa Afrikaans==
{{wikipedia|lang=af}}
====Kata nama====
'''September''' (''jamak'' '''[[Septembermaande]]''')
# [[#Bahasa Melayu|September]]

===Sebutan===
* {{AFA|af|[səpˈtem(b)ər, səˈtemər]}}

===Tulisan Arab===
{{ARchar|سِپْتَِمْبِرْ}}

[[Kategori:Kata nama bahasa Afrikaans]]
{{C|af|Bulan dalam tahun}}

==Bahasa Ewe==
==== Kata nama khas====
# [[#Bahasa Melayu|September]]

===Tesaurus===
; Sinonim: [[Anyɔnyɔ]].

[[Kategori:Kata nama khas bahasa Ewe]]
{{C|ee|Bulan dalam tahun}}

==Bahasa Indonesia==
==== Kata nama khas====
# Nama bulan ke-9.

[[Kategori:Kata nama khas bahasa Indonesia]]
{{C|id|Bulan dalam tahun}}

==Bahasa Inggeris==
{{wikipedia|lang=en}}
==== Kata nama khas====
'''September''' (''jamak'' '''[[Septembers]]''')
# Bulan kesembilan [[kalendar Masihi]], selepas [[August]] dan sebelum [[October]]. Kependekan: '''[[Sep]]''' atau '''[[Sep.]]''', '''[[Sept]]''' atau '''[[Sept.]]'''

===Etimologi===
Daripada bahasa {{inh|en|enm|-}}, daripada bahasa {{der|en|ang|-}} Akhir, daripada perkataan bahasa {{der|ms|fro|septembre}}, {{der|ms|la|September||bulan ketujuh}}, daripada {{m|la|septem||tujuh}}, daripada {{der|en|ine-pro|*septḿ̥||tujuh}}; + {{der|en|la|-ber}}, daripada {{m|la|-bris}} yang merupakan akhiran bersifat; September merupakan bulan ketujuh dalam kalendar Rom.

===Sebutan===
* {{a|UK}} {{AFA|en|/sɛpˈtɛmbə/}}
* {{a|US}} {{enPR|sĕp-tĕmʹbər}} {{AFA|en|/sɛpˈtɛmbəɹ/}}
* {{audio|en|en-us-September.ogg|Audio (US)}}
* {{rhymes|en|ɛmbə(r)}}

===Terbitan===
{{atas3}}
* [[w:en:Black September|Black September]]
* [[endless September]]
* [[eternal September]]
* [[Great September]]
* [[it's always September]]
* [[May-September romance]]
* [[mid-September]]
* [[perpetual September]]
* [[September 10th]]
* [[September 11]]
{{tengah3}}
* [[September call-up]]
* {{w|en:September Campaign|September Campaign}}
* {{w|en:September Convention|September Convention}}
* {{w|en:September Dossier|September Dossier}}
* [[Septembered]]
* [[september elm]]
* [[september equinox]]
* [[Septemberer]]
* {{w|en:September Group|September Group}}
{{tengah3}}
* [[Septemberish]], [[Septembrish]]
* [[Septemberism]]
* {{w|en:September Massacres|September Massacres}}
* [[September people]]
* {{w|en:September Six|September Six}}
* {{w|en:Eternal September|September that never ended}}
* [[September thorn]]
* [[Septembrian]]
* [[Septembrist]]
{{ter-bawah}}

===Tesaurus===
; Sinonim: [[Septembre]] {{qualifier|usang}}

===Lihat juga===
* [[9/11]]

[[Kategori:Kata nama khas bahasa Inggeris]]
[[Kategori:Kata nama khas terhitung bahasa Inggeris]]
[[Kategori:en:Bulan takwim Masihi]]

==Bahasa Jerman==
{{wikipedia|lang=de}}
====Kata nama====
'''September'''  (''genitif'' '''[[Septembers]]''' ''atau'' '''[[September]]''', ''jamak'' '''[[September]]''')
# [[#Bahasa Melayu|September]]

===Sebutan===
* {{AFA|de|/zɛpˈtɛmbɐ/}}
* {{audio|de|De-September.ogg|Audio}}
* {{audio|de|De-September2.ogg|Audio}}

[[Kategori:Kata nama bahasa Jerman]]
{{C|de|Bulan dalam tahun}}

==Bahasa Luxembourg==
{{wikipedia|lang=lb}}
==== Kata nama khas====
'''September''' 
# [[#Bahasa Melayu|September]]

[[Kategori:Kata nama khas bahasa Luxembourg]]
{{C|lb|Bulan dalam tahun}}

==Bahasa Scots==
{{wikipedia|lang=sco}}
==== Kata nama khas====
{{head|sco|kata nama khas}}

# [[#Bahasa Melayu|September]]

===Etimologi===
Daripada {{der|sco|la|september||bulan ketujuh}}.

===Lihat juga===
* {{sense|bulan}} Sebelum: [[August]]. Selepas: [[October]]

{{C|sco|Bulan dalam tahun}}</text>
      <sha1>lit7lsj4tdu1un0u160i9rz58msojqe</sha1>
    </revision>
  </page>
  <page>
    <title>October</title>
    <ns>0</ns>
    <id>9699</id>
    <revision>
      <id>342808</id>
      <parentid>321487</parentid>
      <timestamp>2026-05-16T12:31:49Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <origin>342808</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1506" sha1="buf2577x2aqntazehnhhev1lo0m2pct" xml:space="preserve">{{also|october}}

==Bahasa Inggeris==
{{wikipedia|lang=en}}

===Kata nama khas===
{{en-knk}}

# [[bulan|Bulan]] kesepuluh [[kalendar Masihi]], selepas [[September]] dan sebelum [[November]]. Kependekan: '''[[Oct]]'''; [[Oktober]].

===Etimologi===
{{etymon|en|:inh|enm:&lt;ety:bor&lt;fro:octobre&gt;&gt;}}
Daripada {{inh|en|enm|-}}, dipinjam daripada {{der|en|fro|octobre}}, daripada {{der|en|la|Octōber||bulan kelapan}}, daripada {{der|en|la|octō||eight}}, daripada {{der|en|ine-pro|*oḱtṓw||empat kali dua}}; + {{der|en|la|-ber}}, daripada {{m|la|-bris}}, akhiran pembentuk kata sifat; Oktober ialah bulan kelapan dalam takwim Rom.

===Sebutan===
* {{a|UK}} {{AFA|en|/ɒkˈtəʊbə/}}
* {{a|AS}} {{enPR|äk-tōʹbər}}, {{AFA|en|/ɑkˈtoʊbəɹ/}}
* {{audio|en|en-us-October.ogg|Audio (AS)}}

===Terbitan===
{{atas2}}
* [[mid-October]]
* [[October beer]]
* [[October-bird]]
* [[October effect]]
* [[Octoberfest]]
* [[Octoberist]], [[Octobrist]]
{{tengah2}}
* [[October Revolution]]
* [[October surprise]]
* {{w|October War|lang=en}}
* [[Red October]]
{{ter-bawah}}

===Tesaurus===
; Sinonim: [[Octobre]] {{qualifier|kuno}}.

[[Kategori:Kata nama khas bahasa Inggeris]]
[[Kategori:en:Bulan takwim Masihi]]

==Bahasa Scots==

===Kata nama khas===
{{head|sco|kata nama khas}}

# [[Oktober]]

===Etimologi===
Daripada {{der|sco|la|octōber||yang bulan kelapan}}.

===Sebutan===
* {{AFA|sco|[okˈtobər]}}

===Lihat juga===
* {{sense|bulan}} Sebelum: [[September]]. Selepas: [[November]]

{{C|sco|Bulan dalam tahun}}</text>
      <sha1>buf2577x2aqntazehnhhev1lo0m2pct</sha1>
    </revision>
  </page>
  <page>
    <title>Modul:languages/data/3/j</title>
    <ns>828</ns>
    <id>9767</id>
    <revision>
      <id>342846</id>
      <parentid>265546</parentid>
      <timestamp>2026-05-17T03:51:37Z</timestamp>
      <contributor>
        <username>PeaceSeekers</username>
        <id>3334</id>
      </contributor>
      <origin>342846</origin>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="7518" sha1="nkhxzp70xmnluyo4obnzkqisfhid7ww" xml:space="preserve">local m_langdata = require(&quot;Module:languages/data&quot;)

-- Loaded on demand, as it may not be needed (depending on the data).
local function u(...)
	u = require(&quot;Module:string utilities&quot;).char
	return u(...)
end

local c = m_langdata.chars
local p = m_langdata.puaChars
local s = m_langdata.shared

local m = {}

m[&quot;jaa&quot;] = {
	&quot;Jamamadí&quot;,
	3053275,
	&quot;auf&quot;,
	&quot;Latn&quot;,
}

m[&quot;jab&quot;] = {
	&quot;Hyam&quot;,
	35403,
	&quot;nic-plc&quot;,
	&quot;Latn&quot;,
}

m[&quot;jac&quot;] = {
	&quot;Jakaltek&quot;,
	33393,
	&quot;myn&quot;,
	&quot;Latn&quot;,
}

m[&quot;jad&quot;] = {
	&quot;Jahanka&quot;,
	3913992,
	&quot;dmn-wmn&quot;,
	&quot;Latn&quot;,
}

m[&quot;jae&quot;] = {
	&quot;Jabem&quot;,
	3571232,
	&quot;poz-ocw&quot;,
	&quot;Latn&quot;,
}

m[&quot;jaf&quot;] = {
	&quot;Jara&quot;,
	56289,
	&quot;cdc&quot;,
	&quot;Latn&quot;,
}

m[&quot;jah&quot;] = {
	&quot;Jah Hut&quot;,
	2742661,
	&quot;mkh-asl&quot;,
	&quot;Latn&quot;,
}

m[&quot;jaj&quot;] = {
	&quot;Zazao&quot;,
	3574969,
	&quot;poz-ocw&quot;,
	&quot;Latn&quot;,
}

m[&quot;jak&quot;] = {
	&quot;Jakun&quot;,
	4216968,
	&quot;poz-mly&quot;,
	&quot;Latn&quot;,
}

m[&quot;jal&quot;] = {
	&quot;Yalahatan&quot;,
	8047298,
	&quot;poz-cma&quot;,
	&quot;Latn&quot;,
}

m[&quot;jam&quot;] = {
	&quot;Kreol Jamaica&quot;,
	35939,
	&quot;crp&quot;,
	&quot;Latn&quot;,
	ancestors = &quot;en&quot;,
}

m[&quot;jan&quot;] = {
	&quot;Janday&quot;,
	6150919,
	&quot;aus-pam&quot;,
	&quot;Latn&quot;,
}

m[&quot;jao&quot;] = {
	&quot;Yanyuwa&quot;,
	34241,
	&quot;aus-pam&quot;,
	&quot;Latn&quot;,
}

m[&quot;jaq&quot;] = {
	&quot;Yaqay&quot;,
	8049134,
	&quot;ngf&quot;,
	&quot;Latn&quot;,
}

m[&quot;jas&quot;] = {
	&quot;New Caledonian Javanese&quot;,
	12953527,
	&quot;poz-sus&quot;,
	&quot;Latn&quot;,
	ancestors = &quot;jv&quot;,
}

m[&quot;jat&quot;] = {
	&quot;Jakati&quot;,
	4159744,
	&quot;inc-pan&quot;,
	ancestors = &quot;lah&quot;,
}

m[&quot;jau&quot;] = {
	&quot;Yaur&quot;,
	8050346,
	&quot;poz-hce&quot;,
	&quot;Latn&quot;,
}

m[&quot;jax&quot;] = {
	&quot;Melayu Jambi&quot;,
	3915769,
	&quot;poz-mly&quot;,
	&quot;Latn&quot;,
}

m[&quot;jay&quot;] = {
	&quot;Yan-nhangu&quot;,
	10723405,
	&quot;aus-yol&quot;,
	&quot;Latn&quot;,
}

m[&quot;jaz&quot;] = {
	&quot;Jawe&quot;,
	3163200,
	&quot;poz-cln&quot;,
	&quot;Latn&quot;,
}

m[&quot;jbj&quot;] = {
	&quot;Arandai&quot;,
	4784070,
	&quot;ngf&quot;,
	&quot;Latn&quot;,
}

m[&quot;jbk&quot;] = {
	&quot;Barikewa&quot;,
	nil,
	&quot;ngf&quot;,
	&quot;Latn&quot;,
}

m[&quot;jbn&quot;] = {
	&quot;Nefusa&quot;,
	36151,
	&quot;ber&quot;,
}

m[&quot;jbo&quot;] = {
	&quot;Lojban&quot;,
	36350,
	&quot;art&quot;,
	&quot;Latn&quot;,
	type = &quot;appendix-constructed&quot;,
}

m[&quot;jbr&quot;] = {
	&quot;Jofotek-Bromnya&quot;,
	16886849,
	&quot;paa-tkw&quot;,
}

m[&quot;jbt&quot;] = {
	&quot;Jabutí&quot;,
	2060023,
	&quot;sai-mje&quot;,
	&quot;Latn&quot;,
}

m[&quot;jbu&quot;] = {
	&quot;Jukun Takum&quot;,
	35447,
	&quot;nic-jkn&quot;,
	&quot;Latn&quot;,
}

m[&quot;jbw&quot;] = {
	&quot;Yawijibaya&quot;,
	31722921,
	&quot;aus-wor&quot;,
	&quot;Latn&quot;,
}

m[&quot;jcs&quot;] = {
	&quot;Bahasa Isyarat Negara Jamaica&quot;,
	6127418,
	&quot;sgn&quot;,
	&quot;Latn&quot;, -- when documented
}

m[&quot;jct&quot;] = {
	&quot;Krymchak&quot;,
	33723,
	&quot;trk-kcu&quot;,
	&quot;Latn, Cyrl&quot;,
}

m[&quot;jda&quot;] = {
	&quot;Jad&quot;,
	12633440,
	&quot;sit-las&quot;,
}

m[&quot;jdg&quot;] = {
	&quot;Jadgali&quot;,
	13560607,
	&quot;inc-snd&quot;,
}

m[&quot;jdt&quot;] = {
	&quot;Judeo-Tat&quot;,
	56495,
	&quot;ira-swi&quot;,
	&quot;Latn, Cyrl, Hebr&quot;,
	ancestors = &quot;fa&quot;,
	translit = &quot;jdt-translit&quot;,
}

m[&quot;jeb&quot;] = {
	&quot;Jebero&quot;,
	967031,
	&quot;sai-cah&quot;,
}

m[&quot;jee&quot;] = {
	&quot;Jerung&quot;,
	56372,
	&quot;sit-kiw&quot;,
}

m[&quot;jeg&quot;] = {
	&quot;Jeng&quot;,
	5091274,
	&quot;mkh-ban&quot;,
	&quot;Latn&quot;,
}

m[&quot;jeh&quot;] = {
	&quot;Jeh&quot;,
	3914636,
	&quot;mkh-ban&quot;,
	&quot;Latn&quot;,
}

m[&quot;jei&quot;] = {
	&quot;Yei&quot;,
	8051326,
}

m[&quot;jek&quot;] = {
	&quot;Jeri Kuo&quot;,
	11031936,
	&quot;dmn-jje&quot;,
	&quot;Latn&quot;,
}

m[&quot;jel&quot;] = {
	&quot;Yelmek&quot;,
	8052020,
}

m[&quot;jen&quot;] = {
	&quot;Dza&quot;,
	35558,
	&quot;alv-bwj&quot;,
}

m[&quot;jer&quot;] = {
	&quot;Jere&quot;,
	3915449,
	&quot;nic-jer&quot;,
}

m[&quot;jet&quot;] = {
	&quot;Manem&quot;,
	6748412,
	&quot;paa-brd&quot;,
}

m[&quot;jeu&quot;] = {
	&quot;Jonkor Bourmataguil&quot;,
	56269,
}

m[&quot;jgb&quot;] = {
	&quot;Ngbee&quot;,
	7022243,
}

-- &quot;jge&quot; IS TREATED AS &quot;ka&quot;, SEE WT:LT

m[&quot;jgk&quot;] = {
	&quot;Gwak&quot;,
	17523694,
	&quot;nic-jrw&quot;,
}

m[&quot;jgo&quot;] = {
	&quot;Ngomba&quot;,
	36287,
	&quot;bai&quot;,
	&quot;Latn&quot;,
}

m[&quot;jhi&quot;] = {
	&quot;Jehai&quot;,
	3176748,
	&quot;mkh-asl&quot;,
}

m[&quot;jhs&quot;] = {
	&quot;Bahasa Isyarat Jhankot&quot;,
	6190889,
	&quot;sgn&quot;,
}

m[&quot;jia&quot;] = {
	&quot;Jina&quot;,
	56297,
}

m[&quot;jib&quot;] = {
	&quot;Jibu&quot;,
	3914448,
	&quot;nic-jkn&quot;,
	&quot;Latn&quot;,
}

m[&quot;jic&quot;] = {
	&quot;Tol&quot;,
	3178609,
	&quot;nai-jcq&quot;,
	&quot;Latn&quot;,
}

m[&quot;jid&quot;] = {
	&quot;Bu&quot;,
	3913321,
	&quot;nic-nin&quot;,
	&quot;Latn&quot;,
}

m[&quot;jie&quot;] = {
	&quot;Jilbe&quot;,
	56281,
}

m[&quot;jig&quot;] = {
	&quot;Jingulu&quot;,
	6202435,
	&quot;aus-mir&quot;,
}

m[&quot;jih&quot;] = {
	&quot;Shangzhai&quot;,
	25559440,
	&quot;sit-rgy&quot;,
}

m[&quot;jii&quot;] = {
	&quot;Jiiddu&quot;,
	56769,
	&quot;cus-som&quot;,
	&quot;Latn&quot;,
}

m[&quot;jil&quot;] = {
	&quot;Jilim&quot;,
	6192674,
	&quot;ngf-mad&quot;,
}

m[&quot;jim&quot;] = {
	&quot;Jimjimen&quot;,
	56288,
	&quot;cdc-cbm&quot;,
	&quot;Latn&quot;,
}

m[&quot;jio&quot;] = {
	&quot;Jiamao&quot;,
	3178570,
	nil,
	&quot;Latn&quot;,
}

m[&quot;jiq&quot;] = {
	&quot;Khroskyabs&quot;,
	3118757,
	&quot;sit-rgy&quot;,
}

m[&quot;jit&quot;] = {
	&quot;Jita&quot;,
	6203228,
	&quot;bnt-haj&quot;,
	&quot;Latn&quot;,
}

m[&quot;jiu&quot;] = {
	&quot;Youle Jino&quot;,
	12952530,
	&quot;tbq-jin&quot;,
}

m[&quot;jiv&quot;] = {
	&quot;Shuar&quot;,
	617291,
	&quot;sai-jiv&quot;,
	&quot;Latn&quot;,
}

m[&quot;jiy&quot;] = {
	&quot;Buyuan Jino&quot;,
	12952528,
	&quot;tbq-jin&quot;,
}

m[&quot;jje&quot;] = {
	&quot;Jeju&quot;,
	129648,
	&quot;qfa-kor&quot;,
	&quot;Kore&quot;,
	ancestors = &quot;okm&quot;,
	translit = &quot;jje-translit&quot;,
	entry_name = s[&quot;Kore-entryname&quot;],
}

m[&quot;jjr&quot;] = {
	&quot;Zhár&quot;,
	17523697,
	&quot;nic-jrw&quot;,
}

m[&quot;jka&quot;] = {
	&quot;Kaera&quot;,
	16910923,
	&quot;ngf&quot;,
	&quot;Latn&quot;,
}

m[&quot;jko&quot;] = {
	&quot;Kubo&quot;,
	12952670,
	&quot;ngf&quot;,
}

m[&quot;jkr&quot;] = {
	&quot;Koro (India)&quot;,
	36162,
	&quot;sit-gsi&quot;,
}

m[&quot;jku&quot;] = {
	&quot;Labir&quot;,
	1990210,
	&quot;nic-jrn&quot;,
}

m[&quot;jle&quot;] = {
	&quot;Ngile&quot;,
	36329,
	&quot;alv-tal&quot;,
}

m[&quot;jls&quot;] = {
	&quot;Bahasa Isyarat Jamaica&quot;,
	6127433,
	&quot;sgn&quot;,
	&quot;Latn&quot;, -- when documented
}

m[&quot;jma&quot;] = {
	&quot;Dima&quot;,
	5277140,
}

m[&quot;jmb&quot;] = {
	&quot;Zumbun&quot;,
	56252,
	&quot;cdc-wst&quot;,
}

m[&quot;jmc&quot;] = {
	&quot;Machame&quot;,
	12952751,
	&quot;bnt-chg&quot;,
	&quot;Latn&quot;,
}

m[&quot;jmd&quot;] = {
	&quot;Yamdena&quot;,
	8048030,
	&quot;poz-cet&quot;,
	&quot;Latn&quot;,
}

m[&quot;jmi&quot;] = {
	&quot;Jimi&quot;,
	3502308,
	&quot;cdc-wst&quot;,
	&quot;Latn&quot;,
}

m[&quot;jml&quot;] = {
	&quot;Jumli&quot;,
	6310993,
	&quot;inc-pah&quot;,
}

m[&quot;jmn&quot;] = {
	&quot;Makuri Naga&quot;,
	6740482,
	&quot;sit-aao&quot;,
}

m[&quot;jmr&quot;] = {
	&quot;Kamara&quot;,
	35561,
	&quot;nic-dag&quot;,
}

-- &quot;jms&quot; IS TREATED AS &quot;mff&quot;, SEE WT:LT

m[&quot;jmw&quot;] = {
	&quot;Mouwase&quot;,
	nil,
	&quot;ngf&quot;,
	&quot;Latn&quot;,
}

m[&quot;jmx&quot;] = {
	&quot;Western Juxtlahuaca Mixtec&quot;,
	12953731,
	&quot;omq-mxt&quot;,
	&quot;Latn&quot;,
}

m[&quot;jna&quot;] = {
	&quot;Jangshung&quot;,
	12633505,
	&quot;sit-kin&quot;,
	&quot;Takr&quot;
}

m[&quot;jnd&quot;] = {
	&quot;Jandavra&quot;,
	6150941,
	&quot;inc-wes&quot;,
	&quot;Arab&quot;,
	ancestors = &quot;gu&quot;,
}

m[&quot;jng&quot;] = {
	&quot;Yangman&quot;,
	10723416,
	&quot;aus-yng&quot;,
}

m[&quot;jni&quot;] = {
	&quot;Janji&quot;,
	3915330,
	&quot;nic-jer&quot;,
}

m[&quot;jnj&quot;] = {
	&quot;Yemsa&quot;,
	36873,
	&quot;omv&quot;,
}

m[&quot;jnl&quot;] = {
	&quot;Rawat&quot;,
	7296948,
	&quot;sit-gma&quot;,
}

m[&quot;jns&quot;] = {
	&quot;Jaunsari&quot;,
	6164857,
	&quot;him&quot;,
}

m[&quot;job&quot;] = {
	&quot;Joba&quot;,
	13123409,
	&quot;bnt-shh&quot;,
}

m[&quot;jod&quot;] = {
	&quot;Wojenaka&quot;,
	11029540,
	&quot;dmn-mnk&quot;,
}

m[&quot;jor&quot;] = {
	&quot;Jorá&quot;,
	5393974,
	&quot;tup-gua&quot;,
	&quot;Latn&quot;,
}

m[&quot;jos&quot;] = {
	&quot;Bahasa Isyarat Jordan&quot;,
	6534917,
	&quot;sgn&quot;,
	&quot;Sgnw&quot;,
}

m[&quot;jow&quot;] = {
	&quot;Jowulu&quot;,
	3914487,
	&quot;dmn-mnw&quot;,
	&quot;Latn&quot;,
}

-- &quot;jpa&quot; IS NOT USED, SEE WT:LT

m[&quot;jpr&quot;] = {
	&quot;Judeo-Persian&quot;,
	33367,
	&quot;ira-swi&quot;,
	&quot;Hebr&quot;,
	ancestors = &quot;fa&quot;,
}

m[&quot;jqr&quot;] = {
	&quot;Jaqaru&quot;,
	33443,
	&quot;sai-aym&quot;,
	&quot;Latn&quot;,
}

m[&quot;jra&quot;] = {
	&quot;Jarai&quot;,
	33370,
	&quot;cmc&quot;,
	&quot;Latn&quot;,
}

m[&quot;jrr&quot;] = {
	&quot;Jiru&quot;,
	6203123,
	&quot;nic-jkn&quot;,
}

m[&quot;jru&quot;] = {
	&quot;Japrería&quot;,
	3441409,
	&quot;sai-yuk&quot;,
	&quot;Latn&quot;,
}

m[&quot;jsl&quot;] = {
	&quot;Bahasa Isyarat Jepun&quot;,
	35601,
	&quot;sgn-jsl&quot;,
}

m[&quot;jua&quot;] = {
	&quot;Júma&quot;,
	12953587,
	&quot;tup-gua&quot;,
	&quot;Latn&quot;,
}

m[&quot;jub&quot;] = {
	&quot;Wannu&quot;,
	3914905,
	&quot;nic-jkn&quot;,
}

m[&quot;juc&quot;] = {
	&quot;Jurchen&quot;,
	56731,
	&quot;tuw-jrc&quot;,
	&quot;Jurc, Hani&quot;,
}

m[&quot;jud&quot;] = {
	&quot;Worodougou&quot;,
	11155821,
	&quot;dmn-mnk&quot;,
}

m[&quot;juh&quot;] = {
	&quot;Hone&quot;,
	5964576,
	&quot;nic-jkn&quot;,
	&quot;Latn&quot;,
}

m[&quot;jui&quot;] = {
	&quot;Ngadjuri&quot;,
	16897028,
	&quot;aus-pam&quot;,
	&quot;Latn&quot;,
}

m[&quot;juk&quot;] = {
	&quot;Wapan&quot;,
	3914914,
	&quot;nic-jkn&quot;,
}

m[&quot;jul&quot;] = {
	&quot;Jirel&quot;,
	56863,
	&quot;sit-tib&quot;,
}

m[&quot;jum&quot;] = {
	&quot;Jumjum&quot;,
	11283696,
	&quot;sdv&quot;,
}

m[&quot;jun&quot;] = {
	&quot;Juang&quot;,
	33362,
	&quot;mun&quot;,
	&quot;Orya&quot;,
}

m[&quot;juo&quot;] = {
	&quot;Jiba&quot;,
	6191995,
	&quot;nic-jkn&quot;,
}

m[&quot;jup&quot;] = {
	&quot;Hupdë&quot;,
	3143384,
	&quot;sai-nad&quot;,
	&quot;Latn&quot;,
}

m[&quot;jur&quot;] = {
	&quot;Jurúna&quot;,
	4023175,
	&quot;tup&quot;,
	&quot;Latn&quot;,
}

m[&quot;jus&quot;] = {
	&quot;Bahasa Isyarat Jumla&quot;,
	6310991,
	&quot;sgn&quot;,
}

m[&quot;jut&quot;] = {
	&quot;Jutish&quot;,
	1340322,
	&quot;gmq-eas&quot;,
	&quot;Latn&quot;,
	ancestors = &quot;da&quot;,
}

m[&quot;juu&quot;] = {
	&quot;Ju&quot;,
	3914897,
}

m[&quot;juw&quot;] = {
	&quot;Wãpha&quot;,
	3914934,
	&quot;nic-jkn&quot;,
	&quot;Latn&quot;,
}

m[&quot;juy&quot;] = {
	&quot;Juray&quot;,
	6314963,
	&quot;mun&quot;,
}

m[&quot;jvd&quot;] = {
	&quot;Javindo&quot;,
	2719893,
	&quot;crp&quot;,
	&quot;Latn&quot;,
}

m[&quot;jvn&quot;] = {
	&quot;Jawa Caribbean&quot;,
	11732256,
	&quot;poz-sus&quot;,
	&quot;Latn&quot;,
	ancestors = &quot;jv&quot;,
}

m[&quot;jwi&quot;] = {
	&quot;Jwira-Pepesa&quot;,
	35467,
	&quot;alv-ctn&quot;,
	&quot;Latn&quot;,
}

-- &quot;jya&quot; IS TREATED AS &quot;sit-sit&quot;, &quot;sit-jap&quot;, &quot;sit-tsh&quot;, &quot;sit-zbu&quot;, SEE WT:LT

m[&quot;jyy&quot;] = {
	&quot;Jaya&quot;,
	641720,
	&quot;csu-bgr&quot;,
	&quot;Latn&quot;,
}

return require(&quot;Module:languages&quot;).finalizeData(m, &quot;language&quot;)</text>
      <sha1>nkhxzp70xmnluyo4obnzkqisfhid7ww</sha1>
    </revision>
  </page>
  <page>
    <title>November</title>
    <ns>0</ns>
    <id>9800</id>
    <revision>
      <id>342807</id>
      <parentid>334086</parentid>
      <timestamp>2026-05-16T12:31:20Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <origin>342807</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="9526" sha1="5n5u12vm13zb6dxwjisarj7xrd5au8u" xml:space="preserve">{{also|november|nóvember}}
{{Pautan Projek Wikimedia}}

==Rentas bahasa==
====Simbol====
# Huruf [[N]] di [[abjad ejaan ICAO]].

===Sebutan===
* {{AFA|mul|[noˈvembə]}}

[[Kategori:Simbol rentas bahasa]]
[[Kategori:Abjad ejaan ICAO]]

==Bahasa Melayu==
{{wikipedia|lang=ms}}
===Kata nama khas===
{{ms-knk}}
# Bulan kesebelas dalam tahun Masihi yang mengandungi 30 hari, antara [[Oktober]] dan [[Disember]].

===Etimologi===
Daripada {{bor|ms|en|November}}, daripada {{der|ms|enm}}, daripada {{der|ms|fro|novembre}}, daripada {{der|ms|la|november}}, daripada bahasa Latin {{term|la|''novem''}}, daripada {{der|ms|ine-pro|[[*h₁néwn̥]]}}.

===Sebutan===
* {{dewan|nõ|vém|ber}}
* {{AFA|ms|[novɛmbə(r)]}}
* {{rhymes|ms|bə(r)|ə(r)}}
* {{penyempangan|ms|No|vem|ber}}
* {{audio|ms|November (Malay).ogg}}

===Tulisan Jawi===
{{ARchar|[[نوۏيمبر]]}}

===Terjemahan===
{{ter-atas|bulan kesebelas}}
* Abaza: {{t|abq|ноябрь}}
* Abkhaz: {{t|ab|абҵара}}
* Afrikaans: {{t+|af|November}}
* Alabama: {{t|akz|hasiholtina istapókkòolawah cháffàaka}}, {{t|akz|Nofìmba}}
* Albania: {{t|sq|nëntor}}
* Alutiiq: {{t|ems|Quyawim Iralua}}
* Amhara: {{t|am|ኖቬምበር|sc=Ethi}}
* Apache:
*: Apache Barat: {{t|apw|Kǫʼ Bąąh Náłkʼas}}
* Arab: {{t+|ar|نُوفمْبر|tr=nufímbir, nufámbir, nufámbar|m}}, {{t|ar|تِشرينُ الثّانِي|tr=tišrīnu θ-θāni|m}}
*: Arab Mesir: {{t|arz|نوفمبر|m|tr=novamber|sc=Arab}}
* Aragones: {{t+|an|nobiembre|m}}
* Armenia: {{t+|hy|նոյեմբեր}}
*: Armenian Lama: {{t|xcl|նոյեմբեր}}
* Aromania: {{t|rup|nuembru}}, {{t|rup|brumar}}
* Asturia: {{t+|ast|payares|m}}, {{t+|ast|noviembre}}
* Azeri: {{t+|az|noyabr}}
* Basque: {{t+|eu|azaro}}
* Belanda: {{t+|nl|november}}
* Belarus: {{t|be|лістапа́д|m}}
* Benggali: {{t|bn|নভেম্বর|sc=Beng}}
* Bislama: {{t|bi|novemba}}
* Bulgaria: {{t+|bg|ное́мври|m}}
* Burma: {{t+|my|နိုဝင်ဘာ|sc=Mymr}}
* Catalonia: {{t+|ca|novembre|m}}
* Chechen: {{t|ce|Лахьанан-бутт|sc=Cyrl}}
* Cherokee: {{t|chr|ᏅᏓᏕᏩ|tr=Nvdadewa|sc=Cher}}
* Chuvash: {{t|cv|чӳк}}
* Cina:
*: Mandarin: {{t+|cmn|十一月|tr=shíyīyuè}}
* Cornish: {{t|kw|mys du}}
* Czech: {{t+|cs|listopad|m}}
* Dakota: {{t|dak|Tahecapšuŋwi}}
* Denmark: {{t+|da|november}}
* Esperanto: {{t+|eo|novembro}}, {{t|eo|Novembro}}
* Estonia: {{t+|et|november}}
* Ewe: {{t|ee|Adeɛmekpɔxe}}, {{t|ee|Nɔvember}}
* Faroe: {{t|fo|november|m}}, {{t|fo|novembur|m}}
* Fiji: {{t|fj|Noveba}}
* Finland: {{t+|fi|marraskuu}}
* Frisia Barat: {{t+|fy|novimber}}, {{t+|fy|slachtmoanne}}
* Friulia: {{t|fur|Novembar|m}}
* Gaelik Scotland: {{t|gd|Samhain|f|alt=an t-Samhain}}
* Galicia: {{t+|gl|novembro|m}}, {{t|gl|santos|m}}
* Georgia: {{t+|ka|ნოემბერი}}
* Greek: {{t+|el|Νοέμβριος|m}}, {{t+|el|Νοέμβρης|m}}
* Greenland: {{t+|kl|Novembari}}
* Hawaii: {{t|haw|Nowemapa}}
* Hindi: {{t+|hi|नवम्बर|tr=navambar}}
* Hungary: {{t+|hu|november}}
* Ibrani: {{t+|he|נובמבר|alt=נוֹבֶמְבֶּר|tr=novémber}}
* Iceland: {{t+|is|nóvember|m}}, {{t|is|nóvembermánuður|m}}
* Ido: {{t+|io|novembro}}
* Indonesia: {{t|id|November}}
* Inggeris: {{t+|en|November}}
* Inggeris Kuno: {{t|ang|blōtmōnaþ|m}}
* Interlingua: {{t|ia|novembre}}
* Ireland: {{t+|ga|Samhain|f}}
* Itali: {{t+|it|novembre|m}}
* Jepun: {{t+|ja|十一月|tr=じゅういちがつ, jūichigatsu}}, {{t+|ja|霜月|tr=しもつき, shimotsuki}}
* Jerman: {{t+|de|November|m}}, {{qualifier|arkaik}} {{t+|de|Nebelung|m}}
* Jerman Kasar:
*: Jerman Kasar Jerman: {{t|nds-de|November|m}}
*: Saxon Kasar Belanda: {{t|nds-nl|november|m}}
* Kabuverdianu: {{t|kea|nuvembru|m}} {{qualifier|Badiu|Santiago}}, {{t|kea|n'vembr'|m}} {{qualifier|São Vicente}}
* Kashubia: {{t+|csb|lëstopadnik|m}}
* Kazakh: {{t+|kk|қараша}}

* Khmer: {{t+|km|វិច្ឆិកា|tr=weuchăgā}}
* Kiribati: {{t|gil|Nobembwa|sc=Cyrl}}
* Kreol Haiti: {{t|ht|novanm}}
* Korea: {{t+|ko|십일월|tr=sibilwol|sc=Kore}}
* Ladin: {{t|lld|november}}, {{t|lld|nuvember}}
* Lao: {{t|lo|ເດືອນພະຈິກ|sc=Laoo}}
* Latin: {{t+|la|november}}
* Latvia: {{t+|lv|novembris|m}}
* Lezgi: {{t|lez|цӏехуьл}}
* Limburg: {{t+|li|November}}
* Lithuania: {{t+|lt|lapkritis|m}}
* Livonia: {{t|liv|novembõr}}, {{t|liv|kīlmakū}}
* Luxembourg: {{t+|lb|November|m}}, {{t+|lb|Allerhellgemount|m}}, {{t+|lb|Wantermount|m}}
* Macedonia: {{t+|mk|ное́мври|m}}
* Malta: {{t|mt|Novembru}}
* Manchu: (omšon biya)
* Maori: {{t|mi|Noema}}
* Montagnais: {{t|moe|takuatshi-pishimᵘ}}
* Navajo: {{t|nv|Níłchʼitsʼósí}}
* Neapolitan: {{t|nap|nuvèmbre|m}}
* Norway: {{t+|no|november}}
* Novial: {{t|nov|novembre}}
* Occitan: {{t+|oc|novembre|m}}
* Ojibwe: {{t|oj|gashkadino-giizis}}
* Oriya: {{t|or|ନଭେମ୍ବର|sc=Orya}}
* Ossetia: {{t|os|ноябрь}}
* Parsi: {{t+|fa|نوامبر|tr=novâmbr}}
* Perancis: {{t+|fr|novembre|m}}
* Poland: {{t+|pl|listopad|m}}
* Portugis: {{t+|pt|novembro|m}}
* Romania: {{t+|ro|noiembrie|m}}, {{qualifier|pop}} {{t+|ro|brumar}}
* Romansch: {{t|rm|november|m}}
* Rusia: {{t+|ru|ноя́брь|m}}
* Samoa: {{t|sm|novema}}
* Sardinia: {{t|sc|donniasantu}}, {{t|sc|santandria}}
* Sepanyol: {{t+|es|noviembre|m}}
* Serbo-Croatia:
*: Cyril: {{t|sh|новембар|m|sc=Cyrl}}, {{t|sh|студени|m|sc=Cyrl}}
*: Rumi: {{t+|sh|novembar|m|sc=Latn}}, {{t+|sh|studeni|m|sc=Latn}}
* Sicilia: {{t+|scn|nuvemmiru|m}}
* Skolt Sami: {{t|sms|vuˊvrrmmään}}, {{t|sms|skamm´mään}}
* Slovak: {{t+|sk|november|m}}
* Slovene: {{t|sl|novêmber|m}}
* Sotho: {{t+|st|Pudungwana}}
* Sweden: {{t+|sv|november}}
* Tagalog: {{t|tl|nobyembre}}
* Tahiti: {{t|ty|novema}}
* Tajik: {{t+|tg|ноябр}}
* Tatar: {{t|tt|nöyäber}}
* Telugu: {{t|te|నవంబరు}}
* Thai: {{t+|th|พฤศจิกายน|tr=phrēut sà jì gaa yohn}}
* Tok Pisin: {{t|tpi|novemba}}
* Tonga: {{t|to|nōvema}}
* Turki: {{t+|tr|kasım}}, {{t|tr|Teşrini Sani}} {{qualifier|kuno}}
* Ukraine: {{t+|uk|листопа́д|m}}
* Urdu: {{t|ur|نومبر|tr=nuvembar}}
* Venice: {{t+|vec|novenbre}}
* Vietnam: {{t+|vi|tháng Mười một}}, {{t+|vi|tháng Mười Một}}, {{t+|vi|tháng mười một}}
* Volapük: {{t+|vo|novul}}
* Võro: {{t|vro|märtekuu}}
* Walloon: {{t+|wa|nôvimbe|m}}
* Wales: {{t+|cy|Tachwedd|m}}
* Wolof: {{t|wo|Nowembar}}
* Yiddish: {{t+|yi|נאָוועמבער|m|tr=november, nowember|sc=Hebr}}
* Yup'ik: {{t|esu|Cauyarvik}}
* Zuni: {{t|zun|Kok A:wiyanna}}, {{t|zun|Yachun Kwa'shi'amme}}
{{ter-bawah}}

===Pautan luar===
* {{R:PRPM}}

[[Kategori:ms:Bulan takwim Masihi]]

==Bahasa Afrikaans==
{{wikipedia|lang=af}}
====Kata nama====
'''November''' (''jamak'' '''[[Novembermaande]]''')
# [[#Bahasa Melayu|November]]

===Sebutan===
* {{AFA|af|[nuˈfem(b)ər]}}

===Tulisan Arab===
{{ARchar|نُوفَِمْبِرْ}}

===Tesaurus===
; Sinonim: [[Nov.]], [[Nófember]].

[[Kategori:Kata nama bahasa Afrikaans]]
{{C|af|Bulan dalam tahun}}

==Bahasa Indonesia==
{{wikipedia|lang=id}}
====Kata nama====
# [[#Bahasa Melayu|November]]

===Etimologi===
Daripada {{bor|id|nl|november}}.

[[Kategori:Kata nama bahasa Indonesia]]
{{C|id|Bulan dalam tahun}}

==Bahasa Inggeris==
{{wikipedia|lang=en}}
====Kata nama khas====
{{en-knk}}

# [[bulan|Bulan]] kesebelas [[kalendar Masihi]], selepas [[October]] dan sebelum [[December]]. Kependekan: '''[[Nov]]''' atau '''[[Nov.]]'''
# Huruf ''N'' di [[abjad ejaan ICAO]].

===Etimologi===
Daripada {{inh|en|enm}}, daripada {{bor|en|fro|novembre}}, daripada {{inh|fro|la|november||bulan kesembilan}}, daripada bahasa Latin {{term|la|''novem''}}, daripada {{inh|la|ine-pro|*h₁néwn̥||sembilan}}; + bahasa Latin {{term|la|''-ber''}}, daripada akhiran kata sifat {{term|la|''-bris''}}; November dahulu merupakan bulan kesembilan dalam kalendar Roman.

===Sebutan===
* {{a|UK}} {{AFA|en|/nəʊˈvɛmbə/}}
* {{a|AS}} {{enPR|nō-vĕmʹbər}}, {{AFA|en|/noʊˈvɛmbəɹ/}}
* {{penyempangan|en|No|vem|ber}}
* {{audio|en|en-us-November.ogg|Audio (US)}}
* {{rhymes|en|ɛmbə(r)}}

===Terbitan===
{{der-top|Terbitan}}
* [[mid-November]]
* [[November class]]
* {{w|November Coalition|lang=en}}
* [[November criminal]]
* [[November Eve]]
* {{w|November Group|lang=en}}
{{der-mid}}
* [[Novemberish]]
* [[November moth]]
* [[November Revolution]]
* [[November Uprising]]
* [[Novembery]], [[Novembry]]
* [[Witch of November]]
{{der-bottom}}

===Tesaurus===
; Sinonim: [[Novembre]] {{qualifier|kuno}}

[[Kategori:Kata nama khas terhitung bahasa Inggeris]]
[[Kategori:en:Bulan takwim Masihi]]

==Bahasa Jerman==
{{wikipedia|lang=de}}
====Kata nama====
'''November'''  (''genitif'' '''[[Novembers]]''' ''atau'' '''[[November]]''', ''jamak'' '''[[November]]''')
# [[#Bahasa Melayu|November]]

===Sebutan===
* {{AFA|de|/noˈvɛmbɐ/}}
* {{rhymes|de|ɛmbɐ}}
* {{penyempangan|de|No|vem|ber}}
* {{audio|de|De-November.ogg|audio}}
* {{audio|de|De-November2.ogg|audio}}

[[Kategori:Kata nama bahasa Jerman]]
{{C|de|Bulan dalam tahun}}

==Bahasa Luxembourg==
{{wikipedia|lang=lb}}
====Kata nama khas====
'''November''' 
# [[#Bahasa Melayu|November]]

[[Kategori:Kata nama khas bahasa Luxembourg]]
{{C|lb|Bulan dalam tahun}}

==Bahasa Scots==
{{wikipedia|lang=sco}}
====Kata nama khas====
# [[November]]

===Etimologi===
Daripada {{bor|sco|la|november||bulan kesembilan}}.

===Sebutan===
* {{AFA|sco|[noːvɛmˈbər]}}

====Lihat juga====
* {{sense|bulan}} Sebelum: [[October]]. Selepas: [[December]]

[[Kategori:Kata nama khas bahasa Scots]]
{{C|sco|Bulan dalam tahun}}</text>
      <sha1>5n5u12vm13zb6dxwjisarj7xrd5au8u</sha1>
    </revision>
  </page>
  <page>
    <title>Modul:languages/data/3/f</title>
    <ns>828</ns>
    <id>9810</id>
    <revision>
      <id>342849</id>
      <parentid>254977</parentid>
      <timestamp>2026-05-17T04:01:54Z</timestamp>
      <contributor>
        <username>PeaceSeekers</username>
        <id>3334</id>
      </contributor>
      <minor />
      <origin>342849</origin>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="5597" sha1="g3p71awi780ckf2w77tttlvtcga4l3w" xml:space="preserve">local m_langdata = require(&quot;Module:languages/data&quot;)

-- Loaded on demand, as it may not be needed (depending on the data).
local function u(...)
	u = require(&quot;Module:string utilities&quot;).char
	return u(...)
end

local c = m_langdata.chars
local p = m_langdata.puaChars
local s = m_langdata.shared

local m = {}

m[&quot;faa&quot;] = {
	&quot;Fasu&quot;,
	3446687,
	&quot;paa-kut&quot;,
	&quot;Latn&quot;,
}

m[&quot;fab&quot;] = {
	&quot;Annobon&quot;,
	34992,
	&quot;crp&quot;,
	&quot;Latn&quot;,
	ancestors = &quot;pt&quot;,
}

m[&quot;fad&quot;] = {
	&quot;Wagi&quot;,
	7959569,
	&quot;ngf-mad&quot;,
	&quot;Latn&quot;,
}

m[&quot;faf&quot;] = {
	&quot;Fagani&quot;,
	3063759,
	&quot;poz-sls&quot;,
	&quot;Latn&quot;,
}

m[&quot;fag&quot;] = {
	&quot;Finongan&quot;,
	3450761,
	&quot;ngf-fin&quot;,
	&quot;Latn&quot;,
}

m[&quot;fah&quot;] = {
	&quot;Baissa Fali&quot;,
	3446632,
	&quot;nic-bco&quot;,
	&quot;Latn&quot;,
}

m[&quot;fai&quot;] = {
	&quot;Faiwol&quot;,
	3501773,
	&quot;ngf-okk&quot;,
	&quot;Latn&quot;,
}

m[&quot;faj&quot;] = {
	&quot;Faita&quot;,
	976953,
	&quot;ngf-mad&quot;,
	&quot;Latn&quot;,
}

m[&quot;fak&quot;] = {
	&quot;Fang (Beboid)&quot;,
	5433811,
	&quot;nic-beb&quot;,
	&quot;Latn&quot;,
}

m[&quot;fal&quot;] = {
	&quot;Fali Selatan&quot;,
	15637351,
	&quot;alv-fli&quot;,
	&quot;Latn&quot;,
}

m[&quot;fam&quot;] = {
	&quot;Fam&quot;,
	35290,
	&quot;nic-mmb&quot;,
	&quot;Latn&quot;,
}

m[&quot;fan&quot;] = {
	&quot;Fang (Bantu)&quot;,
	33484,
	&quot;bnt-btb&quot;,
	&quot;Latn&quot;,
}

m[&quot;fap&quot;] = {
	&quot;Palor&quot;,
	36318,
	&quot;alv-cng&quot;,
	&quot;Latn&quot;,
}

m[&quot;far&quot;] = {
	&quot;Fataleka&quot;,
	3067168,
	&quot;poz-sls&quot;,
	&quot;Latn&quot;,
}

-- &quot;fat&quot; IS TREATED AS &quot;ak&quot;, SEE WT:LT

m[&quot;fau&quot;] = {
	&quot;Fayu&quot;,
	5439113,
	&quot;paa-lkp&quot;,
	&quot;Latn&quot;,
}

m[&quot;fax&quot;] = {
	&quot;Fala&quot;,
	300402,
	&quot;roa-ibe&quot;,
	&quot;Latn&quot;,
	ancestors = &quot;roa-opt&quot;,
}

m[&quot;fay&quot;] = {
	&quot;Fars Barat Daya&quot;,
	5228140,
	&quot;ira-swi&quot;,
}

m[&quot;faz&quot;] = {
	&quot;Fars Barat Laut&quot;,
	7060307,
	&quot;ira-swi&quot;,
}

m[&quot;fbl&quot;] = {
	&quot;Bikol Albay Barat&quot;,
	18603801,
	&quot;phi&quot;,
	&quot;Latn&quot;,
}

m[&quot;fcs&quot;] = {
	&quot;Bahasa Isyarat Quebec&quot;,
	13193,
	&quot;sgn&quot;,
	&quot;Latn&quot;, -- when documented
}

m[&quot;fer&quot;] = {
	&quot;Feroge&quot;,
	35287,
	&quot;nic-ser&quot;,
	&quot;Latn&quot;,
}

m[&quot;ffi&quot;] = {
	&quot;Foia Foia&quot;,
	8564176,
	&quot;ngf&quot;,
	&quot;Latn&quot;,
}

-- &quot;ffm&quot; IS TREATED AS &quot;ff&quot;, SEE WT:LT

m[&quot;fgr&quot;] = {
	&quot;Fongoro&quot;,
	3437645,
	&quot;csu&quot;,
	&quot;Latn&quot;,
}

m[&quot;fia&quot;] = {
	&quot;Nobiin&quot;,
	36503,
	&quot;nub&quot;,
	&quot;Latn, Arab, Copt&quot;,
	ancestors = &quot;onw&quot;,
	translit = {
		Copt = &quot;Copt-translit&quot;,
	},
}

m[&quot;fie&quot;] = {
	&quot;Fyer&quot;,
	56273,
	&quot;cdc-wst&quot;,
	&quot;Latn&quot;,
}

-- &quot;fil&quot; IS TREATED AS &quot;tl&quot;, SEE WT:LT

m[&quot;fip&quot;] = {
	&quot;Fipa&quot;,
	667747,
	&quot;bnt-mwi&quot;,
	&quot;Latn&quot;,
}

m[&quot;fir&quot;] = {
	&quot;Firan&quot;,
	3915847,
	&quot;nic-plc&quot;,
	&quot;Latn&quot;,
}

m[&quot;fit&quot;] = {
	&quot;Meänkieli&quot;,
	13357,
	&quot;urj-fin&quot;,
	&quot;Latn&quot;,
	ancestors = &quot;fi&quot;,
}

m[&quot;fiw&quot;] = {
	&quot;Fiwaga&quot;,
	5456292,
	&quot;paa-kut&quot;,
	&quot;Latn&quot;,
}

m[&quot;fkk&quot;] = {
	&quot;Kirya-Konzel&quot;,
	6416310,
	&quot;cdc-cbm&quot;,
	&quot;Latn&quot;,
}

m[&quot;fkv&quot;] = {
	&quot;Kven&quot;,
	165795,
	&quot;urj-fin&quot;,
	&quot;Latn&quot;,
	ancestors = &quot;fi&quot;,
}

m[&quot;fla&quot;] = {
	&quot;Montana Salish&quot;,
	3111983,
	&quot;sal&quot;,
	&quot;Latn&quot;,
}

m[&quot;flh&quot;] = {
	&quot;Foau&quot;,
	5463819,
	&quot;paa-lkp&quot;,
	&quot;Latn&quot;,
}

m[&quot;fli&quot;] = {
	&quot;Fali&quot;,
	56244,
	&quot;cdc-cbm&quot;,
	&quot;Latn&quot;,
}

m[&quot;fll&quot;] = {
	&quot;Fali Utara&quot;,
	12952419,
	&quot;alv-fli&quot;,
	&quot;Latn&quot;,
}

m[&quot;fln&quot;] = {
	&quot;Pulau Flinders&quot;,
	3915702,
	&quot;aus-pmn&quot;,
	&quot;Latn&quot;,
}

m[&quot;flr&quot;] = {
	&quot;Fuliiru&quot;,
	7166821,
	&quot;bnt-shh&quot;,
	&quot;Latn&quot;,
}

m[&quot;fly&quot;] = {
	&quot;Tsotsitaal&quot;,
	12643960,
	&quot;crp&quot;,
	&quot;Latn&quot;,
	ancestors = &quot;af&quot;,
}

m[&quot;fmp&quot;] = {
	&quot;Fe'fe'&quot;,
	35276,
	&quot;bai&quot;,
	&quot;Latn&quot;,
}

m[&quot;fmu&quot;] = {
	&quot;Muria Barat Jauh&quot;,
	42589412,
	&quot;dra-mur&quot;,
}

m[&quot;fng&quot;] = {
	&quot;Fanagalo&quot;,
	35727,
	&quot;crp&quot;,
	&quot;Latn&quot;,
	ancestors = &quot;zu&quot;,
}

m[&quot;fni&quot;] = {
	&quot;Fania&quot;,
	317642,
	&quot;alv-bua&quot;,
	&quot;Latn&quot;,
}

m[&quot;fod&quot;] = {
	&quot;Foodo&quot;,
	5465566,
	&quot;alv-gng&quot;,
	&quot;Latn&quot;,
}

m[&quot;foi&quot;] = {
	&quot;Foi&quot;,
	5464146,
	&quot;paa-kut&quot;,
	&quot;Latn&quot;,
}

m[&quot;fom&quot;] = {
	&quot;Foma&quot;,
	5464911,
	&quot;bnt-ske&quot;,
	&quot;Latn&quot;,
	ancestors = &quot;khy&quot;,
}

m[&quot;fon&quot;] = {
	&quot;Fon&quot;,
	33291,
	&quot;alv-gbe&quot;,
	&quot;Latn&quot;,
}

m[&quot;for&quot;] = {
	&quot;Fore&quot;,
	3077126,
	&quot;paa-kag&quot;,
	&quot;Latn&quot;,
}

m[&quot;fos&quot;] = {
	&quot;Siraya&quot;,
	716604,
	&quot;map&quot;,
	&quot;Latn&quot;,
}

m[&quot;fpe&quot;] = {
	&quot;Pichinglis&quot;,
	35288,
	&quot;crp&quot;,
	&quot;Latn&quot;,
	ancestors = &quot;en&quot;,
}

m[&quot;fqs&quot;] = {
	&quot;Fas&quot;,
	56320,
	&quot;paa&quot;,
	&quot;Latn&quot;,
}

-- &quot;frc&quot; IS TREATED AS &quot;fr&quot; (or as etymology-only), SEE WT:LT

m[&quot;frd&quot;] = {
	&quot;Fordata&quot;,
	5468035,
	&quot;poz&quot;,
	&quot;Latn&quot;,
}

m[&quot;frm&quot;] = {
	&quot;Perancis Pertengahan&quot;,
	1473289,
	&quot;roa-oil&quot;,
	&quot;Latn&quot;,
	sort_key = s[&quot;roa-oil-sortkey&quot;],
}

m[&quot;fro&quot;] = {
	&quot;Perancis Kuno&quot;,
	35222,
	&quot;roa-oil&quot;,
	&quot;Latn, Hebr&quot;,
	sort_key = {Latn = s[&quot;roa-oil-sortkey&quot;]},
}

m[&quot;frp&quot;] = {
	&quot;Franco-Provençal&quot;,
	15087,
	&quot;roa&quot;,
	&quot;Latn&quot;,
	sort_key = {
		remove_diacritics = c.grave .. c.acute .. c.circ .. c.diaer .. c.cedilla .. &quot;'&quot;,
		from = {&quot;æ&quot;, &quot;œ&quot;},
		to = {&quot;ae&quot;, &quot;oe&quot;}
	},
}

m[&quot;frq&quot;] = {
	&quot;Forak&quot;,
	5467173,
	&quot;ngf-fin&quot;,
	&quot;Latn&quot;,
}

m[&quot;frr&quot;] = {
	&quot;Frisia Utara&quot;,
	28224,
	&quot;gmw-fri&quot;,
	&quot;Latn&quot;,
}

-- &quot;frs&quot; IS NOT USED, SEE WT:LT

m[&quot;frt&quot;] = {
	&quot;Fortsenal&quot;,
	2666835,
	&quot;poz-vnc&quot;,
	&quot;Latn&quot;,
}

m[&quot;fse&quot;] = {
	&quot;Bahasa Isyarat Finland&quot;,
	33225,
	&quot;sgn&quot;,
	&quot;Latn&quot;, -- when documented
}

m[&quot;fsl&quot;] = {
	&quot;Bahasa Isyarat Perancis&quot;,
	33302,
	&quot;sgn-fsl&quot;,
	&quot;Latn&quot;, -- when documented
}

m[&quot;fss&quot;] = {
	&quot;Bahasa Isyarat Finland-Sweden&quot;,
	5450448,
	&quot;sgn&quot;,
	&quot;Latn&quot;, -- when documented
}

-- &quot;fub&quot; IS TREATED AS &quot;ff&quot;, SEE WT:LT

-- &quot;fuc&quot; IS TREATED AS &quot;ff&quot;, SEE WT:LT

m[&quot;fud&quot;] = {
	&quot;Futuna Timur&quot;,
	35334,
	&quot;poz-pnp&quot;,
	&quot;Latn&quot;,
}

-- &quot;fue&quot; IS TREATED AS &quot;ff&quot;, SEE WT:LT

-- &quot;fuf&quot; IS TREATED AS &quot;ff&quot;, SEE WT:LT

-- &quot;fuh&quot; IS TREATED AS &quot;ff&quot;, SEE WT:LT

-- &quot;fui&quot; IS TREATED AS &quot;ff&quot;, SEE WT:LT

m[&quot;fuj&quot;] = {
	&quot;Ko&quot;,
	35693,
	&quot;alv-hei&quot;,
	&quot;Latn&quot;,
}

m[&quot;fum&quot;] = {
	&quot;Fum&quot;,
	11011870,
	&quot;nic-nka&quot;,
	&quot;Latn&quot;,
}

m[&quot;fun&quot;] = {
	&quot;Fulniô&quot;,
	774441,
	&quot;qfa-iso&quot;,
	&quot;Latn&quot;,
}

-- &quot;fuq&quot; IS TREATED AS &quot;ff&quot;, SEE WT:LT

m[&quot;fur&quot;] = {
	&quot;Friuli&quot;,
	33441,
	&quot;roa-rhe&quot;,
	&quot;Latn&quot;,
}

m[&quot;fut&quot;] = {
	&quot;Futuna-Aniwa&quot;,
	3064409,
	&quot;poz-pnp&quot;,
	&quot;Latn&quot;,
}

m[&quot;fuu&quot;] = {
	&quot;Furu&quot;,
	3441160,
	&quot;csu-bkr&quot;,
	&quot;Latn&quot;,
}

-- &quot;fuv&quot; IS TREATED AS &quot;ff&quot;, SEE WT:LT

m[&quot;fuy&quot;] = {
	&quot;Fuyug&quot;,
	3073472,
	&quot;ngf&quot;,
	&quot;Latn&quot;,
}

m[&quot;fvr&quot;] = {
	&quot;Fur&quot;,
	33364,
	&quot;ssa-fur&quot;,
	&quot;Latn&quot;,
}

m[&quot;fwa&quot;] = {
	&quot;Fwâi&quot;,
	3091331,
	&quot;poz-cln&quot;,
	&quot;Latn&quot;,
}

m[&quot;fwe&quot;] = {
	&quot;Fwe&quot;,
	5511159,
	&quot;bnt-bot&quot;,
	&quot;Latn&quot;,
}

return require(&quot;Module:languages&quot;).finalizeData(m, &quot;language&quot;)</text>
      <sha1>g3p71awi780ckf2w77tttlvtcga4l3w</sha1>
    </revision>
  </page>
  <page>
    <title>Modul:languages/data/3/i</title>
    <ns>828</ns>
    <id>9813</id>
    <revision>
      <id>342848</id>
      <parentid>273099</parentid>
      <timestamp>2026-05-17T04:00:38Z</timestamp>
      <contributor>
        <username>PeaceSeekers</username>
        <id>3334</id>
      </contributor>
      <minor />
      <origin>342848</origin>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="12233" sha1="5znpn41jwyxlwm965ga6tclzb3km6tc" xml:space="preserve">local m_langdata = require(&quot;Module:languages/data&quot;)

-- Loaded on demand, as it may not be needed (depending on the data).
local function u(...)
	u = require(&quot;Module:string utilities&quot;).char
	return u(...)
end

local c = m_langdata.chars
local p = m_langdata.puaChars
local s = m_langdata.shared

local m = {}

m[&quot;iai&quot;] = {
	&quot;Iaai&quot;,
	282888,
	&quot;poz-cln&quot;,
	&quot;Latn&quot;,
}

m[&quot;ian&quot;] = {
	&quot;Iatmul&quot;,
	5983460,
	&quot;paa-spk&quot;,
}

m[&quot;iar&quot;] = {
	&quot;Purari&quot;,
	3499934,
	&quot;paa&quot;,
}

m[&quot;iba&quot;] = {
	&quot;Iban&quot;,
	33424,
	&quot;poz-mly&quot;,
	&quot;Latn&quot;,
}

m[&quot;ibb&quot;] = {
	&quot;Ibibio&quot;,
	33792,
	&quot;nic-ief&quot;,
	&quot;Latn&quot;,
}

m[&quot;ibd&quot;] = {
	&quot;Iwaidja&quot;,
	1977429,
	&quot;aus-wdj&quot;,
	&quot;Latn&quot;,
}

m[&quot;ibe&quot;] = {
	&quot;Akpes&quot;,
	35457,
	&quot;alv-von&quot;,
	&quot;Latn&quot;,
}

m[&quot;ibg&quot;] = {
	&quot;Ibanag&quot;,
	1775596,
	&quot;phi&quot;,
	&quot;Latn&quot;,
}

m[&quot;ibh&quot;] = {
	&quot;Bih&quot;,
	nil,
	&quot;cmc&quot;,
	&quot;Latn&quot;,
}

m[&quot;ibl&quot;] = {
	&quot;Ibaloi&quot;,
	3147383,
	&quot;phi&quot;,
}

m[&quot;ibm&quot;] = {
	&quot;Agoi&quot;,
	34727,
	&quot;nic-ucr&quot;,
	&quot;Latn&quot;,
}

m[&quot;ibn&quot;] = {
	&quot;Ibino&quot;,
	3813281,
	&quot;nic-lcr&quot;,
	&quot;Latn&quot;,
}

m[&quot;ibr&quot;] = {
	&quot;Ibuoro&quot;,
	3813306,
	&quot;nic-ief&quot;,
}

m[&quot;ibu&quot;] = {
	&quot;Ibu&quot;,
	11732235,
	&quot;paa-nha&quot;,
}

m[&quot;iby&quot;] = {
	&quot;Ibani&quot;,
	11280479,
	&quot;ijo&quot;,
}

m[&quot;ica&quot;] = {
	&quot;Ede Ica&quot;,
	12952405,
	&quot;alv-ede&quot;,
	&quot;Latn&quot;,
}

m[&quot;ich&quot;] = {
	&quot;Etkywan&quot;,
	3914462,
	&quot;nic-jkn&quot;,
	&quot;Latn&quot;,
}

m[&quot;icl&quot;] = {
	&quot;Bahasa Isyarat Iceland&quot;,
	3436654,
	&quot;sgn&quot;,
	&quot;Latn&quot;, -- when documented
}

m[&quot;icr&quot;] = {
	&quot;Inggeris Kreol Islander&quot;,
	2044587,
	&quot;crp&quot;,
	&quot;Latn&quot;,
	ancestors = &quot;en&quot;,
}

m[&quot;ida&quot;] = {
	&quot;Idakho-Isukha-Tiriki&quot;,
	12952512,
	&quot;bnt-lok&quot;,
}

m[&quot;idb&quot;] = {
	&quot;Indo-Portugis&quot;,
	6025550,
	&quot;crp&quot;,
	&quot;Latn&quot;,
	ancestors = &quot;pt&quot;,
}

m[&quot;idc&quot;] = {
	&quot;Idon&quot;,
	3913366,
	&quot;nic-plc&quot;,
}

m[&quot;idd&quot;] = {
	&quot;Ede Idaca&quot;,
	13123376,
	&quot;alv-ede&quot;,
	&quot;Latn&quot;,
}

m[&quot;ide&quot;] = {
	&quot;Idere&quot;,
	3813288,
	&quot;nic-ief&quot;,
}

m[&quot;idi&quot;] = {
	&quot;Idi&quot;,
	5988630,
	&quot;paa&quot;,
	&quot;Latn&quot;,
}

m[&quot;idr&quot;] = {
	&quot;Indri&quot;,
	35662,
	&quot;nic-ser&quot;,
}

m[&quot;ids&quot;] = {
	&quot;Idesa&quot;,
	3913979,
	&quot;alv-swd&quot;,
	&quot;Latn&quot;,
	ancestors = &quot;oke&quot;,
}

m[&quot;idt&quot;] = {
	&quot;Idaté&quot;,
	12952511,
	&quot;poz-tim&quot;,
	&quot;Latn&quot;,
}

m[&quot;idu&quot;] = {
	&quot;Idoma&quot;,
	35478,
	&quot;alv-ido&quot;,
	&quot;Latn&quot;,
}

m[&quot;ifa&quot;] = {
	&quot;Amganad Ifugao&quot;,
	18748222,
	&quot;phi&quot;,
	&quot;Latn&quot;,
}

m[&quot;ifb&quot;] = {
	&quot;Batad Ifugao&quot;,
	12953578,
	&quot;phi&quot;,
	&quot;Latn&quot;,
}

m[&quot;ife&quot;] = {
	&quot;Ifè&quot;,
	33606,
	&quot;alv-ede&quot;,
	&quot;Latn&quot;,
	entry_name = {remove_diacritics = c.grave .. c.acute .. c.circ .. c.macron .. c.caron},
	sort_key = {
		remove_diacritics = c.tilde,
		from = {&quot;ɖ&quot;, &quot;dz&quot;, &quot;ɛ&quot;, &quot;gb&quot;, &quot;kp&quot;, &quot;ny&quot;, &quot;ŋ&quot;, &quot;ɔ&quot;, &quot;ts&quot;},
		to = {&quot;d&quot; .. p[1], &quot;d&quot; .. p[2], &quot;e&quot; .. p[1], &quot;g&quot; .. p[1], &quot;k&quot; .. p[1], &quot;n&quot; .. p[1], &quot;n&quot; .. p[2], &quot;o&quot; .. p[1], &quot;t&quot; .. p[1]}
	},
}

m[&quot;iff&quot;] = {
	&quot;Ifo&quot;,
	7902545,
	&quot;poz-vns&quot;,
	&quot;Latn&quot;,
}

m[&quot;ifk&quot;] = {
	&quot;Tuwali Ifugao&quot;,
	7857158,
	&quot;phi&quot;,
	&quot;Latn&quot;,
}

m[&quot;ifm&quot;] = {
	&quot;Teke-Fuumu&quot;,
	36603,
	&quot;bnt-tek&quot;,
}

m[&quot;ifu&quot;] = {
	&quot;Mayoyao Ifugao&quot;,
	12953579,
	&quot;phi&quot;,
	&quot;Latn&quot;,
}

m[&quot;ify&quot;] = {
	&quot;Keley-I Kallahan&quot;,
	3192221,
	&quot;phi&quot;,
	&quot;Latn&quot;,
}

m[&quot;igb&quot;] = {
	&quot;Ebira&quot;,
	35363,
	&quot;alv-nup&quot;,
	&quot;Latn&quot;,
}

m[&quot;ige&quot;] = {
	&quot;Igede&quot;,
	35420,
	&quot;alv-ido&quot;,
	&quot;Latn&quot;,
}

m[&quot;igg&quot;] = {
	&quot;Igana&quot;,
	5991454,
	&quot;paa&quot;,
	&quot;Latn&quot;,
}

m[&quot;igl&quot;] = {
	&quot;Igala&quot;,
	35513,
	&quot;alv-yrd&quot;,
	&quot;Latn&quot;,
	entry_name = {remove_diacritics = c.grave .. c.acute .. c.circ .. c.macron .. c.dotabove .. c.caron .. c.lineabove},
	sort_key = {
		from = {
			&quot;ñm&quot;, &quot;ñw&quot;, -- 3 chars
			&quot;ch&quot;, &quot;ẹ&quot;, &quot;gb&quot;, &quot;gw&quot;, &quot;kp&quot;, &quot;kw&quot;, &quot;ny&quot;, &quot;ñ&quot;, &quot;ọ&quot; -- 2 chars
		},
		to = {
			&quot;n&quot; .. p[3], &quot;n&quot; .. p[4],
			&quot;c&quot; .. p[1], &quot;e&quot; .. p[1], &quot;g&quot; .. p[1], &quot;g&quot; .. p[2], &quot;k&quot; .. p[1], &quot;k&quot; .. p[2], &quot;n&quot; .. p[1], &quot;n&quot; .. p[2], &quot;o&quot; .. p[1]
		}
	},
}

m[&quot;igm&quot;] = {
	&quot;Kanggape&quot;,
	6362743,
	&quot;paa&quot;,
	&quot;Latn&quot;,
}

m[&quot;ign&quot;] = {
	&quot;Ignaciano&quot;,
	3148190,
	&quot;awd&quot;,
}

m[&quot;igo&quot;] = {
	&quot;Isebe&quot;,
	11732248,
	&quot;ngf-mad&quot;,
}

m[&quot;igs&quot;] = {
	&quot;Glosa&quot;,
	1138529,
	&quot;art&quot;,
	type = &quot;appendix-constructed&quot;,
}

m[&quot;igw&quot;] = {
	&quot;Igwe&quot;,
	3913985,
	&quot;alv-yek&quot;,
	&quot;Latn&quot;,
}

m[&quot;ihb&quot;] = {
	&quot;Pidgin Iha&quot;,
	12639686,
	&quot;crp&quot;,
	ancestors = &quot;ihp&quot;,
}

m[&quot;ihi&quot;] = {
	&quot;Ihievbe&quot;,
	3441193,
	&quot;alv-eeo&quot;,
	&quot;Latn&quot;,
	ancestors = &quot;ema&quot;,
}

m[&quot;ihp&quot;] = {
	&quot;Iha&quot;,
	5994495,
	&quot;ngf&quot;,
}

m[&quot;ijc&quot;] = {
	&quot;Izon&quot;,
	35483,
	&quot;ijo&quot;,
	&quot;Latn&quot;,
}

m[&quot;ije&quot;] = {
	&quot;Biseni&quot;,
	35010,
	&quot;ijo&quot;,
}

m[&quot;ijj&quot;] = {
	&quot;Ede Ije&quot;,
	12952406,
	&quot;alv-ede&quot;,
	&quot;Latn&quot;,
}

m[&quot;ijn&quot;] = {
	&quot;Kalabari&quot;,
	35697,
	&quot;ijo&quot;,
}

m[&quot;ijs&quot;] = {
	&quot;Southeast Ijo&quot;,
	3915854,
	&quot;ijo&quot;,
	&quot;Latn&quot;,
}

m[&quot;ike&quot;] = {
	&quot;Eastern Canadian Inuktitut&quot;,
	4126517,
	&quot;esx-inu&quot;,
	&quot;Cans&quot;,
}

m[&quot;iki&quot;] = {
	&quot;Iko&quot;,
	3813290,
	&quot;nic-lcr&quot;,
	&quot;Latn&quot;,
}

m[&quot;ikk&quot;] = {
	&quot;Ika&quot;,
	35406,
	&quot;alv-igb&quot;,
	&quot;Latn&quot;,
}

m[&quot;ikl&quot;] = {
	&quot;Ikulu&quot;,
	425973,
	&quot;nic-plc&quot;,
	&quot;Latn&quot;,
}

m[&quot;iko&quot;] = {
	&quot;Olulumo-Ikom&quot;,
	3914402,
	&quot;nic-uce&quot;,
	&quot;Latn&quot;,
}

m[&quot;ikp&quot;] = {
	&quot;Ikpeshi&quot;,
	3912777,
	&quot;alv-yek&quot;,
	&quot;Latn&quot;,
}

m[&quot;ikr&quot;] = {
	&quot;Ikaranggal&quot;,
	5995402,
	&quot;aus-pam&quot;,
}

m[&quot;iks&quot;] = {
	&quot;Bahasa Isyarat Inuit&quot;,
	13360244,
	&quot;sgn&quot;,
	&quot;Latn&quot;, -- when documented
}

m[&quot;ikt&quot;] = {
	&quot;Inuvialuktun&quot;,
	27990,
	&quot;esx-inu&quot;,
	&quot;Cans, Latn&quot;,
}

m[&quot;ikv&quot;] = {
	&quot;Iku-Gora-Ankwa&quot;,
	3913940,
	&quot;nic-plc&quot;,
}

m[&quot;ikw&quot;] = {
	&quot;Ikwere&quot;,
	35399,
	&quot;alv-igb&quot;,
}

m[&quot;ikx&quot;] = {
	&quot;Ik&quot;,
	35472,
	&quot;ssa-klk&quot;,
	&quot;Latn&quot;,
}

m[&quot;ikz&quot;] = {
	&quot;Ikizu&quot;,
	10977626,
	&quot;bnt-lok&quot;,
	&quot;Latn&quot;,
}

m[&quot;ila&quot;] = {
	&quot;Ile Ape&quot;,
	12473380,
	&quot;poz-cet&quot;,
}

m[&quot;ilb&quot;] = {
	&quot;Ila&quot;,
	10962725,
	&quot;bnt-bot&quot;,
	&quot;Latn&quot;,
}

m[&quot;ilg&quot;] = {
	&quot;Ilgar&quot;,
	5997810,
	&quot;aus-wdj&quot;,
	&quot;Latn&quot;,
}

m[&quot;ili&quot;] = {
	&quot;Ili Turki&quot;,
	33627,
	&quot;trk-kar&quot;,
}

m[&quot;ilk&quot;] = {
	&quot;Ilongot&quot;,
	3148787,
	&quot;phi&quot;,
	&quot;Latn&quot;,
}

m[&quot;ill&quot;] = {
	&quot;Iranun&quot;,
	12953581,
	&quot;phi&quot;,
	&quot;Latn, Arab&quot;,
}

m[&quot;ilo&quot;] = {
	&quot;Ilocano&quot;,
	35936,
	&quot;phi&quot;,
	&quot;Latn, Tglg&quot;,
	translit = {
		Tglg = &quot;ilo-translit&quot;,
	},
	override_translit = true,
	entry_name = {
		Latn = {
			remove_diacritics = c.grave .. c.acute .. c.circ .. c.diaer,
		}
	},
    sort_key = {
		Latn = &quot;tl-sortkey&quot;,
	},
	standardChars = { 
		Latn = &quot;AaBbKkDdEeGgHhIiLlMmNnOoPpRrSsTtUuWwYy&quot; .. c.punc,
	},
}

m[&quot;ils&quot;] = {
	&quot;International Sign&quot;,
	35754,
	&quot;sgn&quot;,
}

m[&quot;ilu&quot;] = {
	&quot;Ili'uun&quot;,
	12632888,
	&quot;poz-tim&quot;,
}

m[&quot;ilv&quot;] = {
	&quot;Ilue&quot;,
	3813301,
	&quot;nic-lcr&quot;,
	&quot;Latn&quot;,
}

m[&quot;ima&quot;] = {
	&quot;Mala Malasar&quot;,
	6740693,
	&quot;dra-tam&quot;,
}

m[&quot;imi&quot;] = {
	&quot;Anamgura&quot;,
	3501881,
	&quot;ngf-mad&quot;,
}

m[&quot;iml&quot;] = {
	&quot;Miluk&quot;,
	3314550,
	&quot;nai-coo&quot;,
	&quot;Latn&quot;,
}

m[&quot;imn&quot;] = {
	&quot;Imonda&quot;,
	6005721,
	&quot;paa-brd&quot;,
}

m[&quot;imo&quot;] = {
	&quot;Imbongu&quot;,
	12632895,
	&quot;ngf-mad&quot;,
}

m[&quot;imr&quot;] = {
	&quot;Imroing&quot;,
	6008394,
	&quot;poz-tim&quot;,
}

m[&quot;ims&quot;] = {
	&quot;Marsian&quot;,
	1265446,
	&quot;itc-sbl&quot;,
	&quot;Latn&quot;,
}

m[&quot;imy&quot;] = {
	&quot;Milyan&quot;,
	3832946,
	&quot;ine-luw&quot;,
	&quot;Lyci&quot;,
}

m[&quot;inb&quot;] = {
	&quot;Inga&quot;,
	35491,
	&quot;qwe&quot;,
	ancestors = &quot;qwe-kch&quot;,
}

m[&quot;ing&quot;] = {
	&quot;Deg Xinag&quot;,
	27782,
	&quot;ath-nor&quot;,
	&quot;Latn&quot;,
}

m[&quot;inh&quot;] = {
	&quot;Ingush&quot;,
	33509,
	&quot;cau-vay&quot;,
	&quot;Cyrl, Latn, Arab&quot;,
	translit = {
		Cyrl = &quot;cau-nec-translit&quot;,
		Arab = &quot;ar-translit&quot;,
	},
	override_translit = true,
	display_text = {Cyrl = s[&quot;cau-Cyrl-displaytext&quot;]},
	entry_name = {
		Cyrl = s[&quot;cau-Cyrl-entryname&quot;],
		Latn = s[&quot;cau-Latn-entryname&quot;],
	},
	sort_key = {
		Cyrl = {
			from = {&quot;аь&quot;, &quot;гӏ&quot;, &quot;ё&quot;, &quot;кх&quot;, &quot;къ&quot;, &quot;кӏ&quot;, &quot;пӏ&quot;, &quot;тӏ&quot;, &quot;хь&quot;, &quot;хӏ&quot;, &quot;цӏ&quot;, &quot;чӏ&quot;, &quot;яь&quot;},
			to = {&quot;а&quot; .. p[1], &quot;г&quot; .. p[1], &quot;е&quot; .. p[1], &quot;к&quot; .. p[1], &quot;к&quot; .. p[2], &quot;к&quot; .. p[3], &quot;п&quot; .. p[1], &quot;т&quot; .. p[1], &quot;х&quot; .. p[1], &quot;х&quot; .. p[2], &quot;ц&quot; .. p[1], &quot;ч&quot; .. p[1], &quot;я&quot; .. p[1]}
		},
	},
}

m[&quot;inj&quot;] = {
	&quot;Jungle Inga&quot;,
	16115012,
	&quot;qwe&quot;,
	ancestors = &quot;qwe-kch&quot;,
}

m[&quot;inl&quot;] = {
	&quot;Bahasa Isyarat Indonesia&quot;,
	3915477,
	&quot;sgn&quot;,
	&quot;Latn&quot;, -- when documented
}

m[&quot;inm&quot;] = {
	&quot;Minaean&quot;,
	737784,
	&quot;sem-osa&quot;,
	&quot;Sarb&quot;,
	translit = &quot;Sarb-translit&quot;,
}

m[&quot;inn&quot;] = {
	&quot;Isinai&quot;,
	6081098,
	&quot;phi&quot;,
}

m[&quot;ino&quot;] = {
	&quot;Inoke-Yate&quot;,
	6036531,
	&quot;paa-kag&quot;,
}

m[&quot;inp&quot;] = {
	&quot;Iñapari&quot;,
	15338035,
	&quot;awd&quot;,
	&quot;Latn&quot;,
}

m[&quot;ins&quot;] = {
	&quot;Bahasa Isyarat India&quot;,
	12953486,
	&quot;sgn&quot;,
}

m[&quot;int&quot;] = {
	&quot;Intha&quot;,
	6057507,
	&quot;tbq-brm&quot;,
	ancestors = &quot;obr&quot;,
}

m[&quot;inz&quot;] = {
	&quot;Ineseño&quot;,
	35443,
	&quot;nai-chu&quot;,
	&quot;Latn&quot;,
}

m[&quot;ior&quot;] = {
	&quot;Inor&quot;,
	35763,
	&quot;sem-eth&quot;,
	&quot;Ethi&quot;,
}

m[&quot;iou&quot;] = {
	&quot;Tuma-Irumu&quot;,
	7852460,
	&quot;ngf-fin&quot;,
	&quot;Latn&quot;,
}

m[&quot;iow&quot;] = {
	&quot;Chiwere&quot;,
	56737,
	&quot;sio-msv&quot;,
	&quot;Latn&quot;,
}

m[&quot;ipi&quot;] = {
	&quot;Ipili&quot;,
	6065141,
	&quot;paa-eng&quot;,
}

m[&quot;ipo&quot;] = {
	&quot;Ipiko&quot;,
	10566515,
	&quot;ngf&quot;,
}

m[&quot;iqu&quot;] = {
	&quot;Iquito&quot;,
	2669184,
	&quot;sai-zap&quot;,
	&quot;Latn&quot;,
}

m[&quot;iqw&quot;] = {
	&quot;Ikwo&quot;,
	11926474,
	&quot;alv-igb&quot;,
	&quot;Latn&quot;,
	ancestors = &quot;izi&quot;,
}

m[&quot;ire&quot;] = {
	&quot;Iresim&quot;,
	6069398,
	&quot;poz-hce&quot;,
	&quot;Latn&quot;,
}

m[&quot;irh&quot;] = {
	&quot;Irarutu&quot;,
	3027928,
	&quot;poz-cet&quot;,
	&quot;Latn&quot;,
}

m[&quot;iri&quot;] = {
	&quot;Rigwe&quot;,
	3912756,
	&quot;nic-plc&quot;,
	&quot;Latn&quot;,
}

m[&quot;irk&quot;] = {
	&quot;Iraqw&quot;,
	33595,
	&quot;cus-sou&quot;,
	&quot;Latn&quot;,
}

m[&quot;irn&quot;] = {
	&quot;Irantxe&quot;,
	3409301,
	nil,
	&quot;Latn&quot;,
}

m[&quot;irr&quot;] = {
	&quot;Ir&quot;,
	3071880,
	&quot;mkh-kat&quot;,
}

m[&quot;iru&quot;] = {
	&quot;Irula&quot;,
	33363,
	&quot;dra-imd&quot;,
	&quot;Taml&quot;,
	translit = &quot;ta-translit&quot;
}

m[&quot;irx&quot;] = {
	&quot;Kamberau&quot;,
	6356317,
	&quot;ngf&quot;,
}

m[&quot;iry&quot;] = {
	&quot;Iraya&quot;,
	6068356,
	&quot;phi&quot;,
	&quot;Latn&quot;,
}

m[&quot;isa&quot;] = {
	&quot;Isabi&quot;,
	11732247,
	&quot;paa-kag&quot;,
}

m[&quot;isc&quot;] = {
	&quot;Isconahua&quot;,
	3052971,
	&quot;sai-pan&quot;,
	&quot;Latn&quot;,
}

m[&quot;isd&quot;] = {
	&quot;Isnag&quot;,
	6085162,
	&quot;phi&quot;,
	&quot;Latn&quot;,
}

m[&quot;ise&quot;] = {
	&quot;Bahasa Isyarat Itali&quot;,
	375619,
	&quot;sgn&quot;,
	&quot;Latn&quot;, -- when documented
}

m[&quot;isg&quot;] = {
	&quot;Bahasa Isyarat Ireland&quot;,
	14183,
	&quot;sgn&quot;,
	&quot;Latn&quot;, -- when documented
}

m[&quot;ish&quot;] = {
	&quot;Esan&quot;,
	35268,
	&quot;alv-eeo&quot;,
	&quot;Latn&quot;,
}

m[&quot;isi&quot;] = {
	&quot;Nkem-Nkum&quot;,
	36261,
	&quot;nic-eko&quot;,
	&quot;Latn&quot;,
}

m[&quot;isk&quot;] = {
	&quot;Ishkashimi&quot;,
	33419,
	&quot;ira-sgi&quot;,
}

m[&quot;ism&quot;] = {
	&quot;Masimasi&quot;,
	6783273,
	&quot;poz-ocw&quot;,
	&quot;Latn&quot;,
}

m[&quot;isn&quot;] = {
	&quot;Isanzu&quot;,
	6078891,
	&quot;bnt-tkm&quot;,
	&quot;Latn&quot;,
}

m[&quot;iso&quot;] = {
	&quot;Isoko&quot;,
	35414,
	&quot;alv-swd&quot;,
	&quot;Latn&quot;,
}

m[&quot;isr&quot;] = {
	&quot;Bahasa Isyarat Israel&quot;,
	2911863,
	&quot;sgn&quot;,
	&quot;Sgnw&quot;,
}

m[&quot;ist&quot;] = {
	&quot;Istriot&quot;,
	35845,
	&quot;roa-itd&quot;,
	&quot;Latn&quot;,
}

m[&quot;isu&quot;] = {
	&quot;Isu&quot;,
	6089423,
	&quot;nic-rnw&quot;,
	&quot;Latn&quot;,
}

m[&quot;isv&quot;] = {
	&quot;Interslavic&quot;,
	148971,
	&quot;art&quot;,
	&quot;Latn, Cyrl&quot;,
	type = &quot;appendix-constructed&quot;,
	ancestors = &quot;sla-pro&quot;,
}

m[&quot;itb&quot;] = {
	&quot;Binongan Itneg&quot;,
	12953584,
	&quot;phi&quot;,
}

m[&quot;itd&quot;] = {
	&quot;Tidung Selatan&quot;,
	7049643,
	&quot;poz-san&quot;,
	&quot;Latn&quot;,
}

m[&quot;ite&quot;] = {
	&quot;Itene&quot;,
	3038640,
	&quot;sai-cpc&quot;,
	&quot;Latn&quot;,
}

m[&quot;iti&quot;] = {
	&quot;Inlaod Itneg&quot;,
	12953585,
	&quot;phi&quot;,
}

m[&quot;itk&quot;] = {
	&quot;Judeo-Itali&quot;,
	1145414,
	&quot;roa-itd&quot;,
	&quot;Hebr, Latn&quot;,
}

m[&quot;itl&quot;] = {
	&quot;Itelmen&quot;,
	33624,
	&quot;qfa-cka&quot;,
	&quot;Cyrl, Latn&quot;,
	entry_name = {
		Cyrl = {
			from = {&quot;['’]&quot;, &quot;[ӅԮ]&quot;, &quot;[ӆԯ]&quot;, &quot;Ҳ&quot;, &quot;ҳ&quot;},
			to   = {&quot;ʼ&quot;, &quot;Ԓ&quot;, &quot;ԓ&quot;, &quot;Ӽ&quot;, &quot;ӽ&quot;}
		},
	},
	sort_key = {
		Cyrl = {
			from = {
				&quot;ӑ&quot;, &quot;ё&quot;, &quot;кʼ&quot;, &quot;ӄʼ&quot;, &quot;о̆&quot;, &quot;пʼ&quot;, &quot;тʼ&quot;, &quot;ў&quot;, &quot;чʼ&quot;, -- 2 chars
				&quot;ӄ&quot;, &quot;љ&quot;, &quot;ԓ&quot;, &quot;њ&quot;, &quot;ӈ&quot;, &quot;ӽ&quot;, &quot;ә&quot; -- 1 char
			},
			to = {
				&quot;а&quot; .. p[1], &quot;е&quot; .. p[1], &quot;к&quot; .. p[1], &quot;к&quot; .. p[3], &quot;о&quot; .. p[1], &quot;п&quot; .. p[1], &quot;т&quot; .. p[1], &quot;у&quot; .. p[1], &quot;ч&quot; .. p[1],
				&quot;к&quot; .. p[2], &quot;л&quot; .. p[1], &quot;л&quot; .. p[2], &quot;н&quot; .. p[1], &quot;н&quot; .. p[2], &quot;х&quot; .. p[1], &quot;ь&quot; .. p[1]
			}
		},
	},
}

m[&quot;itm&quot;] = {
	&quot;Itu Mbon Uzo&quot;,
	10977737,
	&quot;nic-ief&quot;,
	&quot;Latn&quot;,
	ancestors = &quot;ibr&quot;,
}

m[&quot;ito&quot;] = {
	&quot;Itonama&quot;,
	950585,
	&quot;qfa-iso&quot;,
	&quot;None&quot;,
}

m[&quot;itr&quot;] = {
	&quot;Iteri&quot;,
	2083185,
	&quot;paa-asa&quot;,
}

m[&quot;its&quot;] = {
	&quot;Itsekiri&quot;,
	36045,
	&quot;alv-edk&quot;,
	&quot;Latn&quot;,
	entry_name = {Latn = {remove_diacritics = c.grave .. c.acute .. c.macron}},
	sort_key = {
		remove_diacritics = c.tilde,
		from = {&quot;ẹ&quot;, &quot;gb&quot;, &quot;gh&quot;, &quot;kp&quot;, &quot;ọ&quot;, &quot;ts&quot;, &quot;ṣ&quot;},
		to = {&quot;e&quot; .. p[1], &quot;g&quot; .. p[1], &quot;g&quot; .. p[2], &quot;k&quot; .. p[1], &quot;o&quot; .. p[1], &quot;t&quot; .. p[1], &quot;t&quot; .. p[1]}
	},
}

m[&quot;itt&quot;] = {
	&quot;Maeng Itneg&quot;,
	18748761,
	&quot;phi&quot;,
}

m[&quot;itv&quot;] = {
	&quot;Itawit&quot;,
	3915527,
	&quot;phi&quot;,
	&quot;Latn&quot;,
}

m[&quot;itw&quot;] = {
	&quot;Ito&quot;,
	11128810,
	&quot;nic-ief&quot;,
	ancestors = &quot;ibr&quot;,
}

m[&quot;itx&quot;] = {
	&quot;Itik&quot;,
	6094713,
	&quot;paa-tkw&quot;,
}

m[&quot;ity&quot;] = {
	&quot;Moyadan Itneg&quot;,
	12953583,
	&quot;phi&quot;,
}

m[&quot;itz&quot;] = {
	&quot;Itzá&quot;,
	35537,
	&quot;myn&quot;,
}

m[&quot;ium&quot;] = {
	&quot;Iu Mien&quot;,
	2498808,
	&quot;hmx-mie&quot;,
	&quot;Latn&quot;,
}

m[&quot;ivb&quot;] = {
	&quot;Ibatan&quot;,
	18748212,
	&quot;phi&quot;,
	&quot;Latn&quot;,
}

m[&quot;ivv&quot;] = {
	&quot;Ivatan&quot;,
	3547080,
	&quot;phi&quot;,
	&quot;Latn&quot;,
}

m[&quot;iwk&quot;] = {
	&quot;I-Wak&quot;,
	12632789,
	&quot;phi&quot;,
}

m[&quot;iwm&quot;] = {
	&quot;Iwam&quot;,
	3915215,
	&quot;paa-spk&quot;,
}

m[&quot;iwo&quot;] = {
	&quot;Iwur&quot;,
	6101006,
	&quot;ngf-okk&quot;,
}

m[&quot;iws&quot;] = {
	&quot;Sepik Iwam&quot;,
	16893603,
	&quot;paa-spk&quot;,
}

m[&quot;ixc&quot;] = {
	&quot;Ixcatec&quot;,
	56706,
	&quot;omq&quot;,
}

m[&quot;ixl&quot;] = {
	&quot;Ixil&quot;,
	35528,
	&quot;myn&quot;,
	&quot;Latn&quot;,
}

m[&quot;iya&quot;] = {
	&quot;Iyayu&quot;,
	3913390,
	&quot;alv-nwd&quot;,
	&quot;Latn&quot;,
}

m[&quot;iyo&quot;] = {
	&quot;Mesaka&quot;,
	36080,
	&quot;nic-tiv&quot;,
	&quot;Latn&quot;,
}

m[&quot;iyx&quot;] = {
	&quot;Yaa&quot;,
	36909,
	&quot;bnt-nze&quot;,
	&quot;Latn&quot;,
}

m[&quot;izh&quot;] = {
	&quot;Ingria&quot;,
	33559,
	&quot;urj-fin&quot;,
	&quot;Latn&quot;,
	sort_key = {
		from = {
			&quot;š&quot;, &quot;ž&quot;,
		},
		to = {
			&quot;s&quot; .. p[1], &quot;z&quot; .. p[1],
		}
	},
}

m[&quot;izi&quot;] = {
	&quot;Izi-Ezaa-Ikwo-Mgbo&quot;,
	nil,
	&quot;alv-igb&quot;,
}

m[&quot;izr&quot;] = {
	&quot;Izere&quot;,
	6101921,
	&quot;nic-plc&quot;,
	&quot;Latn&quot;,
}

m[&quot;izz&quot;] = {
	&quot;Izi&quot;,
	3914387,
	&quot;alv-igb&quot;,
	&quot;Latn&quot;,
	ancestors = &quot;izi&quot;,
}

return require(&quot;Module:languages&quot;).finalizeData(m, &quot;language&quot;)</text>
      <sha1>5znpn41jwyxlwm965ga6tclzb3km6tc</sha1>
    </revision>
  </page>
  <page>
    <title>Modul:languages/data/3/x</title>
    <ns>828</ns>
    <id>9824</id>
    <revision>
      <id>342847</id>
      <parentid>281274</parentid>
      <timestamp>2026-05-17T03:52:49Z</timestamp>
      <contributor>
        <username>PeaceSeekers</username>
        <id>3334</id>
      </contributor>
      <minor />
      <origin>342847</origin>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="20879" sha1="n40topjbk5dwq74kd70arslduv875oh" xml:space="preserve">local m_langdata = require(&quot;Module:languages/data&quot;)

-- Loaded on demand, as it may not be needed (depending on the data).
local function u(...)
	u = require(&quot;Module:string utilities&quot;).char
	return u(...)
end

local c = m_langdata.chars
local p = m_langdata.puaChars
local s = m_langdata.shared

local m = {}


m[&quot;xaa&quot;] = {
	&quot;Arab Andalusia&quot;,
	1137945,
	&quot;sem-arb&quot;,
	&quot;Arab, Latn&quot;,
	entry_name = {
		remove_diacritics = c.kashida .. c.fathatan .. c.dammatan .. c.kasratan .. c.fatha .. c.damma .. c.kasra .. c.shadda .. c.sukun .. c.superalef,
		from = {u(0x0671)},
		to = {u(0x0627)}
	},
}

m[&quot;xab&quot;] = {
	&quot;Sambe&quot;,
	36265,
	&quot;nic-alu&quot;,
	&quot;Latn&quot;,
}

m[&quot;xac&quot;] = {
	&quot;Kachari&quot;,
	3442442,
	&quot;tbq-bdg&quot;,
}

m[&quot;xad&quot;] = {
	&quot;Adai&quot;,
	346744,
}

m[&quot;xae&quot;] = {
	&quot;Aequian&quot;,
	930579,
	&quot;itc&quot;,
}

m[&quot;xag&quot;] = {
	&quot;Aghwan&quot;,
	34931,
	&quot;cau-esm&quot;,
	&quot;Aghb&quot;,
	translit = &quot;Aghb-translit&quot;,
	override_translit = true,
}

m[&quot;xai&quot;] = {
	&quot;Kaimbé&quot;,
	6348017,
}

m[&quot;xaj&quot;] = {
	&quot;Ararandewára&quot;,
	nil,
	&quot;tup-gua&quot;,
	&quot;Latn&quot;,
}

m[&quot;xak&quot;] = {
	&quot;Maku&quot;,
	2032882,
	nil,
	&quot;Latn&quot;,
}

m[&quot;xal&quot;] = {
	&quot;Kalmyk&quot;,
	33634,
	&quot;xgn-cen&quot;,
	&quot;Cyrl, xwo-Mong&quot;,
	ancestors = &quot;xwo&quot;,
	translit = &quot;xal-translit&quot;,
	override_translit = true,
	sort_key = &quot;xal-sortkey&quot;,
}

m[&quot;xam&quot;] = {
	&quot;ǀXam&quot;,
	2086145,
	&quot;khi-tuu&quot;,
	&quot;Latn&quot;,
}

m[&quot;xan&quot;] = {
	&quot;Xamtanga&quot;,
	56527,
	&quot;cus-cen&quot;,
}

m[&quot;xao&quot;] = {
	&quot;Khao&quot;,
	3196077,
	&quot;mkh-pal&quot;,
}

m[&quot;xap&quot;] = {
	&quot;Apalachee&quot;,
	686501,
	&quot;nai-mus&quot;,
	&quot;Latn&quot;,
}

m[&quot;xaq&quot;] = {
	&quot;Aquitanian&quot;,
	500522,
	&quot;euq&quot;,
	&quot;Latn&quot;,
}

m[&quot;xar&quot;] = {
	&quot;Karami&quot;,
	11732281,
}

m[&quot;xas&quot;] = {
	&quot;Kamassian&quot;,
	35991,
	translit = &quot;xas-translit&quot;,
	&quot;syd&quot;,
	&quot;Cyrl&quot;,
}

m[&quot;xat&quot;] = {
	&quot;Katawixi&quot;,
	3440512,
	&quot;sai-ktk&quot;,
}

m[&quot;xau&quot;] = {
	&quot;Kauwera&quot;,
	6378983,
	&quot;paa-tkw&quot;,
}

m[&quot;xav&quot;] = {
	&quot;Xavante&quot;,
	36962,
	&quot;sai-cje&quot;,
	&quot;Latn&quot;,
}

m[&quot;xaw&quot;] = {
	&quot;Kawaiisu&quot;,
	56338,
	&quot;azc-num&quot;,
	&quot;Latn&quot;,
}

m[&quot;xay&quot;] = {
	&quot;Kayan Mahakam&quot;,
	25337171,
}

m[&quot;xbb&quot;] = {
	&quot;Lower Burdekin&quot;,
	6693353,
}

m[&quot;xbc&quot;] = {
	&quot;Baktria&quot;,
	756651,
	&quot;ira-sbc&quot;,
	&quot;Grek, Mani&quot;,
	translit = &quot;xbc-translit&quot;,
	entry_name = {
		from = {&quot;Þ&quot;, &quot;þ&quot;},
		to = {&quot;Ϸ&quot;, &quot;ϸ&quot;}
	},
}

m[&quot;xbd&quot;] = {
	&quot;Bindal&quot;,
	4913975,
}

m[&quot;xbe&quot;] = {
	&quot;Bigambal&quot;,
	16841801,
	&quot;aus-pam&quot;, --unclassified within
}

m[&quot;xbg&quot;] = {
	&quot;Bunganditj&quot;,
	4997615,
}

m[&quot;xbi&quot;] = {
	&quot;Kombio&quot;,
	6428259,
	&quot;qfa-tor&quot;,
	&quot;Latn&quot;,
}

m[&quot;xbj&quot;] = {
	&quot;Birrpayi&quot;,
	nil,
}

m[&quot;xbm&quot;] = {
	&quot;Breton Pertengahan&quot;,
	787610,
	&quot;cel-bry&quot;,
	&quot;Latn&quot;,
	ancestors = &quot;obt&quot;,
}

m[&quot;xbn&quot;] = {
	&quot;Kenaboi&quot;,
	6388752,
}

m[&quot;xbo&quot;] = {
	&quot;Bulgar&quot;,
	36880,
	&quot;trk-ogr&quot;,
	&quot;Arab, Grek&quot;,
}

m[&quot;xbp&quot;] = {
	&quot;Bibbulman&quot;,
	22918391,
}

m[&quot;xbr&quot;] = {
	&quot;Kambera&quot;,
	3053279,
	&quot;poz-cet&quot;,
	&quot;Latn&quot;,
}

m[&quot;xbw&quot;] = {
	&quot;Kambiwá&quot;,
	9006744,
}

m[&quot;xby&quot;] = {
	&quot;Butchulla&quot;,
	31752631,
}

m[&quot;xcb&quot;] = {
	&quot;Cumbric&quot;,
	35965,
	&quot;cel-bry&quot;,
}

m[&quot;xcc&quot;] = {
	&quot;Camunic&quot;,
	489011,
	nil,
	&quot;Ital&quot;,
	translit = &quot;Ital-translit&quot;,
}

m[&quot;xce&quot;] = {
	&quot;Celtiberian&quot;,
	37012,
	&quot;cel&quot;,
	&quot;Latn&quot;,
}

m[&quot;xch&quot;] = {
	&quot;Chemakum&quot;,
	56397,
	&quot;chi&quot;,
	&quot;Latn&quot;,
}

m[&quot;xcl&quot;] = {
	&quot;Armenia Kuno&quot;,
	181074,
	&quot;hyx&quot;,
	&quot;Armn&quot;,
	translit = &quot;Armn-translit&quot;,
	override_translit = true,
	entry_name = {
		remove_diacritics = &quot;՞՜՛՟&quot;,
		from = {&quot;եւ&quot;},
		to = {&quot;և&quot;}
	},
}

m[&quot;xcm&quot;] = {
	&quot;Comecrudo&quot;,
	609808,
	&quot;nai-pak&quot;,
}

m[&quot;xcn&quot;] = {
	&quot;Cotoname&quot;,
	56889,
	&quot;nai-pak&quot;,
}

m[&quot;xco&quot;] = {
	&quot;Khwarezm&quot;,
	33138,
	&quot;ira-sbc&quot;,
	&quot;Arab, Armi, Chrs, Phlv, Sogd&quot;,
	translit = {Chrs = &quot;Chrs-translit&quot;},
}

m[&quot;xcr&quot;] = {
	&quot;Carian&quot;,
	35929,
	&quot;ine-ana&quot;,
	&quot;Cari&quot;,
}

m[&quot;xct&quot;] = {
	&quot;Tibet Klasik&quot;,
	5128314,
	&quot;sit-tib&quot;,
	&quot;Tibt, Hani, Marc, Mong, mnc-Mong, xwo-Mong, Phag, Tang, Zanb&quot;,
	translit = {
		Tibt = &quot;Tibt-translit&quot;,
		Mong = &quot;Mong-translit&quot;,
		[&quot;mnc-Mong&quot;] = &quot;mnc-translit&quot;,
		[&quot;xwo-Mong&quot;] = &quot;xwo-translit&quot;,
		Tang = &quot;txg-translit&quot;,
	},
	override_translit = true,
	display_text = {
		Tibt = s[&quot;Tibt-displaytext&quot;],
		Mong = s[&quot;Mong-displaytext&quot;],
	},
	entry_name = {
		Tibt = s[&quot;Tibt-entryname&quot;],
		Mong = s[&quot;Mong-entryname&quot;],
	},
	sort_key = {
		Tibt = &quot;Tibt-sortkey&quot;,
		Hani = &quot;Hani-sortkey&quot;,
	},
}

m[&quot;xcu&quot;] = {
	&quot;Curonian&quot;,
	35857,
	&quot;bat&quot;,
	&quot;Latn&quot;,
}

m[&quot;xcv&quot;] = {
	&quot;Chuva&quot;,
	3516641,
	&quot;qfa-yuk&quot;,
	&quot;Cyrl&quot;,
	translit = &quot;xcv-translit&quot;
}

m[&quot;xcw&quot;] = {
	&quot;Coahuilteco&quot;,
	2008062,
	&quot;nai-pak&quot;,
}

m[&quot;xcy&quot;] = {
	&quot;Cayuse&quot;,
	2472016,
}

m[&quot;xda&quot;] = {
	&quot;Darkinjung&quot;,
	5223660,
	&quot;aus-yuk&quot;,
	&quot;Latn&quot;,
}

m[&quot;xdc&quot;] = {
	&quot;Dacian&quot;,
	682547,
	&quot;ine&quot;,
	&quot;Latn&quot;,
}

m[&quot;xdk&quot;] = {
	&quot;Dharug&quot;,
	1166814,
	&quot;aus-yuk&quot;,
	&quot;Latn&quot;,
}

m[&quot;xdm&quot;] = {
	&quot;Edom&quot;,
	2363529,
	&quot;sem-can&quot;,
	&quot;Phnx&quot;,
	translit = &quot;Phnx-translit&quot;,
}

m[&quot;xdq&quot;] = {
	&quot;Kaitag&quot;,
	1990659,
	&quot;cau-drg&quot;,
	&quot;Cyrl&quot;,
	translit = {Cyrl = &quot;dar-translit&quot;},
	override_translit = true,
	display_text = {Cyrl = s[&quot;cau-Cyrl-displaytext&quot;]},
	entry_name = {
		Cyrl = s[&quot;cau-Cyrl-entryname&quot;],
		Latn = s[&quot;cau-Latn-entryname&quot;],
	},
	sort_key = {
		Cyrl = {
			from = {
				&quot;къкъ&quot;, &quot;хьхь&quot;, -- 4 chars
				&quot;гъ&quot;, &quot;гь&quot;, &quot;гӏ&quot;, &quot;ё&quot;, &quot;къ&quot;, &quot;кь&quot;, &quot;кӏ&quot;, &quot;пп&quot;, &quot;пӏ&quot;, &quot;сс&quot;, &quot;тт&quot;, &quot;тӏ&quot;, &quot;хх&quot;, &quot;хъ&quot;, &quot;хь&quot;, &quot;хӏ&quot;, &quot;цц&quot;, &quot;цӏ&quot;, &quot;чч&quot;, &quot;чӏ&quot; -- 2 chars
			},
			to = {
				&quot;к&quot; .. p[2], &quot;х&quot; .. p[4],
				&quot;г&quot; .. p[1], &quot;г&quot; .. p[2], &quot;г&quot; .. p[3], &quot;е&quot; .. p[1], &quot;к&quot; .. p[1], &quot;к&quot; .. p[3], &quot;к&quot; .. p[4], &quot;п&quot; .. p[1], &quot;п&quot; .. p[2], &quot;с&quot; .. p[1], &quot;т&quot; .. p[1], &quot;т&quot; .. p[2], &quot;х&quot; .. p[1], &quot;х&quot; .. p[2], &quot;х&quot; .. p[3], &quot;х&quot; .. p[5], &quot;ц&quot; .. p[1], &quot;ц&quot; .. p[2], &quot;ч&quot; .. p[1], &quot;ч&quot; .. p[2]
			}
		},
	},
}

m[&quot;xdy&quot;] = {
	&quot;Malayic Dayak&quot;,
	3514892,
}

m[&quot;xeb&quot;] = {
	&quot;Ebla&quot;,
	35345,
	&quot;sem-eas&quot;,
	&quot;Xsux&quot;,
}

m[&quot;xed&quot;] = {
	&quot;Hdi&quot;,
	56246,
	&quot;cdc-cbm&quot;,
	&quot;Latn&quot;,
}

m[&quot;xeg&quot;] = {
	&quot;ǁXegwi&quot;,
	3509732,
	&quot;khi-tuu&quot;,
	&quot;Latn&quot;,
}

m[&quot;xel&quot;] = {
	&quot;Kelo&quot;,
	6386412,
	&quot;sdv-eje&quot;,
}

m[&quot;xem&quot;] = {
	&quot;Kembayan&quot;,
	6386874,
}

m[&quot;xep&quot;] = {
	&quot;Epi-Olmec&quot;,
	nil,
}

m[&quot;xer&quot;] = {
	&quot;Xerénte&quot;,
	3073436,
	&quot;sai-cje&quot;,
	&quot;Latn&quot;,
}

m[&quot;xes&quot;] = {
	&quot;Kesawai&quot;,
	6394907,
	&quot;ngf-mad&quot;,
	&quot;Latn&quot;,
}

m[&quot;xet&quot;] = {
	&quot;Xetá&quot;,
	2980404,
	&quot;tup-gua&quot;,
	&quot;Latn&quot;,
}

m[&quot;xeu&quot;] = {
	&quot;Keoru-Ahia&quot;,
	11732313,
	&quot;ngf&quot;,
}

m[&quot;xfa&quot;] = {
	&quot;Falisci&quot;,
	35669,
	&quot;itc&quot;,
	&quot;Ital, Latn&quot;,
	translit = &quot;Ital-translit&quot;,
	entry_name = {remove_diacritics = c.macron .. c.breve .. c.diaer},
}

m[&quot;xga&quot;] = {
	&quot;Galatia&quot;,
	27403,
	&quot;cel&quot;,
	&quot;Latn, Grek&quot;,
	ancestors = &quot;cel-gau&quot;,
}

m[&quot;xgb&quot;] = {
	&quot;Gbin&quot;,
	16934745,
	&quot;dmn-mse&quot;,
	&quot;Latn&quot;,
}

m[&quot;xgd&quot;] = {
	&quot;Gudang&quot;,
	5614528,
}

m[&quot;xgf&quot;] = {
	&quot;Gabrielino-Fernandeño&quot;,
	56387,
	&quot;azc-tak&quot;,
	&quot;Latn&quot;,
}

m[&quot;xgg&quot;] = {
	&quot;Goreng&quot;,
	nil,
}

m[&quot;xgi&quot;] = {
	&quot;Garingbal&quot;,
	nil,
}

m[&quot;xgl&quot;] = {
	&quot;Galindan&quot;,
	1190494,
	&quot;bat&quot;,
	&quot;Latn&quot;,
}

m[&quot;xgm&quot;] = {
	&quot;Darumbal&quot;,
	16954400,
}

m[&quot;xgr&quot;] = {
	&quot;Garza&quot;,
	3098656,
	&quot;nai-pak&quot;,
}

m[&quot;xgu&quot;] = {
	&quot;Unggumi&quot;,
	62000004,
	&quot;aus-wor&quot;,
	&quot;Latn&quot;,
}

m[&quot;xgw&quot;] = {
	&quot;Guwa&quot;,
	5621992,
}

m[&quot;xha&quot;] = {
	&quot;Harami&quot;,
	41506724,
	nil,
	&quot;Sarb&quot;,
	translit = &quot;Sarb-translit&quot;,
}

m[&quot;xhc&quot;] = {
	&quot;Hun&quot;,
	35959,
}

m[&quot;xhd&quot;] = {
	&quot;Hadrami&quot;,
	1032453,
	&quot;sem-osa&quot;,
	&quot;Sarb&quot;,
	translit = &quot;Sarb-translit&quot;,
}

m[&quot;xhe&quot;] = {
	&quot;Khetrani&quot;,
	2614111,
	&quot;inc-pan&quot;,
	ancestors = &quot;lah&quot;,
}

m[&quot;xhm&quot;] = {
	&quot;Khmer Pertengahan&quot;,
	25226861,
	&quot;mkh-kmr&quot;,
	&quot;Latn, Khmr&quot;, --and also Pallava
	ancestors = &quot;okz&quot;,
}

m[&quot;xhr&quot;] = {
	&quot;Hernican&quot;,
	5908773,
	&quot;itc-sbl&quot;,
	&quot;Ital&quot;,
}

m[&quot;xht&quot;] = {
	&quot;Hatti&quot;,
	31107,
	&quot;qfa-iso&quot;,
	&quot;Xsux&quot;,
}

m[&quot;xhu&quot;] = {
	&quot;Hurri&quot;,
	35740,
	&quot;qfa-hur&quot;,
	&quot;Xsux, Ugar&quot;,
}

m[&quot;xhv&quot;] = {
	&quot;Khua&quot;,
	22970290,
	&quot;mkh-kat&quot;,
}

m[&quot;xib&quot;] = {
	&quot;Iberia&quot;,
	855215,
	&quot;qfa-iso&quot;,
	&quot;Latn, Ibrn&quot;,
}

m[&quot;xii&quot;] = {
	&quot;Xiri&quot;,
	36876,
}

m[&quot;xin&quot;] = {
	&quot;Xinca&quot;,
	1546494,
	&quot;nai-xin&quot;,
	&quot;Latn&quot;,
}

m[&quot;xil&quot;] = {
	&quot;Illyria&quot;,
	35976,
	&quot;ine&quot;,
	type = &quot;reconstructed&quot;,
}

m[&quot;xir&quot;] = {
	&quot;Xiriâna&quot;,
	2028772,
	&quot;awd&quot;,
	&quot;Latn&quot;,
}

m[&quot;xis&quot;] = {
	&quot;Kisan&quot;,
	nil,
}

m[&quot;xiv&quot;] = {
	&quot;Bahasa Lembah Indus&quot;,
	3428279,
	nil,
	&quot;Inds&quot;,
}

m[&quot;xiy&quot;] = {
	&quot;Xipaya&quot;,
	13226,
	&quot;tup&quot;,
}

m[&quot;xjb&quot;] = {
	&quot;Minjungbal&quot;,
	nil,
	&quot;aus-pam&quot;,
	&quot;Latn&quot;,
}

m[&quot;xka&quot;] = {
	&quot;Kalkoti&quot;,
	3877551,
	&quot;inc-dar&quot;,
	&quot;xka-Arab&quot;,
}

m[&quot;xkb&quot;] = {
	&quot;Manigri-Kambolé Ede Nago&quot;,
	36042,
	&quot;alv-ede&quot;,
}

m[&quot;xkc&quot;] = {
	&quot;Khoini&quot;,
	6401919,
	&quot;xme-ttc&quot;,
	ancestors = &quot;xme-ttc-wes&quot;,
}

m[&quot;xkd&quot;] = {
	&quot;Kayan Mendalam&quot;,
	12952597,
}

m[&quot;xke&quot;] = {
	&quot;Kereho&quot;,
	6437086,
	&quot;poz&quot;,
	&quot;Latn&quot;,
}

m[&quot;xkf&quot;] = {
	&quot;Khengkha&quot;,
	3695207,
	&quot;sit-ebo&quot;,
	&quot;Tibt&quot;,
	translit = &quot;Tibt-translit&quot;,
	override_translit = true,
	display_text = s[&quot;Tibt-displaytext&quot;],
	entry_name = s[&quot;Tibt-entryname&quot;],
	sort_key = &quot;Tibt-sortkey&quot;,
}

m[&quot;xkg&quot;] = {
	&quot;Kagoro&quot;,
	11159524,
	&quot;dmn-wmn&quot;,
}

m[&quot;xki&quot;] = {
	&quot;Bahasa Isyarat Kenya&quot;,
	6392859,
	&quot;sgn&quot;,
}

m[&quot;xkj&quot;] = {
	&quot;Kajali&quot;,
	14916876,
	&quot;xme-ttc&quot;,
	ancestors = &quot;xme-ttc-cen&quot;,
}

m[&quot;xkk&quot;] = {
	&quot;Kaco'&quot;,
	6344767,
	&quot;mkh&quot;,
}

m[&quot;xkl&quot;] = {
	&quot;Bakung&quot;,
	6736761,
	&quot;poz-swa&quot;,
	&quot;Latn&quot;,
}

m[&quot;xkn&quot;] = {
	&quot;Kayan Sungai Kayan&quot;,
	12473395,
	&quot;poz&quot;,
	&quot;Latn&quot;,
}

m[&quot;xko&quot;] = {
	&quot;Kiorr&quot;,
	6414519,
	&quot;mkh-pal&quot;,
}

m[&quot;xkp&quot;] = {
	&quot;Kabatei&quot;,
	34165,
	&quot;xme-ttc&quot;,
	ancestors = &quot;xme-ttc-cen&quot;,
}

m[&quot;xkq&quot;] = {
	&quot;Koroni&quot;,
	3199000,
	&quot;poz-btk&quot;,
}

m[&quot;xkr&quot;] = {
	&quot;Xakriabá&quot;,
	3073441,
	&quot;sai-cje&quot;,
	&quot;Latn&quot;,
}

m[&quot;xks&quot;] = {
	&quot;Kumbewaha&quot;,
	6443722,
}

m[&quot;xkt&quot;] = {
	&quot;Kantosi&quot;,
	35651,
	&quot;nic-dag&quot;,
}

m[&quot;xku&quot;] = {
	&quot;Kaamba&quot;,
	11042324,
	&quot;bnt-kng&quot;,
}

m[&quot;xkv&quot;] = {
	&quot;Kgalagadi&quot;,
	2088743,
	&quot;bnt-sts&quot;,
	&quot;Latn&quot;,
}

m[&quot;xkw&quot;] = {
	&quot;Kembra&quot;,
	12953627,
	&quot;paa-pau&quot;,
}

m[&quot;xkx&quot;] = {
	&quot;Karore&quot;,
	6373260,
	&quot;poz-ocw&quot;,
}

m[&quot;xky&quot;] = {
	&quot;Uma' Lasan&quot;,
	nil,
	&quot;poz-swa&quot;,
}

m[&quot;xkz&quot;] = {
	&quot;Kurtöp&quot;,
	3695193,
	&quot;sit-ebo&quot;,
	&quot;Tibt, Latn&quot;,
	translit = {Tibt = &quot;Tibt-translit&quot;},
	display_text = {Tibt = s[&quot;Tibt-displaytext&quot;]},
	entry_name = {Tibt = s[&quot;Tibt-entryname&quot;]},
	sort_key = {Tibt = &quot;Tibt-sortkey&quot;},
}

m[&quot;xla&quot;] = {
	&quot;Kamula&quot;,
	10957277,
	&quot;ngf&quot;,
}

m[&quot;xlb&quot;] = {
	&quot;Loup B&quot;,
	13108281,
	&quot;alg-eas&quot;,
	&quot;Latn&quot;,
}

m[&quot;xlc&quot;] = {
	&quot;Lycia&quot;,
	35969,
	&quot;ine-ana&quot;,
	&quot;Lyci&quot;,
	translit = &quot;Lyci-translit&quot;,
}

m[&quot;xld&quot;] = {
	&quot;Lydia&quot;,
	36095,
	&quot;ine-ana&quot;,
	&quot;Lydi&quot;,
	translit = &quot;Lydi-translit&quot;,
}

m[&quot;xle&quot;] = {
	&quot;Lemnos&quot;,
	36203,
	&quot;qfa-tyn&quot;,
	&quot;Ital&quot;,
	translit = &quot;Ital-translit&quot;,
}

m[&quot;xlg&quot;] = {
	&quot;Liguria Purba&quot;,
	36104,
	&quot;ine&quot;,
}

m[&quot;xli&quot;] = {
	&quot;Liburni&quot;,
	35835,
	&quot;ine&quot;,
}

--xln is etymology-only

m[&quot;xlo&quot;] = {
	&quot;Loup A&quot;,
	27921265,
	&quot;alg-eas&quot;,
	&quot;Latn&quot;,
}

m[&quot;xlp&quot;] = {
	&quot;Lepontii&quot;,
	35993,
	&quot;cel&quot;,
	&quot;Ital&quot;,
	translit = &quot;Ital-translit&quot;,
}

m[&quot;xls&quot;] = {
	&quot;Lusitania&quot;,
	35960,
	&quot;ine&quot;,
	&quot;Latn&quot;,
}

m[&quot;xlu&quot;] = {
	&quot;Luwiya&quot;,
	12634577,
	&quot;ine-ana&quot;,
	&quot;Xsux, Hluw&quot;,
}

m[&quot;xly&quot;] = {
	&quot;Elymi&quot;,
	35329,
	nil,
	&quot;Grek&quot;,
}

m[&quot;xmb&quot;] = {
	&quot;Mbonga&quot;,
	36064,
	&quot;nic-jrn&quot;,
	&quot;Latn&quot;,
}

m[&quot;xmc&quot;] = {
	&quot;Makhuwa-Marrevone&quot;,
	11127231,
	&quot;bnt-mak&quot;,
	ancestors = &quot;vmw&quot;,
}

m[&quot;xmd&quot;] = {
	&quot;Mbudum&quot;,
	6799790,
	&quot;cdc-cbm&quot;,
	&quot;Latn&quot;,
}

m[&quot;xmf&quot;] = {
	&quot;Mingrelia&quot;,
	13359,
	&quot;ccs-zan&quot;,
	&quot;Geor&quot;,
	translit = &quot;Geor-translit&quot;,
	override_translit = true,
}

m[&quot;xmg&quot;] = {
	&quot;Mengaka&quot;,
	36017,
	&quot;bai&quot;,
	&quot;Latn&quot;,
}

m[&quot;xmh&quot;] = {
	&quot;Kugu-Muminh&quot;,
	10549849,
	&quot;aus-pmn&quot;,
	&quot;Latn&quot;,
}

m[&quot;xmj&quot;] = {
	&quot;Majera&quot;,
	6737666,
	&quot;cdc-cbm&quot;,
	&quot;Latn&quot;,
}

m[&quot;xmk&quot;] = {
	&quot;Macedonia Purba&quot;,
	35974,
	&quot;grk&quot;,
	&quot;Polyt&quot;,
	translit = &quot;grc-translit&quot;,
	entry_name = {remove_diacritics = c.macron .. c.breve},
	sort_key = s[&quot;Grek-sortkey&quot;],
}

m[&quot;xml&quot;] = {
	&quot;Bahasa Isyarat Malaysia&quot;,
	33420,
	&quot;sgn&quot;,
}

m[&quot;xmm&quot;] = {
	&quot;Melayu Manado&quot;,
	1068112,
	&quot;crp&quot;,
	&quot;Latn&quot;,
}

m[&quot;xmo&quot;] = {
	&quot;Morerebi&quot;,
	12953749,
	&quot;tup&quot;,
	&quot;Latn&quot;,
}

m[&quot;xmp&quot;] = {
	&quot;Kuku-Mu'inh&quot;,
	10549852,
	nil,
	&quot;Latn&quot;,
}

m[&quot;xmq&quot;] = {
	&quot;Kuku-Mangk&quot;,
	10549851,
	&quot;aus-pam&quot;,
	&quot;Latn&quot;,
}

m[&quot;xmr&quot;] = {
	&quot;Meroe&quot;,
	13366,
	&quot;afa&quot;,
	&quot;Mero, Merc, Latn&quot;, -- we have entries in Latn
	translit = &quot;xmr-translit&quot;,
}

m[&quot;xms&quot;] = {
	&quot;Bahasa Isyarat Maghribi&quot;,
	6913107,
	&quot;sgn&quot;,
}

m[&quot;xmt&quot;] = {
	&quot;Matbat&quot;,
	6786187,
	&quot;poz-hce&quot;,
}

m[&quot;xmu&quot;] = {
	&quot;Kamu&quot;,
	6359779,
}

m[&quot;xmx&quot;] = {
	&quot;Maden&quot;,
	12952756,
	&quot;poz-hce&quot;,
}

m[&quot;xmy&quot;] = {
	&quot;Mayaguduna&quot;,
	3436736,
}

m[&quot;xmz&quot;] = {
	&quot;Mori Bawah&quot;,
	3324069,
	&quot;poz-btk&quot;,
	&quot;Latn&quot;,
}

m[&quot;xna&quot;] = {
	&quot;Arab Utara Purba&quot;,
	1472213,
	&quot;sem&quot;,
	&quot;Narb&quot;,
	translit = &quot;Narb-translit&quot;,
}

m[&quot;xnb&quot;] = {
	&quot;Kanakanabu&quot;,
	172244,
	&quot;map&quot;,
	&quot;Latn&quot;,
}

m[&quot;xng&quot;] = {
	&quot;Mongol Pertengahan&quot;,
	2582455,
	&quot;xgn&quot;,
	&quot;Mong, Phag, Hani, Arab, Armn&quot;,
	translit = {Mong = &quot;Mong-translit&quot;},
	display_text = {Mong = s[&quot;Mong-displaytext&quot;]},
	entry_name = {Mong = s[&quot;Mong-entryname&quot;]},
	sort_key = {Hani = &quot;Hani-sortkey&quot;},
}

m[&quot;xnh&quot;] = {
	&quot;Kuanhua&quot;,
	6441084,
	&quot;mkh-pal&quot;,
}

m[&quot;xni&quot;] = {
	&quot;Ngarigu&quot;,
	7022072,
	&quot;aus-yuk&quot;,
}

m[&quot;xnk&quot;] = {
	&quot;Nganakarti&quot;,
	33087049,
}

m[&quot;xnn&quot;] = {
	&quot;Kankanay Utara&quot;,
	12953609,
	&quot;phi&quot;,
}

-- &quot;xno&quot; IS TREATED AS &quot;fro&quot;, SEE WT:LT

m[&quot;xnr&quot;] = {
	&quot;Kangri&quot;,
	2331560,
	&quot;him&quot;,
	&quot;Deva, Takr, fa-Arab&quot;,
	ancestors = &quot;doi&quot;,
	translit = &quot;hi-translit&quot;,
}

m[&quot;xns&quot;] = {
	&quot;Kanashi&quot;,
	6360672,
	&quot;sit-whm&quot;,
}

m[&quot;xnt&quot;] = {
	&quot;Narragansett&quot;,
	3336118,
	&quot;alg-eas&quot;,
	&quot;Latn&quot;,
	entry_name = {remove_diacritics = c.grave .. c.acute .. c.tilde .. c.macron},
}

m[&quot;xnu&quot;] = {
	&quot;Nukunul&quot;,
	7068904,
}

m[&quot;xny&quot;] = {
	&quot;Nyiyaparli&quot;,
	16919427,
	&quot;aus-nga&quot;,
	&quot;Latn&quot;,
}

m[&quot;xoc&quot;] = {
	&quot;O'chi'chi'&quot;,
	3813833,
	&quot;nic-cde&quot;,
	&quot;Latn&quot;,
}

m[&quot;xod&quot;] = {
	&quot;Kokoda&quot;,
	6426734,
	&quot;ngf-sbh&quot;,
}

m[&quot;xog&quot;] = {
	&quot;Soga&quot;,
	33784,
	&quot;bnt-nyg&quot;,
	&quot;Latn&quot;,
}

m[&quot;xoi&quot;] = {
	&quot;Kominimung&quot;,
	6428352,
	&quot;paa&quot;,
	&quot;Latn&quot;,
}

m[&quot;xok&quot;] = {
	&quot;Xokleng&quot;,
	3027930,
	&quot;sai-sje&quot;,
}

m[&quot;xom&quot;] = {
	&quot;Komo&quot;,
	56681,
	&quot;ssa-kom&quot;,
}

m[&quot;xon&quot;] = {
	&quot;Konkomba&quot;,
	35674,
	&quot;nic-grm&quot;,
	&quot;Latn&quot;,
}

m[&quot;xoo&quot;] = { -- contrast kzw, sai-kat, sai-xoc
	&quot;Xukurú&quot;,
	9096758,
}

m[&quot;xop&quot;] = {
	&quot;Kopar&quot;,
	11732346,
}

m[&quot;xor&quot;] = {
	&quot;Korubo&quot;,
	3199022,
}

m[&quot;xow&quot;] = {
	&quot;Kowaki&quot;,
	6434920,
	&quot;ngf-mad&quot;,
}

m[&quot;xpa&quot;] = {
	&quot;Pirriya&quot;,
	16978087,
}

m[&quot;xpb&quot;] = {
	&quot;Pyemmairre&quot;,
	7262964,
	nil,
	&quot;Latn&quot;,
}

m[&quot;xpc&quot;] = {
	&quot;Pecheneg&quot;,
	877881,
	&quot;trk&quot;,
}

m[&quot;xpd&quot;] = {
	&quot;Paredarerme&quot;,
	7136678,
	nil,
	&quot;Latn&quot;,
}

m[&quot;xpe&quot;] = {
	&quot;Liberia Kpelle&quot;,
	20527226,
	&quot;dmn-msw&quot;,
	ancestors = &quot;kpe&quot;,
}

m[&quot;xpf&quot;] = {
	&quot;Tasmania Tenggara&quot;,
	7068421,
	nil,
	&quot;Latn&quot;,
}

m[&quot;xpg&quot;] = {
	&quot;Phrygia&quot;,
	36751,
	&quot;ine&quot;,
	&quot;Grek&quot;,
	translit = &quot;grc-translit&quot;,
}

m[&quot;xph&quot;] = {
	&quot;Tyerrernotepanner&quot;,
	7859815,
	nil,
	&quot;Latn&quot;,
}

m[&quot;xpi&quot;] = {
	&quot;Pict&quot;,
	856383,
	&quot;cel&quot;,
	&quot;Ogam, Latn&quot;,
}

m[&quot;xpj&quot;] = {
	&quot;Mpalitjanh&quot;,
	6928192,
	&quot;aus-pam&quot;,
}

m[&quot;xpk&quot;] = {
	&quot;Kulina&quot;,
	6443027,
	&quot;sai-pan&quot;,
}

m[&quot;xpl&quot;] = {
	&quot;Port Sorell&quot;,
	7230944,
	nil,
	&quot;Latn&quot;,
}

m[&quot;xpm&quot;] = {
	&quot;Pumpokol&quot;,
	2991985,
	&quot;qfa-yen&quot;,
	&quot;Latn&quot;,
}

m[&quot;xpn&quot;] = {
	&quot;Kapinawá&quot;,
	6366667,
}

m[&quot;xpo&quot;] = {
	&quot;Pochutec&quot;,
	2427341,
	&quot;azc-nah&quot;,
	&quot;Latn&quot;,
}

m[&quot;xpp&quot;] = {
	&quot;Puyo-Paekche&quot;,
	nil,
}

m[&quot;xpq&quot;] = {
	&quot;Mohegan-Pequot&quot;,
	3319130,
	&quot;alg-eas&quot;,
	&quot;Latn&quot;,
}

m[&quot;xpr&quot;] = {
	&quot;Parthia&quot;,
	25953,
	&quot;ira-mpr&quot;,
	&quot;Prti, Mani, Phlv&quot;,
	translit = {
		Prti = &quot;Prti-translit&quot;,
		Mani = &quot;Mani-translit&quot;,
	},
}

m[&quot;xps&quot;] = {
	&quot;Pisidia&quot;,
	36580,
	&quot;ine-ana&quot;,
}

m[&quot;xpu&quot;] = {
	&quot;Punik&quot;,
	535958,
	&quot;sem-can&quot;,
	&quot;Phnx, Latn, Grek&quot;,
	ancestors = &quot;phn&quot;,
	translit = {Phnx = &quot;Phnx-translit&quot;},
}

m[&quot;xpv&quot;] = {
	&quot;Tommeginne&quot;,
	7819095,
	nil,
	&quot;Latn&quot;,
}

m[&quot;xpw&quot;] = {
	&quot;Peerapper&quot;,
	7160431,
	nil,
	&quot;Latn&quot;,
}

m[&quot;xpx&quot;] = {
	&quot;Toogee&quot;,
	7824008,
	nil,
	&quot;Latn&quot;,
}

m[&quot;xpy&quot;] = {
	&quot;Buyeo&quot;,
	5003359,
	&quot;qfa-kor&quot;,
	&quot;Hani&quot;,
	sort_key = &quot;Hani-sortkey&quot;,
}

m[&quot;xpz&quot;] = {
	&quot;Pulau Bruny&quot;,
	4979601,
	nil,
	&quot;Latn&quot;,
}

m[&quot;xqa&quot;] = {
	&quot;Karakhanid&quot;,
	nil,
	&quot;trk-kar&quot;,
	&quot;Arab&quot;,
	entry_name = &quot;ar-entryname&quot;,
}

m[&quot;xqt&quot;] = {
	&quot;Qatabanian&quot;,
	384101,
	&quot;sem-osa&quot;,
	&quot;Sarb&quot;,
	translit = &quot;Sarb-translit&quot;,
}

m[&quot;xra&quot;] = {
	&quot;Krahô&quot;,
	3199549,
	&quot;sai-nje&quot;,
	&quot;Latn&quot;,
}

m[&quot;xrb&quot;] = {
	&quot;Karaboro Timur&quot;,
	35716,
	&quot;alv-krb&quot;,
}

m[&quot;xrd&quot;] = {
	&quot;Gundungurra&quot;,
	nil,
}

m[&quot;xre&quot;] = {
	&quot;Kreye&quot;,
	3199686,
	&quot;sai-nje&quot;,
}

m[&quot;xrg&quot;] = {
	&quot;Minang&quot;,
	22893424,
}

m[&quot;xri&quot;] = {
	&quot;Krikati-Timbira&quot;,
	3199710,
}

m[&quot;xrm&quot;] = {
	&quot;Armazic&quot;,
	7599646,
}

m[&quot;xrn&quot;] = {
	&quot;Arin&quot;,
	34088,
	&quot;qfa-yen&quot;,
	&quot;Latn&quot;,
}

m[&quot;xrq&quot;] = {
	&quot;Karranga&quot;,
	6373349,
	nil,
	&quot;Latn&quot;,
}

m[&quot;xrr&quot;] = {
	&quot;Raetic&quot;,
	36689,
	nil,
	&quot;Ital&quot;,
	translit = &quot;Ital-translit&quot;,
}

m[&quot;xrt&quot;] = {
	&quot;Aranama-Tamique&quot;,
	2859505,
}

m[&quot;xru&quot;] = {
	&quot;Marriammu&quot;,
	10577724,
	&quot;aus-dal&quot;,
}

m[&quot;xrw&quot;] = {
	&quot;Karawa&quot;,
	6368857,
	&quot;paa-spk&quot;,
}

m[&quot;xsa&quot;] = {
	&quot;Sabaean&quot;,
	1070391,
	&quot;sem-osa&quot;,
	&quot;Sarb&quot;,
	translit = &quot;Sarb-translit&quot;,
}

m[&quot;xsb&quot;] = {
	&quot;Sambal&quot;,
	2592378,
	&quot;phi&quot;,
	&quot;Latn&quot;,
}

m[&quot;xsd&quot;] = {
	&quot;Sidetic&quot;,
	36659,
	&quot;ine-ana&quot;,
}

m[&quot;xse&quot;] = {
	&quot;Sempan&quot;,
	3504358,
}

m[&quot;xsh&quot;] = {
	&quot;Shamang&quot;,
	3914876,
	&quot;nic-plc&quot;,
}

m[&quot;xsi&quot;] = {
	&quot;Sio&quot;,
	3485100,
	&quot;poz-ocw&quot;,
}

m[&quot;xsj&quot;] = {
	&quot;Subi&quot;,
	7631298,
	&quot;bnt-haj&quot;,
}

m[&quot;xsl&quot;] = {
	&quot;Slavey Selatan&quot;,
	28552,
	&quot;ath-nor&quot;,
	&quot;Latn&quot;,
}

m[&quot;xsm&quot;] = {
	&quot;Kasem&quot;,
	35552,
	&quot;nic-gnn&quot;,
}

m[&quot;xsn&quot;] = {
	&quot;Sanga (Nigeria)&quot;,
	3915334,
	&quot;nic-jer&quot;,
	&quot;Latn&quot;,
}

m[&quot;xso&quot;] = {
	&quot;Solano&quot;,
	2474492,
	nil,
	&quot;Latn&quot;,
}

m[&quot;xsp&quot;] = {
	&quot;Silopi&quot;,
	7515533,
	&quot;ngf-mad&quot;,
}

m[&quot;xsq&quot;] = {
	&quot;Makhuwa-Saka&quot;,
	11008159,
	&quot;bnt-mak&quot;,
	ancestors = &quot;vmw&quot;,
}

m[&quot;xsr&quot;] = {
	&quot;Sherpa&quot;,
	36612,
	&quot;sit-tib&quot;,
	&quot;Tibt, Deva&quot;,
	ancestors = &quot;xct&quot;,
	translit = {
		Tibt = &quot;Tibt-translit&quot;,
		Deva = &quot;xsr-Deva-translit&quot;,
	},
	override_translit = true,
	display_text = {Tibt = s[&quot;Tibt-displaytext&quot;]},
	entry_name = {Tibt = s[&quot;Tibt-entryname&quot;]},
	sort_key = {Tibt = &quot;Tibt-sortkey&quot;},
}

m[&quot;xss&quot;] = {
	&quot;Assan&quot;,
	34089,
	&quot;qfa-yen&quot;,
	&quot;Latn&quot;,
}

m[&quot;xsu&quot;] = {
	&quot;Sanumá&quot;,
	251728,
	&quot;sai-ynm&quot;,
	&quot;Latn&quot;,
}

m[&quot;xsv&quot;] = {
	&quot;Sudovian&quot;,
	35603,
	&quot;bat&quot;,
	&quot;Latn&quot;,
}

m[&quot;xsy&quot;] = {
	&quot;Saisiyat&quot;,
	716695,
	&quot;map&quot;,
	&quot;Latn&quot;,
}

m[&quot;xta&quot;] = {
	&quot;Alcozauca Mixtec&quot;,
	25559587,
	&quot;omq-mxt&quot;,
	&quot;Latn&quot;,
}

m[&quot;xtb&quot;] = {
	&quot;Chazumba Mixtec&quot;,
	12182838,
	&quot;omq-mxt&quot;,
	&quot;Latn&quot;,
}

m[&quot;xtc&quot;] = {
	&quot;Kadugli&quot;,
	3407136,
	&quot;qfa-kad&quot;,
	&quot;Latn&quot;,
}

m[&quot;xtd&quot;] = {
	&quot;Diuxi-Tilantongo Mixtec&quot;,
	7802048,
	&quot;omq-mxt&quot;,
	&quot;Latn&quot;,
}

m[&quot;xte&quot;] = {
	&quot;Ketengban&quot;,
	10990152,
}

m[&quot;xth&quot;] = {
	&quot;Yitha Yitha&quot;,
	nil,
}

m[&quot;xti&quot;] = {
	&quot;Sinicahua Mixtec&quot;,
	12953733,
	&quot;omq-mxt&quot;,
	&quot;Latn&quot;,
}

m[&quot;xtj&quot;] = {
	&quot;San Juan Teita Mixtec&quot;,
	32093049,
	&quot;omq-mxt&quot;,
	&quot;Latn&quot;,
}

m[&quot;xtl&quot;] = {
	&quot;Tijaltepec Mixtec&quot;,
	12953738,
	&quot;omq-mxt&quot;,
	&quot;Latn&quot;,
}

m[&quot;xtm&quot;] = {
	&quot;Mixtec Magdalena Peñasco&quot;,
	7179700,
	&quot;omq-mxt&quot;,
	&quot;Latn&quot;,
}

m[&quot;xtn&quot;] = {
	&quot;Mixtec Tlaxiaco Utara&quot;,
	25559585,
	&quot;omq-mxt&quot;,
	&quot;Latn&quot;,
}

m[&quot;xto&quot;] = {
	&quot;Tocharia A&quot;,
	2827041,
	&quot;ine-toc&quot;,
	&quot;Latn&quot;,
	wikipedia_article = &quot;Tocharian languages&quot;, -- wikidata id has no associated article
}

m[&quot;xtp&quot;] = {
	&quot;Mixtec San Miguel Piedras&quot;,
	7414970,
	&quot;omq-mxt&quot;,
	&quot;Latn&quot;,
}

m[&quot;xtq&quot;] = {
	&quot;Tumshuq&quot;,
	nil,
	&quot;xsc-sak&quot;,
	&quot;Brah, Khar&quot;,
	translit = &quot;Brah-translit&quot;,
}

m[&quot;xtr&quot;] = {
	&quot;Tripuri Awal&quot;,
	nil,
}

m[&quot;xts&quot;] = {
	&quot;Mixtec Sindihui&quot;,
	13583581,
	&quot;omq-mxt&quot;,
	&quot;Latn&quot;,
}

m[&quot;xtt&quot;] = {
	&quot;Mixtec Tacahua&quot;,
	7673668,
	&quot;omq-mxt&quot;,
	&quot;Latn&quot;,
}

m[&quot;xtu&quot;] = {
	&quot;Mixtec Cuyamecalco&quot;,
	12953726,
	&quot;omq-mxt&quot;,
	&quot;Latn&quot;,
}

m[&quot;xtv&quot;] = {
	&quot;Thawa&quot;,
	7711494,
}

m[&quot;xtw&quot;] = {
	&quot;Tawandê&quot;,
	nil,
	&quot;sai-nmk&quot;,
	&quot;Latn&quot;,
}

m[&quot;xty&quot;] = {
	&quot;Mixtec Yoloxochitl&quot;,
	8054817,
	&quot;omq-mxt&quot;,
	&quot;Latn&quot;,
}

m[&quot;xtz&quot;] = {
	&quot;Tasmania&quot;,
	530739,
	nil,
	&quot;Latn&quot;,
}

m[&quot;xua&quot;] = {
	&quot;Kurumba Alu&quot;,
	12952679,
	&quot;dra&quot;,
}

m[&quot;xub&quot;] = {
	&quot;Kurumba Betta&quot;,
	16841033,
	&quot;dra&quot;,
	&quot;Knda, Mlym, Taml&quot;,
}

m[&quot;xud&quot;] = {
	&quot;Umiida&quot;,
	61999874,
	&quot;aus-wor&quot;,
	&quot;Latn&quot;,
}

m[&quot;xug&quot;] = {
	&quot;Kunigami&quot;,
	56558,
	&quot;jpx-ryu&quot;,
	&quot;Jpan&quot;,
	translit = s[&quot;Jpan-translit&quot;],
	sort_key = s[&quot;Jpan-sortkey&quot;],
}

m[&quot;xuj&quot;] = {
	&quot;Jennu Kurumba&quot;,
	21282543,
	&quot;dra&quot;,
}

m[&quot;xul&quot;] = {
	&quot;Ngunawal&quot;,
	7022712,
	&quot;aus-yuk&quot;,
	&quot;Latn&quot;,
}

m[&quot;xum&quot;] = {
	&quot;Umbri&quot;,
	36957,
	&quot;itc-sbl&quot;,
	&quot;Ital, Latn&quot;,
	translit = &quot;Ital-translit&quot;,
}

m[&quot;xun&quot;] = {
	&quot;Unggaranggu&quot;,
	61999823,
	&quot;aus-wor&quot;,
	&quot;Latn&quot;,
}

m[&quot;xuo&quot;] = {
	&quot;Kuo&quot;,
	6445233,
	&quot;alv-mbm&quot;,
}

m[&quot;xup&quot;] = {
	&quot;Upper Umpqua&quot;,
	20607,
	&quot;ath-pco&quot;,
	&quot;Latn&quot;,
}

m[&quot;xur&quot;] = {
	&quot;Urartian&quot;,
	36934,
	&quot;qfa-hur&quot;,
	&quot;Xsux&quot;,
}

m[&quot;xut&quot;] = {
	&quot;Kuthant&quot;,
	6448417,
}

m[&quot;xuu&quot;] = {
	&quot;Khwe&quot;,
	28305,
	&quot;khi-kal&quot;,
	&quot;Latn&quot;,
}

m[&quot;xve&quot;] = {
	&quot;Venetic&quot;,
	36871,
	&quot;ine&quot;,
	&quot;Ital&quot;,
	translit = &quot;Ital-translit&quot;,
}

-- m[&quot;xvi&quot;] = { &quot;Kamviri&quot;, 1193495, &quot;nur-nor&quot;, Arab } moved to etym-only code

m[&quot;xvn&quot;] = {
	&quot;Vandalic&quot;,
	36835,
	&quot;gme&quot;,
	&quot;Latn&quot;,
}

m[&quot;xvo&quot;] = {
	&quot;Volscian&quot;,
	622110,
	&quot;itc-sbl&quot;,
	&quot;Latn&quot;,
}

m[&quot;xvs&quot;] = {
	&quot;Vestinian&quot;,
	2576407,
	&quot;itc&quot;,
	&quot;Latn&quot;,
}

m[&quot;xwa&quot;] = {
	&quot;Kwaza&quot;,
	3200839,
}

m[&quot;xwc&quot;] = {
	&quot;Woccon&quot;,
	3569569,
	&quot;nai-cat&quot;,
	&quot;Latn&quot;,
}

m[&quot;xwd&quot;] = {
	&quot;Wadi Wadi&quot;,
	7959249,
}

m[&quot;xwe&quot;] = {
	&quot;Xwela Gbe&quot;,
	36887,
	&quot;alv-pph&quot;,
}

m[&quot;xwg&quot;] = {
	&quot;Kwegu&quot;,
	56723,
	&quot;sdv&quot;,
}

m[&quot;xwj&quot;] = {
	&quot;Wajuk&quot;,
	33110188,
}

m[&quot;xwk&quot;] = {
	&quot;Wangkumara&quot;,
	7967891,
	&quot;aus-pam&quot;,
	&quot;Latn&quot;,
}

m[&quot;xwl&quot;] = {
	&quot;Gbe Xwla Barat&quot;,
	36924,
	&quot;alv-pph&quot;,
	&quot;Latn&quot;,
}

m[&quot;xwo&quot;] = {
	&quot;Oirat Bertulis&quot;,
	56959,
	&quot;xgn-cen&quot;,
	&quot;xwo-Mong&quot;,
	translit = &quot;xwo-translit&quot;,
}

m[&quot;xwr&quot;] = {
	&quot;Kwerba Mamberamo&quot;,
	6450325,
	&quot;paa-tkw&quot;,
}

m[&quot;xww&quot;] = {
	&quot;Wemba-Wemba&quot;,
	18472819,
	&quot;aus-pam&quot;,
	&quot;Latn&quot;,
}

m[&quot;xxb&quot;] = {
	&quot;Boro&quot;,
	16844787,
	nil,
	&quot;Latn&quot;,
}

m[&quot;xxk&quot;] = {
	&quot;Ke'o&quot;,
	3195346,
}

m[&quot;xxm&quot;] = {
	&quot;Minkin&quot;,
	6867836,
}

m[&quot;xxr&quot;] = {
	&quot;Koropó&quot;,
	6432560,
}

m[&quot;xxt&quot;] = {
	&quot;Tambora&quot;,
	36711,
	&quot;paa&quot;,
	&quot;Latn&quot;,
}

m[&quot;xya&quot;] = {
	&quot;Yaygir&quot;,
	8050525,
	&quot;aus-pam&quot;,
}

m[&quot;xyb&quot;] = {
	&quot;Yandjibara&quot;,
	nil,
	nil,
	&quot;Latn&quot;,
}

m[&quot;xyl&quot;] = {
	&quot;Yalakalore&quot;,
	12645352,
	&quot;sai-nmk&quot;,
	&quot;Latn&quot;,
}

m[&quot;xyt&quot;] = {
	&quot;Mayi-Thakurti&quot;,
	47004719,
	&quot;aus-pam&quot;,
	&quot;Latn&quot;,
}

m[&quot;xyy&quot;] = {
	&quot;Yorta Yorta&quot;,
	8055849,
	&quot;aus-pam&quot;,
	&quot;Latn&quot;,
}

m[&quot;xzh&quot;] = {
	&quot;Zhang-Zhung&quot;,
	3437292,
	&quot;sit-alm&quot;,
	&quot;xzh-Tibt, Marc&quot;,
	display_text = {[&quot;xzh-Tibt&quot;] = s[&quot;Tibt-displaytext&quot;]},
	entry_name = {[&quot;xzh-Tibt&quot;] = s[&quot;Tibt-entryname&quot;]},
}

m[&quot;xzm&quot;] = {
	&quot;Zemgalia&quot;,
	47631,
	&quot;bat&quot;,
}

m[&quot;xzp&quot;] = {
	&quot;Zapotec Purba&quot;,
	nil,
}

return require(&quot;Module:languages&quot;).finalizeData(m, &quot;language&quot;)</text>
      <sha1>n40topjbk5dwq74kd70arslduv875oh</sha1>
    </revision>
  </page>
  <page>
    <title>Templat:af-bulan kalendar Masihi</title>
    <ns>10</ns>
    <id>11122</id>
    <revision>
      <id>342812</id>
      <parentid>225993</parentid>
      <timestamp>2026-05-16T12:36:59Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <origin>342812</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1776" sha1="fjxa2ylhhue7t6anblm12s1sl8v6yk8" xml:space="preserve">&lt;onlyinclude&gt;&lt;div id=&quot;rank&quot; align=&quot;center&quot;&gt;
{| border=&quot;1&quot; cellpadding=&quot;4&quot; cellspacing=&quot;0&quot; style=&quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse;&quot;
! colspan=12 | &lt;div class=&quot;center&quot;&gt;Die twaalf [[maand|maande]] van die Gregoriaanse [[jaar]]&lt;/div&gt;
|-
| bgcolor=&quot;#afafaf&quot; style=&quot;text-align: center; width: 5em&quot; | {{l|af|Januarie}}&lt;br&gt;{{l|af|یَنِڤَارِي}}
| bgcolor=&quot;#bfbfbf&quot; style=&quot;text-align: center; width: 5em&quot; | {{l|af|Februarie}}&lt;br&gt;{{l|af|فَِبِرْڤَارِي}}
| bgcolor=&quot;#afafaf&quot; style=&quot;text-align: center; width: 5em&quot; | {{l|af|Maart}}&lt;br&gt;{{l|af|مَارْتْ}}
| bgcolor=&quot;#bfbfbf&quot; style=&quot;text-align: center; width: 5em&quot; | {{l|af|April}}&lt;br&gt;{{l|af|آپْرِلْ}}
| bgcolor=&quot;#cfcfcf&quot; style=&quot;text-align: center; width: 5em&quot; | {{l|af|Mei}}&lt;br&gt;{{l|af|مَيْ}}
| bgcolor=&quot;#cfcfcf&quot; style=&quot;text-align: center; width: 5em&quot; | {{l|af|Junie}}&lt;br&gt;{{l|af|یُینِي}}
| bgcolor=&quot;#cfcfcf&quot; style=&quot;text-align: center; width: 5em&quot; | {{l|af|Julie}}&lt;br&gt;{{l|af|یُیلِي}}
| bgcolor=&quot;#cfcfcf&quot; style=&quot;text-align: center; width: 5em&quot; | {{l|af|Augustus}}&lt;br&gt;{{l|af|اَوْخِوسْتِوسْ}}
| bgcolor=&quot;#bfbfbf&quot; style=&quot;text-align: center; width: 5em&quot; | {{l|af|September}}&lt;br&gt;{{l|af|سِپْتَِمْبِرْ}}
| bgcolor=&quot;#afafaf&quot; style=&quot;text-align: center; width: 5em&quot; | {{l|af|Oktober}}&lt;br&gt;{{l|af|اَُوكْتُوَبِرْ}}
| bgcolor=&quot;#bfbfbf&quot; style=&quot;text-align: center; width: 5em&quot; | {{l|af|November}}&lt;br&gt;{{l|af|نُوفَِمْبِرْ}}
| bgcolor=&quot;#afafaf&quot; style=&quot;text-align: center; width: 5em&quot; | {{l|af|Desember}}&lt;br&gt;{{l|af|دِیسَِمْبِرْ|sc=Arab}} {{l|af|دَِیسَِمْبِرْ|sc=Arab}}
|}&lt;/div&gt;

[[Kategori:af:Bulan takwim Masihi]]
&lt;/onlyinclude&gt;
&lt;noinclude&gt;
[[Kategori:Templat|af-kalendar]]</text>
      <sha1>fjxa2ylhhue7t6anblm12s1sl8v6yk8</sha1>
    </revision>
  </page>
  <page>
    <title>Modul:category tree/topic/Communication</title>
    <ns>828</ns>
    <id>11523</id>
    <revision>
      <id>342796</id>
      <parentid>281456</parentid>
      <timestamp>2026-05-16T12:11:57Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <origin>342796</origin>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="6054" sha1="cjlofl7ldcty9627g1ibrq2is2urz62" xml:space="preserve">local labels = {}

local unpack = unpack or table.unpack -- Lua 5.2 compatibility

-- FIXME: Lookup langs in the language list.
for _, lang_etc in ipairs {
	&quot;Arab&quot;, {&quot;Cina&quot;, &quot;Bahasa-bahasa Cina&quot;}, &quot;Inggeris&quot;, &quot;Jerman&quot;, &quot;Jepun&quot;, &quot;Okinawa&quot;,
	 &quot;Portugis&quot;, &quot;Sepanyol&quot;, &quot;Vietnam&quot;, {&quot;Melayu&quot;, &quot;Bahasa-bahasa Melayik&quot;},
} do
	if type(lang_etc) ~= &quot;table&quot; then
		lang_etc = {lang_etc}
	end
	local lang, desc = unpack(lang_etc)
	desc = desc or (&quot;[[:Kategori:Bahasa %s|bahasa %s]]&quot;):format(lang, lang)
	labels[lang] = {
		type = &quot;berkenaan&quot;,
		description = &quot;=&quot; .. desc,
		parents = {&quot;bahasa-bahasa&quot;},
	}
end

labels[&quot;komunikasi&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;Semua topik&quot;},
}

labels[&quot;huruf&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default&quot;,
	parents = {&quot;sistem tulisan&quot;},
}

labels[&quot;bahasa buatan&quot;] = { -- distinguish from &quot;cat:constructed languages&quot; family category
	type = &quot;nama&quot;,
	description = &quot;={{w|constructed language}}s&quot;,
	parents = {&quot;bahasa-bahasa&quot;},
}

labels[&quot;bahasa badan&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;bahasa&quot;, &quot;nonverbal communication&quot;},
}

labels[&quot;penyiaran&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;media&quot;, &quot;telekomunikasi&quot;},
}

labels[&quot;Komponen aksara Cina&quot;] = {
	type = &quot;set&quot;,
	description = &quot;=[[komponen|Komponen]] [[aksara]] [[Cina]].&quot;,
	parents = {&quot;Huruf, simbol dan tanda baca&quot;},
}

labels[&quot;tanda diakritik&quot;] = {
	type = &quot;set&quot;,
	description = &quot;default&quot;,
	parents = {&quot;Huruf, simbol dan tanda baca&quot;},
}

labels[&quot;dialek&quot;] = {
	type = &quot;set&quot;,
	description = &quot;default&quot;,
	parents = {&quot;bahasa&quot;},
}

labels[&quot;dictation&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;komunikasi&quot;},
}

labels[&quot;bahasa pupus&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default&quot;,
	parents = {&quot;bahasa-bahasa&quot;},
}

labels[&quot;bahasa isyarat&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default&quot;,
	parents = {&quot;bahasa-bahasa&quot;},
}

labels[&quot;facial expressions&quot;] = {
	type = &quot;set&quot;,
	description = &quot;default&quot;,
	parents = {&quot;nonverbal communication&quot;, &quot;face&quot;},
}

labels[&quot;kiasan&quot;] = {
	type = &quot;set&quot;,
	description = &quot;=[[figure of speech|figures of speech]]&quot;,
	parents = {&quot;retorik&quot;},
}

labels[&quot;bendera&quot;] = {
	type = &quot;berkenaan,name,type&quot;,
	description = &quot;default&quot;,
	parents = {&quot;komunikasi&quot;},
}

labels[&quot;jargon&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;bahasa&quot;},
}

labels[&quot;aksara Han&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;sistem tulisan&quot;},
}

labels[&quot;bahasa&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;komunikasi&quot;},
}

labels[&quot;keluarga bahasa&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;Topik berkenaan [[keluarga bahasa]], termasuklah yang diterima dan yang bersifat kontroversi.&quot;,
	parents = {&quot;bahasa&quot;, &quot;nama&quot;},
}

labels[&quot;bahasa-bahasa&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default&quot;,
	parents = {&quot;bahasa&quot;, &quot;nama&quot;},
}

labels[&quot;Huruf, simbol dan tanda baca&quot;] = {
	type = &quot;set&quot;,
	description = &quot;=[[letter]]s, [[symbol]]s, and [[punctuation]]&quot;,
	parents = {&quot;Ortografi&quot;},
}

labels[&quot;logical fallacies&quot;] = {
	type = &quot;set&quot;,
	description = &quot;=[[logical fallacy|logical fallacies]], clearly defined errors in reasoning used to support or refute an argument&quot;,
	additional = &quot;{{also|Kategori:{{{langcode}}}:biases}}&quot;,
	parents = {&quot;retorik&quot;, &quot;logic&quot;},
}

labels[&quot;media&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;komunikasi&quot;},
}

labels[&quot;telefon bimbit&quot;] = {
	type = &quot;berkenaan,set&quot;,
	description = &quot;default&quot;,
	parents = {&quot;telefoni&quot;},
}

labels[&quot;nonverbal communication&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;komunikasi&quot;},
}

labels[&quot;ortografi&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;penulisan&quot;},
}

labels[&quot;palaeography&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;penulisan&quot;},
}

labels[&quot;pos&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;=[[post#Noun|post]] or [[mail#Noun|mail]]&quot;,
	parents = {&quot;komunikasi&quot;},
}

labels[&quot;postal abbreviations&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default&quot;,
	parents = {&quot;pos&quot;},
}

labels[&quot;public relations&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default no singularize&quot;,
	parents = {&quot;komunikasi&quot;},
}

labels[&quot;tanda baca&quot;] = {
	type = &quot;set&quot;,
	description = &quot;default&quot;,
	parents = {&quot;Huruf, simbol dan tanda baca&quot;},
}

labels[&quot;radio&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;telekomunikasi&quot;},
}

labels[&quot;retorik&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;bahasa&quot;},
}

labels[&quot;signs&quot;] = {
	type = &quot;berkenaan,name,type&quot;,
	description = &quot;default&quot;,
	parents = {&quot;komunikasi&quot;},
}

labels[&quot;sociolects&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default&quot;,
	parents = {&quot;bahasa&quot;},
}

labels[&quot;simbol&quot;] = {
	type = &quot;set&quot;,
	description = &quot;=[[symbol]]s, especially [[mathematical]] and [[scientific]] symbols&quot;,
	additional = &quot;Most symbols have equivalent meanings in many languages and can therefore be found in [[:Category:Translingual symbols]].&quot;,
	parents = {&quot;Huruf, simbol dan tanda baca&quot;},
}

labels[&quot;bercakap&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;bahasa&quot;, &quot;tingkah laku manusia&quot;},
}

labels[&quot;telekomunikasi&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default no singularize&quot;,
	parents = {&quot;komunikasi&quot;, &quot;teknologi&quot;},
}

labels[&quot;telegrafi&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;telekomunikasi&quot;, &quot;elektronik&quot;},
	wpcat = true,
	commonscat = true,
}

labels[&quot;telefoni&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;telekomunikasi&quot;, &quot;elektronik&quot;},
}

labels[&quot;bermesej&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;telekomunikasi&quot;},
}

labels[&quot;textual division&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;penulisan&quot;},
}

labels[&quot;tipografi&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;penulisan&quot;, &quot;percetakan&quot;},
}

labels[&quot;penulisan&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;bahasa&quot;, &quot;tingkah laku manusia&quot;},
}

labels[&quot;sistem tulisan&quot;] = {
	type = &quot;set&quot;,
	description = &quot;default&quot;,
	parents = {&quot;penulisan&quot;},
}

return labels</text>
      <sha1>cjlofl7ldcty9627g1ibrq2is2urz62</sha1>
    </revision>
  </page>
  <page>
    <title>Modul:category tree/topic/People</title>
    <ns>828</ns>
    <id>11537</id>
    <revision>
      <id>342831</id>
      <parentid>335837</parentid>
      <timestamp>2026-05-16T14:03:42Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <origin>342831</origin>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="5263" sha1="7wb4jzot9zc177alsvu4t6565vo78zx" xml:space="preserve">local labels = {}

labels[&quot;orang&quot;] = {
	description = &quot;default&quot;,
	parents = {&quot;manusia&quot;},
}

labels[&quot;orang perempuan&quot;] = {
	type = &quot;set&quot;,
	description = &quot;default&quot;,
	parents = {&quot;orang&quot;, &quot;perempuan&quot;},
}

labels[&quot;orang lelaki&quot;] = {
	type = &quot;set&quot;,
	description = &quot;default&quot;,
	parents = {&quot;orang&quot;, &quot;lelaki&quot;},
}


labels[&quot;demonim Armenia&quot;] = {
	description = &quot;{{{langname}}} terms related to Armenian [[demonym]]s, i.e., [[demonym]]s relating to places in [[Armenia]], as well as Armenian diaspora communities abroad.&quot;,
	parents = {&quot;demonim&quot;, &quot;Armenia&quot;},
}

labels[&quot;atlet&quot;] = {
	description = &quot;default&quot;,
	parents = {&quot;pekerjaan&quot;, &quot;olahraga&quot;},
}

labels[&quot;pengarang&quot;] = {
	description = &quot;default&quot;,
	parents = {&quot;orang&quot;, &quot;kesusasteraan&quot;},
}

labels[&quot;Barack Obama&quot;] = {
	description = &quot;{{{langname}}} terms related to [[w:Barack Obama|Barack Obama]], [[president]] of the [[United States]] from 2009 until present.&quot;,
	parents = {&quot;individuals&quot;, &quot;politics&quot;, &quot;United States of America&quot;},
}

labels[&quot;bayi&quot;] = {
	description = &quot;Istilah berkenaan [[bayi]] dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;kanak-kanak&quot;},
}

labels[&quot;kanak-kanak&quot;] = {
	description = &quot;Istilah berkenaan [[kanak-kanak]] dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;orang&quot;},
}

labels[&quot;demonim&quot;] = {
	type = &quot;set&quot;,
	description = &quot;[[demonim|Demonim]], gelaran terhadap kumpulan penetap sesuatu tempat dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;orang&quot;, &quot;nama&quot;},
}

labels[&quot;E. E. Smith&quot;] = {
	description = &quot;{{{langname}}} terms and phrases coined by [[w:E. E. Smith|E. E. Smith]], or otherwise derived from or related to his works.&quot;,
	parents = {&quot;authors&quot;, &quot;American fiction&quot;, &quot;science fiction&quot;, &quot;kesusasteraan&quot;},
}

labels[&quot;ethnicity&quot;] = {
	description = &quot;default&quot;,
	parents = {&quot;orang&quot;},
}

labels[&quot;keluarga&quot;] = {
	description = &quot;default&quot;,
	parents = {&quot;orang&quot;},
}

labels[&quot;ahli keluarga&quot;] = {
	type = &quot;set&quot;,
	description = &quot;Gelaran ahli-ahli keluarga dalam bahasa {{{langname}}} termasuk [[saudara]], [[mentua]] dll.&quot;,
	parents = {&quot;keluarga&quot;},
}

labels[&quot;ahli keluarga perempuan&quot;] = {
	type = &quot;set&quot;,
	description = &quot;Gelaran ahli-ahli keluarga [[perempuan]] dalam bahasa {{{langname}}} termasuk [[saudara]], [[mentua]] dll.&quot;,
	parents = {&quot;ahli keluarga&quot;, &quot;orang perempuan&quot;},
}

labels[&quot;ahli keluarga lelaki&quot;] = {
	type = &quot;set&quot;,
	description = &quot;Gelaran ahli-ahli keluarga [[lelaki]] dalam bahasa {{{langname}}} termasuk [[saudara]], [[mentua]] dll.&quot;,
	parents = {&quot;ahli keluarga&quot;, &quot;orang lelaki&quot;},
}

labels[&quot;peminat&quot;] = {
	description = &quot;Istilah gelaran para peminat penggiat dan karya seni dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;orang&quot;, &quot;fandom&quot;},
}

labels[&quot;George W. Bush&quot;] = {
	description = &quot;{{{langname}}} terms related to [[w:George W. Bush|George W. Bush]], [[president]] of the [[United States]] from 2001 to 2009.&quot;,
	parents = {&quot;individuals&quot;, &quot;politics&quot;, &quot;United States of America&quot;},
}

labels[&quot;ketua negara&quot;] = {
	type = &quot;set&quot;,
	description = &quot;Gelaran [[ketua negara]] dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;pekerjaan&quot;, &quot;pemerintahan&quot;},
}

labels[&quot;pekerjaan kesihatan&quot;] = {
	type = &quot;set&quot;,
	description = &quot;default-set&quot;,
	parents = {&quot;pekerjaan&quot;, &quot;penjagaan kesihatan&quot;},
}

labels[&quot;individu&quot;] = {
	type = &quot;set&quot;,
	description = &quot;{{{langname}}} names of [[individual]]s.&quot;,
	parents = {&quot;orang&quot;},
}

labels[&quot;Isaac Asimov&quot;] = {
	description = &quot;{{{langname}}} terms and phrases coined by [[w:Isaac Asimov|Isaac Asimov]], or otherwise derived from or related to his works.&quot;,
	parents = {&quot;authors&quot;, &quot;American fiction&quot;, &quot;science fiction&quot;, &quot;kesusasteraan&quot;},
}

labels[&quot;J. R. R. Tolkien&quot;] = {
	description = &quot;{{{langname}}} terms related to author [[w:J. R. R. Tolkien|J. R. R. Tolkien]] and his works.&quot;,
	parents = {&quot;authors&quot;, &quot;British fiction&quot;, &quot;fantasy&quot;, &quot;kesusasteraan&quot;},
}

labels[&quot;Latvian demonyms&quot;] = {
	description = &quot;{{{langname}}} terms related to Latvian [[demonym]]s, i.e., [[demonym]]s relating to places in [[Latvia]].&quot;,
	parents = {&quot;demonim&quot;, &quot;Latvia&quot;},
}

labels[&quot;Lewis Carroll&quot;] = {
	description = &quot;{{{langname}}} terms and phrases coined by [[w:Lewis Carroll|Lewis Carroll]], or otherwise derived from his works.&quot;,
	parents = {&quot;authors&quot;, &quot;British fiction&quot;, &quot;fantasy&quot;, &quot;kesusasteraan&quot;},
}

labels[&quot;military ranks&quot;] = {
	type = &quot;set&quot;,
	description = &quot;{{{langname}}} terms for [[rank]]s of the [[military]].&quot;,
	parents = {&quot;pekerjaan&quot;, &quot;ketenteraan&quot;},
}

labels[&quot;kerakyatan&quot;] = {
	type = &quot;set&quot;,
	description = &quot;default-set&quot;,
	parents = {&quot;demonim&quot;, &quot;orang&quot;},
}

labels[&quot;kebangsawanan&quot;] = {
	description = &quot;default&quot;,
	parents = {&quot;orang&quot;},
}

labels[&quot;pekerjaan&quot;] = {
	type = &quot;set&quot;,
	description = &quot;Istilah [[pekerjaan]] dalam bahasa {{{langname}}}&quot;,
	parents = {&quot;orang&quot;},
}

labels[&quot;ibu bapa&quot;] = {
	description = &quot;default&quot;,
	parents = {&quot;keluarga&quot;},
}

labels[&quot;ahli sains&quot;] = {
	type = &quot;set&quot;,
	description = &quot;Gelaran-gelaran [[ahli sains]] dalam bahasa {{{langname}}}&quot;,
	parents = {&quot;pekerjaan&quot;, &quot;sains&quot;},
}

labels[&quot;gelaran&quot;] = {
	description = &quot;[[gelaran|Gelaran-gelaran]] orang dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;orang&quot;},
}

labels[&quot;tribes&quot;] = {
	description = &quot;default&quot;,
	parents = {&quot;demonim&quot;, &quot;orang&quot;},
}

labels[&quot;William Shakespeare&quot;] = {
	description = &quot;{{{langname}}} terms related to the British author William Shakespeare or his works.&quot;,
	parents = {&quot;authors&quot;},
}

return labels</text>
      <sha1>7wb4jzot9zc177alsvu4t6565vo78zx</sha1>
    </revision>
  </page>
  <page>
    <title>Modul:category tree/topic/Time</title>
    <ns>828</ns>
    <id>12242</id>
    <revision>
      <id>342798</id>
      <parentid>335863</parentid>
      <timestamp>2026-05-16T12:23:56Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <comment>Mengemas kini mengikut padanan Wikikamus bahasa Inggeris (semakan [[en:Special:Diff/87310303|87310303]])</comment>
      <origin>342798</origin>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="8898" sha1="7ij6f42a3r2y3g5jtbihtc8s4v93vyn" xml:space="preserve">local labels = {}

labels[&quot;masa&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;semua topik&quot;},
}

labels[&quot;bulan takwim Anglo-Saxon&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the months of the {{w|Anglo-Saxon calendar}}.&quot;,
	parents = {&quot;bulan dalam tahun&quot;, &quot;bulan qamari&quot;},
}

labels[&quot;bulan takwim Armenia&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the months of the {{w|Armenian calendar}}.&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;takwim&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default with the&quot;,
	parents = {&quot;penjagaan masa&quot;},
}

labels[&quot;abad&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default&quot;,
	parents = {&quot;takwim&quot;},
}

labels[&quot;bulan takwim Benggala&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the months of the {{w|Bengali calendar}}.&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;tanda zodiak Burma&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the signs of the {{w|Burmese zodiac}}.&quot;,
	parents = {&quot;astrologi&quot;, &quot;takwim&quot;},
}

labels[&quot;cabang bumi Cina&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;=[[Chinese]] [[earthly branch]]es&quot;,
	parents = {&quot;istilah kitaran seksagenari Cina&quot;},
}

labels[&quot;batang langit Cina&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;=[[Chinese]] [[heavenly stem]]s&quot;,
	parents = {&quot;istilah kitaran seksagenari Cina&quot;},
}

labels[&quot;bulan Cina&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;istilah kitaran seksagenari Cina&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;=[[Chinese]] {{w|sexagenary cycle}} [[term]]s&quot;,
	parents = {&quot;takwim&quot;},
}

labels[&quot;tanda zodiak Cina&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default wikify&quot;,
	parents = {&quot;astrologi&quot;, &quot;takwim&quot;, &quot;mitologi Cina&quot;},
}

labels[&quot;Krismas&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default no singularize&quot;,
	parents = {&quot;cuti&quot;, &quot;Kristian&quot;},
}

labels[&quot;hari takwim Hindu&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the [[day]]s of the {{w|Hindu calendar}}.&quot;,
	parents = {&quot;kejadian berkala&quot;, &quot;Hinduisme&quot;},
}

labels[&quot;hari dalam minggu&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;=the [[Appendix:Days of the week|days of the week]]&quot;,
	parents = {&quot;kejadian berkala&quot;},
}

labels[&quot;dekad&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default&quot;,
	parents = {&quot;takwim&quot;},
}

labels[&quot;Paskah&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;cuti&quot;, &quot;Kristian&quot;},
}

labels[&quot;bulan takwim Mesir&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the months of the ancient {{w|Egyptian calendar}}.&quot;,
	parents = {&quot;Mesir Purba&quot;, &quot;bulan dalam tahun&quot;},
}

labels[&quot;festival&quot;] = {
	type = &quot;nama,jenis&quot;,
	description = &quot;default&quot;,
	parents = {&quot;perayaan&quot;},
}

labels[&quot;bulan takwim Gregory&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;Halloween&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;cuti&quot;},
}

labels[&quot;Hanukkah&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default no singularize&quot;,
	parents = {&quot;cuti&quot;, &quot;Yudaisme&quot;},
}

labels[&quot;bulan takwim Ibrani&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the months of the {{w|Hebrew calendar}}.&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;tahun Jovian Hindu&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for years in the cycle of [[Jovian year]]s in traditional calendars of [[Hinduism]].&quot;,
	additional = &quot;These are based on the movement of the planet Jupiter rather than that of the sun.&quot;,
	parents = {&quot;takwim&quot;, &quot;Hinduisme&quot;},
}

labels[&quot;bulan takwim qamari Hindu&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the months of the {{w|Hindu calendar|Hindu lunar calendar}}.&quot;,
	parents = {&quot;bulan dalam tahun&quot;, &quot;Hinduisme&quot;},
}

labels[&quot;bulan takwim suria Hindu&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the months of the {{w|Hindu calendar|Hindu solar calendar}}.&quot;,
	parents = {&quot;bulan dalam tahun&quot;, &quot;Hinduisme&quot;},
}

labels[&quot;cuti&quot;] = {
	type = &quot;nama,jenis&quot;,
	description = &quot;default&quot;,
	parents = {&quot;perayaan&quot;},
}

labels[&quot;bulan takwim Iceland&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the months of the {{w|Icelandic calendar}}.&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;bulan takwim Hijrah&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default&quot;,
	parents = {&quot;bulan dalam tahun&quot;, &quot;Islam&quot;},
}

labels[&quot;bulan takwim Jepun&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the months of the {{w|Japanese calendar}}.&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;bulan takwim Jawa&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the months of the {{w|Javanese calendar}}.&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;bulan Kojoda&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the months of the {{w|Yoruba calendar}}.&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;bulan qamari&quot;] = {
	type = &quot;set&quot;,
	description = &quot;default&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;tanda hari Mesoamerika&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default&quot;,
	parents = {&quot;simbol&quot;, &quot;takwim&quot;},
	wp = &quot;Aztec calendar&quot;,
}

labels[&quot;bulan dalam tahun&quot;] = {
	type = &quot;set&quot;,
	preceding = &quot;{{also|Appendix:Months of the year}}&quot;,
	description = &quot;{{{langname}}} names of the [[month]]s of the [[year]].&quot;,
	parents = {&quot;kejadian berkala&quot;},
	wpcat = true,
	commonscat = true,
}

labels[&quot;bulan takwim Nanakshahi&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the months of the {{w|Nanakshahi calendar}}.&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;bulan takwim Norse&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;perayaan&quot;] = {
	type = &quot;set&quot;,
	description = &quot;default&quot;,
	parents = {&quot;takwim&quot;},
}

labels[&quot;kejadian berkala&quot;] = {
	type = &quot;set&quot;,
	description = &quot;=occurrences that repeat at certain intervals of time&quot;,
	parents = {&quot;masa&quot;},
}

labels[&quot;bulan Parsi&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;Ramadan&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;perayaan&quot;, &quot;Islam&quot;, &quot;bulan takwim Hijrah&quot;},
}

labels[&quot;musim&quot;] = {
	type = &quot;set&quot;,
	description = &quot;default&quot;,
	parents = {&quot;kejadian berkala&quot;, &quot;alam semula jadi&quot;},
}

labels[&quot;Sinterklaas&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default no singularize&quot;,
	parents = {&quot;cuti&quot;, &quot;tokoh mitologi&quot;},
}

labels[&quot;istilah suria Cina&quot;] = {
	type = &quot;set&quot;,
	description = &quot;default&quot;,
	parents = {&quot;takwim&quot;, &quot;Matahari&quot;},
}

labels[&quot;Tahun Baru&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;=the [[Gregorian]] [[New Year]]&quot;,
	parents = {&quot;cuti&quot;},
}

labels[&quot;bulan Kristian Syria&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;bulan takwim Tamil&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the months of the {{w|Tamil calendar}}.&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;zon masa&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default&quot;,
	parents = {&quot;penjagaan masa&quot;},
}

labels[&quot;Hari Kesyukuran&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;cuti&quot;},
}

labels[&quot;penjagaan masa&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;masa&quot;},
}

labels[&quot;waktu dalam sehari&quot;] = {
	type = &quot;set&quot;,
	description = &quot;=[[time]]s of the [[day]]&quot;,
	parents = {&quot;kejadian berkala&quot;, &quot;penjagaan masa&quot;},
}

labels[&quot;hari&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;=the [[day]] ([[etymologically]] or [[semantically]])&quot;,
	additional = &quot;'''NOTE''': Do not include days of the week within this category. These should be in [[:Category:{{{langcode}}}:Days of the week]].&quot;,
	parents = {&quot;masa&quot;},
}

labels[&quot;malam&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;=the [[night]] ([[etymologically]] or [[semantically]])&quot;,
	parents = {&quot;masa&quot;, &quot;kegelapan&quot;},
}

labels[&quot;tahun&quot;] = {
	type = &quot;jenis&quot;,
	description = &quot;default&quot;,
	parents = {&quot;kejadian berkala&quot;},
}

labels[&quot;masa lampau&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;{{{langname}}} terms for the [[past]], or for events in the [[past]].&quot;,
	additional = &quot;NOTE: Do NOT include words that are exclusively verbs, or words related to the field of history or historiography, within this category.&quot;,
	parents = {&quot;masa&quot;},
}

labels[&quot;masa kini&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;{{{langname}}} terms for the [[present]], or for events in the [[present]].&quot;,
	additional = &quot;NOTE: Do NOT include words that are exclusively verbs, or words related to the field of history or historiography, within this category.&quot;,
	parents = {&quot;masa&quot;},
}

labels[&quot;masa depan&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;{{{langname}}} terms for the [[future]], or for events in the [[future]].&quot;,
	additional = &quot;NOTE: Do NOT include words that are exclusively verbs, or words related to the field of history or historiography, within this category.&quot;,
	parents = {&quot;masa&quot;},
}

labels[&quot;pengembaraan masa&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;masa&quot;, &quot;fiksyen sains&quot;, &quot;pengembaraan&quot;, &quot;kerelatifan&quot;},
}

return labels</text>
      <sha1>7ij6f42a3r2y3g5jtbihtc8s4v93vyn</sha1>
    </revision>
    <revision>
      <id>342799</id>
      <parentid>342798</parentid>
      <timestamp>2026-05-16T12:27:48Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <origin>342799</origin>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="8904" sha1="7br6sihki71gk6akid7qrd0m8weil6f" xml:space="preserve">local labels = {}

labels[&quot;masa&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;semua topik&quot;},
}

labels[&quot;bulan takwim Anglo-Saxon&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the months of the {{w|Anglo-Saxon calendar}}.&quot;,
	parents = {&quot;bulan dalam tahun&quot;, &quot;bulan qamari&quot;},
}

labels[&quot;bulan takwim Armenia&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the months of the {{w|Armenian calendar}}.&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;takwim&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default with the&quot;,
	parents = {&quot;penjagaan masa&quot;},
}

labels[&quot;abad&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default&quot;,
	parents = {&quot;takwim&quot;},
}

labels[&quot;bulan takwim Benggala&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the months of the {{w|Bengali calendar}}.&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;tanda zodiak Burma&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the signs of the {{w|Burmese zodiac}}.&quot;,
	parents = {&quot;astrologi&quot;, &quot;takwim&quot;},
}

labels[&quot;cabang bumi Cina&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;=[[Chinese]] [[earthly branch]]es&quot;,
	parents = {&quot;istilah kitaran seksagenari Cina&quot;},
}

labels[&quot;batang langit Cina&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;=[[Chinese]] [[heavenly stem]]s&quot;,
	parents = {&quot;istilah kitaran seksagenari Cina&quot;},
}

labels[&quot;bulan Cina&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;istilah kitaran seksagenari Cina&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;=[[Chinese]] {{w|sexagenary cycle}} [[term]]s&quot;,
	parents = {&quot;takwim&quot;},
}

labels[&quot;tanda zodiak Cina&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default wikify&quot;,
	parents = {&quot;astrologi&quot;, &quot;takwim&quot;, &quot;mitologi Cina&quot;},
}

labels[&quot;Krismas&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default no singularize&quot;,
	parents = {&quot;cuti&quot;, &quot;Kristian&quot;},
}

labels[&quot;hari takwim Hindu&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the [[day]]s of the {{w|Hindu calendar}}.&quot;,
	parents = {&quot;kejadian berkala&quot;, &quot;Hinduisme&quot;},
}

labels[&quot;hari dalam minggu&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;=the [[Appendix:Days of the week|days of the week]]&quot;,
	parents = {&quot;kejadian berkala&quot;},
}

labels[&quot;dekad&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default&quot;,
	parents = {&quot;takwim&quot;},
}

labels[&quot;Paskah&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;cuti&quot;, &quot;Kristian&quot;},
}

labels[&quot;bulan takwim Mesir&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the months of the ancient {{w|Egyptian calendar}}.&quot;,
	parents = {&quot;Mesir Purba&quot;, &quot;bulan dalam tahun&quot;},
}

labels[&quot;festival&quot;] = {
	type = &quot;nama,jenis&quot;,
	description = &quot;default&quot;,
	parents = {&quot;perayaan&quot;},
}

labels[&quot;bulan takwim Masihi&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;Halloween&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;cuti&quot;},
}

labels[&quot;Hanukkah&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default no singularize&quot;,
	parents = {&quot;cuti&quot;, &quot;Yudaisme&quot;},
}

labels[&quot;bulan takwim Ibrani&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the months of the {{w|Hebrew calendar}}.&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;tahun Jovian Hindu&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for years in the cycle of [[Jovian year]]s in traditional calendars of [[Hinduism]].&quot;,
	additional = &quot;These are based on the movement of the planet Jupiter rather than that of the sun.&quot;,
	parents = {&quot;takwim&quot;, &quot;Hinduisme&quot;},
}

labels[&quot;bulan takwim qamari Hindu&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the months of the {{w|Hindu calendar|Hindu lunar calendar}}.&quot;,
	parents = {&quot;bulan dalam tahun&quot;, &quot;Hinduisme&quot;},
}

labels[&quot;bulan takwim suria Hindu&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the months of the {{w|Hindu calendar|Hindu solar calendar}}.&quot;,
	parents = {&quot;bulan dalam tahun&quot;, &quot;Hinduisme&quot;},
}

labels[&quot;cuti&quot;] = {
	type = &quot;nama,jenis&quot;,
	description = &quot;default&quot;,
	parents = {&quot;perayaan&quot;},
}

labels[&quot;bulan takwim Iceland&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the months of the {{w|Icelandic calendar}}.&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;bulan takwim Hijrah&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default&quot;,
	parents = {&quot;bulan dalam tahun&quot;, &quot;Islam&quot;},
}

labels[&quot;bulan takwim Jepun&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the months of the {{w|Japanese calendar}}.&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;bulan takwim Jawa&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the months of the {{w|Javanese calendar}}.&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;bulan Kojoda&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the months of the {{w|Yoruba calendar}}.&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;bulan qamari&quot;] = {
	type = &quot;set&quot;,
	description = &quot;default&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;tanda hari Mesoamerika&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default&quot;,
	parents = {&quot;simbol&quot;, &quot;takwim&quot;},
	wp = &quot;Aztec calendar&quot;,
}

labels[&quot;bulan dalam tahun&quot;] = {
	type = &quot;set&quot;,
	preceding = &quot;{{also|Appendix:Months of the year}}&quot;,
	description = &quot;{{{langname}}} names of the [[month]]s of the [[year]].&quot;,
	parents = {&quot;kejadian berkala&quot;},
	wpcat = true,
	commonscat = true,
}

labels[&quot;bulan takwim Nanakshahi&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the months of the {{w|Nanakshahi calendar}}.&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;bulan takwim Norse&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;perayaan&quot;] = {
	type = &quot;set&quot;,
	description = &quot;default&quot;,
	parents = {&quot;takwim&quot;},
}

labels[&quot;kejadian berkala&quot;] = {
	type = &quot;set&quot;,
	description = &quot;=occurrences that repeat at certain intervals of time&quot;,
	parents = {&quot;masa&quot;},
}

labels[&quot;bulan Parsi&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;Ramadan&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;perayaan&quot;, &quot;Islam&quot;, &quot;bulan takwim Hijrah&quot;},
}

labels[&quot;musim&quot;] = {
	type = &quot;set&quot;,
	description = &quot;default&quot;,
	parents = {&quot;kejadian berkala&quot;, &quot;alam semula jadi&quot;},
}

labels[&quot;Sinterklaas&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default no singularize&quot;,
	parents = {&quot;cuti&quot;, &quot;tokoh mitologi&quot;},
}

labels[&quot;istilah suria Cina&quot;] = {
	type = &quot;set&quot;,
	description = &quot;default&quot;,
	parents = {&quot;takwim&quot;, &quot;Matahari&quot;},
}

labels[&quot;Tahun Baru Masihi&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;=the [[Gregorian]] [[New Year]]&quot;,
	parents = {&quot;cuti&quot;},
}

labels[&quot;bulan Kristian Syria&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;bulan takwim Tamil&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;{{{langname}}} names for the months of the {{w|Tamil calendar}}.&quot;,
	parents = {&quot;bulan dalam tahun&quot;},
}

labels[&quot;zon masa&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default&quot;,
	parents = {&quot;penjagaan masa&quot;},
}

labels[&quot;Hari Kesyukuran&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;cuti&quot;},
}

labels[&quot;penjagaan masa&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;masa&quot;},
}

labels[&quot;waktu dalam sehari&quot;] = {
	type = &quot;set&quot;,
	description = &quot;=[[time]]s of the [[day]]&quot;,
	parents = {&quot;kejadian berkala&quot;, &quot;penjagaan masa&quot;},
}

labels[&quot;hari&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;=the [[day]] ([[etymologically]] or [[semantically]])&quot;,
	additional = &quot;'''NOTE''': Do not include days of the week within this category. These should be in [[:Category:{{{langcode}}}:Days of the week]].&quot;,
	parents = {&quot;masa&quot;},
}

labels[&quot;malam&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;=the [[night]] ([[etymologically]] or [[semantically]])&quot;,
	parents = {&quot;masa&quot;, &quot;kegelapan&quot;},
}

labels[&quot;tahun&quot;] = {
	type = &quot;jenis&quot;,
	description = &quot;default&quot;,
	parents = {&quot;kejadian berkala&quot;},
}

labels[&quot;masa lampau&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;{{{langname}}} terms for the [[past]], or for events in the [[past]].&quot;,
	additional = &quot;NOTE: Do NOT include words that are exclusively verbs, or words related to the field of history or historiography, within this category.&quot;,
	parents = {&quot;masa&quot;},
}

labels[&quot;masa kini&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;{{{langname}}} terms for the [[present]], or for events in the [[present]].&quot;,
	additional = &quot;NOTE: Do NOT include words that are exclusively verbs, or words related to the field of history or historiography, within this category.&quot;,
	parents = {&quot;masa&quot;},
}

labels[&quot;masa depan&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;{{{langname}}} terms for the [[future]], or for events in the [[future]].&quot;,
	additional = &quot;NOTE: Do NOT include words that are exclusively verbs, or words related to the field of history or historiography, within this category.&quot;,
	parents = {&quot;masa&quot;},
}

labels[&quot;pengembaraan masa&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;masa&quot;, &quot;fiksyen sains&quot;, &quot;pengembaraan&quot;, &quot;kerelatifan&quot;},
}

return labels</text>
      <sha1>7br6sihki71gk6akid7qrd0m8weil6f</sha1>
    </revision>
  </page>
  <page>
    <title>معجون أسنان</title>
    <ns>0</ns>
    <id>16203</id>
    <revision>
      <id>342862</id>
      <parentid>323387</parentid>
      <timestamp>2026-05-17T08:48:04Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <minor />
      <origin>342862</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="432" sha1="osb46y5sveu8wsv6irrksmq89f79a5o" xml:space="preserve">==Bahasa Arab==

===Kata nama===
{{ar-kn|مَعْجُون أَسْنان|m}}

# [[ubat gigi]]

===Etimologi===
{{af|ar|مَعْجُون|أَسْنان}}.

===Sebutan===
* {{ar-AFA|مَعْجُون أَسْنان}}

===Deklensi===
{{ar-dekl-kn|مَعْجُون|mod=أَسْنان|idafa=yes}}

===Rujukan===
* {{R:ar:Freytag}}
* {{R:ar:Baranov}}
* {{R:ar:Lane}}
* {{R:ar:Wehr-3}}

{{topik|ar|Kesihatan gigi|Kelengkapan dandanan diri}}</text>
      <sha1>osb46y5sveu8wsv6irrksmq89f79a5o</sha1>
    </revision>
  </page>
  <page>
    <title>toothpaste</title>
    <ns>0</ns>
    <id>16204</id>
    <revision>
      <id>342863</id>
      <parentid>332318</parentid>
      <timestamp>2026-05-17T08:48:48Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <origin>342863</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="707" sha1="pmuuokerxavj4yn6prm6i28q75ny0u0" xml:space="preserve">==Bahasa Inggeris==
{{wikipedia|lang=en}}

===Kata nama===
{{en-kn|~}}

# [[ubat gigi]].

===Etimologi===
Daripada {{compound|en|tooth|paste|t1=gigi|t2=pes}}. Banding {{cog|stq|Tuskepasta||ubat gigi}}, {{cog|fy|toskpoetserguod||ubat gigi}}, {{cog|nl|tandpasta||ubat gigi}}, {{cog|de|Zahnpasta}}, {{m|de|Zahnpaste||ubat gigi}}, {{cog|da|tandpasta||ubat gigi}}, {{cog|sv|tandpasta||ubat gigi}}, {{cog|is|tannkrem||ubat gigi}}.

===Sebutan===
* {{a|RP}} {{AFA|en|/ˈtuːθpeɪst/}}

===Terbitan===
* {{l|en|toothpaste is out of the tube}}
* {{l|en|toothpastey}}
* {{l|en|toothpasty}}

[[Kategori:Kata majmuk endosentrik bahasa Inggeris]]
[[Kategori:en:Kesihatan gigi]]
[[Kategori:en:Kelengkapan dandanan diri]]</text>
      <sha1>pmuuokerxavj4yn6prm6i28q75ny0u0</sha1>
    </revision>
  </page>
  <page>
    <title>牙膏</title>
    <ns>0</ns>
    <id>16205</id>
    <revision>
      <id>342855</id>
      <parentid>323742</parentid>
      <timestamp>2026-05-17T08:42:24Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <origin>342855</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="457" sha1="60ihgvrl65akctr0jzqomgsqdpuecl9" xml:space="preserve">==Bahasa Cina==
{{zh-forms}}

===Kata nama===
{{zh-kn}}

# [[ubat gigi]] {{zh-mw|m:管|c:枝}}
#: {{zh-x|擳 牙膏|memicit '''ubat gigi'''|C}}

===Sebutan===
{{zh-pron
|m=yágāo,er=y
|c=ngaa4 gou1
|g=nga4 gau1
|h=pfs=ngà-kâu;gd=nga2 gau1
|md=ngāi-gŏ̤
|mn=gê-ko
|mn-t=ghê5 go1
|w=3nga kau
|ma=Zh-yágao.ogg
|cat=n
}}

===Tesaurus===
====Sinonim====
{{zh-dial}}

===Lihat juga===
* {{zh-l|牙刷}}

{{zh-cat|Kesihatan gigi|Kelengkapan dandanan diri}}</text>
      <sha1>60ihgvrl65akctr0jzqomgsqdpuecl9</sha1>
    </revision>
  </page>
  <page>
    <title>Modul:category tree/topic/Islam</title>
    <ns>828</ns>
    <id>22341</id>
    <revision>
      <id>342832</id>
      <parentid>335862</parentid>
      <timestamp>2026-05-16T14:04:44Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <comment>Membuang label &quot;Ramadan&quot; kerana sudah ditakrifkan di [[Modul:category tree/topic/Time]]</comment>
      <origin>342832</origin>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="4882" sha1="8bq8rktdntsxjdjuf0aj2nry7fbqek3" xml:space="preserve">local labels = {}

labels[&quot;Islam&quot;] = {
	type = &quot;set&quot;,
	description = &quot;Istilah berkenaan agama dan masyarakat [[Islam]] dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;agama&quot;},
	wpcat = true,
}

-- Darjat pertama

labels[&quot;Allah&quot;] = {
	description = &quot;Istilah berkaitan [[Allah]] dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;Islam&quot;, &quot;tuhan&quot;},
}

labels[&quot;makhluk dalam Islam&quot;] = {
	description = &quot;Istilah berkenaan makhluk-makhluk dalam agama [[Islam]] dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;Islam&quot;},
}

labels[&quot;pengajian Islam&quot;] = {
	description = &quot;Istilah berkenaan ilmu dan pengajian [[Islam]] dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;Islam&quot;, &quot;teologi&quot;},
}

labels[&quot;ibadat Islam&quot;] = {
	description = &quot;Istilah berkenaan ibadat dalam agama [[Islam]] dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;Islam&quot;, &quot;sembahyang&quot;},
}

labels[&quot;akhirat&quot;] = {
	description = &quot;Istilah berkenaan [[Islam]] dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;Islam&quot;, &quot;alam selepas mati&quot;},
}

labels[&quot;Al-Quran&quot;] = {
	description = &quot;Istilah berkenaan [[Al-Quran]] dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;Islam&quot;, &quot;buku&quot;},
}

labels[&quot;hadis&quot;] = {
	description = &quot;Istilah berkenaan ilmu dan pengajian [[hadis]] dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;Islam&quot;, &quot;Muhammad&quot;},
}

labels[&quot;orang Islam&quot;] = {
	description = &quot;Istilah berkenaan orang [[Islam]] dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;Islam&quot;, &quot;orang&quot;},
}

labels[&quot;budaya Islam&quot;] = {
	description = &quot;Istilah berkenaan kebudayaan [[Islam]] dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;Islam&quot;, &quot;budaya&quot;},
}

-- Darjat kedua - Pengajian Islam

labels[&quot;akidah Islam&quot;] = {
	description = &quot;Istilah berkenaan konsep-konsep [[akidah]] Islam dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;pengajian Islam&quot;, &quot;Allah&quot;},
}

labels[&quot;fiqah&quot;] = {
	description = &quot;Istilah berkenaan konsep-konsep [[fiqh]] dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;pengajian Islam&quot;},
}

labels[&quot;usul fiqah&quot;] = {
	description = &quot;Istilah berkenaan konsep-konsep [[usul fiqh]] dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;fiqah&quot;},
}

labels[&quot;mazhab Islam&quot;] = {
	description = &quot;Istilah [[mazhab|mazhab-mazhab]] Islam dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;fiqh&quot;},
}

labels[&quot;perkahwinan Islam&quot;] = {
	description = &quot;Istilah berkenaan konsep-konsep [[perkahwinan]] dalam Islam dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;pengajian Islam&quot;},
}

labels[&quot;syariat&quot;] = {
	description = &quot;Istilah berkenaan syariah, perundangan dan jenayah [[Islam]] dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;pengajian Islam&quot;},
}

labels[&quot;kesufian&quot;] = {
	description = &quot;default&quot;,
	parents = {&quot;mistisisme&quot;, &quot;Islam&quot;},
}

-- Darjat kedua - Orang Islam


labels[&quot;Muhammad&quot;] = {
	description = &quot;Istilah berkenaan Nabi [[Muhammad]] SAW dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;orang Islam&quot;},
}

-- Darjat kedua - Ibadat dalam Islam

labels[&quot;solat&quot;] = {
	description = &quot;Istilah berkenaan [[solat]] dalam Islam dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;ibadat Islam&quot;},
}

labels[&quot;zakat&quot;] = {
	description = &quot;Istilah berkenaan konsep-konsep [[zakat]] dalam Islam dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;ibadat Islam&quot;, &quot;kewangan Islam&quot;},
}

labels[&quot;puasa Islam&quot;] = {
	description = &quot;Istilah berkenaan [[puasa]] dalam Islam dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;ibadat Islam&quot;},
}

labels[&quot;haji dan umrah&quot;] = {
	description = &quot;Istilah berkenaan ibadah [[haji]] dan [[umrah]] dalam Islam dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;ibadat Islam&quot;},
}

-- Darjat kedua - Al-Quran

labels[&quot;tajwid&quot;] = {
	description = &quot;Istilah berkenaan hukum [[tajwid]] dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;Al-Quran&quot;},
}

labels[&quot;taranum&quot;] = {
	description = &quot;Istilah-istilah ilmu [[taranum]] dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;Al-Quran&quot;},
}

labels[&quot;surah&quot;] = {
	description = &quot;Nama-nama [[surah]] Al-Quran dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;Al-Quran&quot;},
}

-- Darjat kedua - Hadis

-- Darjat kedua - Orang Islam

labels[&quot;nabi dan rasul dalam Islam&quot;] = {
	description = &quot;Nama-nama [[nabi]] dan [[rasul]] dalam Islam dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;orang Islam&quot;},
}

labels[&quot;agamawan Islam&quot;] = {
	description = &quot;Nama-nama [[agamawan]] Islam dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;orang Islam&quot;},
}

-- Darjat kedua - Budaya

labels[&quot;muzik Islam&quot;] = {
	description = &quot;Istilah berkenaan ibadat dan budaya berkenaan bulan [[Ramadan]] dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;budaya Islam&quot;, &quot;genre muzik&quot;},
}

labels[&quot;perayaan Islam&quot;] = {
	description = &quot;Istilah berkenaan hari-hari kebesaran dan perayaan [[Islam]] dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;budaya Islam&quot;},
}

labels[&quot;khat Islam&quot;] = {
	description = &quot;Istilah berkenaan seni [[khat]] [[Islam]] dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;budaya Islam&quot;, &quot;seni khat&quot;},
}

labels[&quot;Aidilfitri&quot;] = {
	description = &quot;Istilah berkenaan [[Aidilfitri]] dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;perayaan Islam&quot;},
}

return labels</text>
      <sha1>8bq8rktdntsxjdjuf0aj2nry7fbqek3</sha1>
    </revision>
  </page>
  <page>
    <title>Modul:parameters/data</title>
    <ns>828</ns>
    <id>33722</id>
    <revision>
      <id>342815</id>
      <parentid>223595</parentid>
      <timestamp>2026-05-16T12:44:12Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <comment>Mengemas kini mengikut padanan Wikikamus bahasa Inggeris (semakan [[en:Special:Diff/88995850|88995850]])</comment>
      <origin>342815</origin>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="2986" sha1="9kmrm2euhzpw7kuwy17wu4tc0r8r4yg" xml:space="preserve">local list_to_set = require(&quot;Module:table&quot;).listToSet

local alias_of_2 = {alias_of = 2}
local boolean = {type = &quot;boolean&quot;}
local empty_list = {}
local list = {list = true}
local list_allow_holes_separate_no_index = {list = true, allow_holes = true, separate_no_index = true}
local required = {required = true}
local required_default_ = {required = true, default = &quot;&quot;}
local required_lang_default_und = {required = true, type = &quot;language&quot;, default = &quot;und&quot;}
local type_labels = {type = &quot;labels&quot;}
local type_qualifier = {type = &quot;qualifier&quot;}
local type_references = {type = &quot;references&quot;}

local m = {}

-- [[Module:anchors]]

m[&quot;anchor&quot;] = {
	[1] = {required = true, list = true, disallow_holes = true},
}
	
m[&quot;senseid&quot;] = {
	[1] = required_lang_default_und,
	[2] = required_default_,
	id = alias_of_2,
	tag = {set = list_to_set{&quot;li&quot;, &quot;p&quot;}, default = &quot;li&quot;},
}
	
m[&quot;etymid&quot;] = {
	[1] = required_lang_default_und,
	[2] = required_default_,
	id = alias_of_2,
}

-- [[Module:etymon]]
	
m[&quot;etymon&quot;] = {
	[1] = required_lang_default_und,
	[2] = {list = true, disallow_holes = true},
	id = true,
	title = true,
	tree = boolean,
	text = true,
    exnihilo = boolean,
    etydate = true,
    rfe = true,
    pos = true,
    notree = {default = false, type = &quot;boolean&quot;},
    nocat = {default = false, type = &quot;boolean&quot;},
    nodot = {default = false, type = &quot;boolean&quot;},
    json = {default = false, type = &quot;boolean&quot;},
}

-- [[Module:transclude]]

m[&quot;transclude&quot;] = {
	[1] = {required = true, type = &quot;language&quot;},
	[2] = {list = true, required = true},
	id = true,
	sort = true,
	nogloss = {default = false, type = &quot;boolean&quot;},
	no_truncate_gloss = boolean,
	include_place_extra_info = boolean,
	place_translation_follows = boolean,
	place_addl = true,
	lb = true,
	nolb = true,
	nocat = boolean,
	to = boolean,
	t = list,
	indent = true,
	dot = boolean,
	pagename = true,
}

-- [[Module:translations]]

m[&quot;translation&quot;] = {
	[1] = required_lang_default_und,
	[2] = true,
	[3] = list,
	alt = true,
	id = true,
	sc = {type = &quot;script&quot;},
	tr = true,
	ts = true,
	lit = true,
	l = type_labels,
	ll = type_labels,
	q = type_qualifier,
	qq = type_qualifier,
	ref = type_references,
}

m[&quot;t-needed&quot;] = {
	[1] = required_lang_default_und,
	[2] = {set = list_to_set{&quot;usex&quot;, &quot;quote&quot;}},
	nocat = boolean,
	sort = true,
}

m[&quot;ter-atas&quot;] = {
	[1] = true,
	id = true,
	[&quot;column-width&quot;] = true,
}

m[&quot;ter-atas-juga&quot;] = {
	[1] = required,
	[2] = list,
	id = list_allow_holes_separate_no_index,
	[&quot;column-width&quot;] = true,
}

m[&quot;checktrans-top&quot;] = {
	[1] = true,
	[&quot;column-width&quot;] = true,
}

m[&quot;ter-bawah&quot;] = empty_list

m[&quot;ter-lihat&quot;] = {
	[1] = required,
	[2] = list,
	id = list_allow_holes_separate_no_index,
}

m[&quot;translation subpage&quot;] = empty_list

m[&quot;no equivalent translation&quot;] = {
	[1] = required_lang_default_und,
	noend = boolean,
}

m[&quot;no attested translation&quot;] = {
	[1] = required_lang_default_und,
	noend = boolean,
	sort = true,
}

m[&quot;not used&quot;] = {
	[1] = required_lang_default_und,
	[2] = true,
}

return m</text>
      <sha1>9kmrm2euhzpw7kuwy17wu4tc0r8r4yg</sha1>
    </revision>
  </page>
  <page>
    <title>Modul:anchors</title>
    <ns>828</ns>
    <id>57712</id>
    <revision>
      <id>342828</id>
      <parentid>234446</parentid>
      <timestamp>2026-05-16T13:56:39Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <comment>Mengemas kini mengikut padanan Wikikamus bahasa Inggeris (semakan [[en:Special:Diff/90373122|90373122]])</comment>
      <origin>342828</origin>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="2558" sha1="2o0jqln8y0bxvpfhe66eogs2k88qkap" xml:space="preserve">local export = {}

local string_utilities_module = &quot;Module:string utilities&quot;

local anchor_encode = mw.uri.anchorEncode
local concat = table.concat
local insert = table.insert
local language_anchor -- Defined below.

local function decode_entities(...)
	decode_entities = require(string_utilities_module).decode_entities
	return decode_entities(...)
end

local function encode_entities(...)
	encode_entities = require(string_utilities_module).encode_entities
	return encode_entities(...)
end

-- Returns the anchor text to be used as the fragment of a link to a language section.
function export.language_anchor(lang, id)
	return anchor_encode(lang:getFullName() .. &quot;: &quot; .. id)
end
language_anchor = export.language_anchor

-- Normalizes input text (removes formatting etc.), which can then be used as an anchor in an `id=` field.
function export.normalize_anchor(str)
	return decode_entities(anchor_encode(str))
end

function export.make_anchors(ids)
	local anchors = {}
	for i = 1, #ids do
		local id = ids[i]
		local el = mw.html.create(&quot;span&quot;)
			:addClass(&quot;template-anchor&quot;)
			:attr(&quot;id&quot;, anchor_encode(id))
			:attr(&quot;data-id&quot;, id)
		insert(anchors, tostring(el))
	end
	return concat(anchors)
end

function export.senseid(lang, id, tag_name)
	-- The following tag is opened but never closed, where is it supposed to be closed?
	--         with &lt;li&gt; it doesn't matter, as it is closed automatically.
	--         with &lt;p&gt; it is a problem
	-- Cannot use mw.html here as it always closes tags
	return &quot;&lt;&quot; .. tag_name .. &quot; class=\&quot;senseid\&quot; id=\&quot;&quot; .. language_anchor(lang, id) .. &quot;\&quot; data-lang=\&quot;&quot; .. lang:getCode() .. &quot;\&quot; data-id=\&quot;&quot; .. encode_entities(id) .. &quot;\&quot;&gt;&quot;
end

function export.etymid(lang, id)
	-- Use a &lt;ul&gt; tag to ensure spacing doesn't get messed up.
	local el = mw.html.create(&quot;ul&quot;)
		:addClass(&quot;etymid&quot;)
		:attr(&quot;id&quot;, language_anchor(lang, id))
		:attr(&quot;data-lang&quot;, lang:getCode())
		:attr(&quot;data-id&quot;, id)
	return tostring(el)
end

function export.etymonid(lang, id, opts)
	opts = opts or {}
	-- Use a &lt;ul&gt; tag to ensure spacing doesn't get messed up.
	local el = mw.html.create(&quot;ul&quot;)
		:addClass(&quot;etymonid&quot;)
		:attr(&quot;data-lang&quot;, lang:getCode())
	
	if id then
		el:attr(&quot;id&quot;, language_anchor(lang, id))
		el:attr(&quot;data-id&quot;, id)
	end
	if opts.no_tree then
		el:attr(&quot;data-no-tree&quot;, &quot;1&quot;)
	end
	if opts.title then
		el:attr(&quot;data-title&quot;, opts.title)
	end
	if opts.empty_tree then
		el:attr(&quot;data-empty-tree&quot;, &quot;1&quot;)
	end
	if opts.ety_tree_json then
		el:attr(&quot;data-ety-tree-json&quot;, opts.ety_tree_json)
	end
	
	return tostring(el)
end

return export</text>
      <sha1>2o0jqln8y0bxvpfhe66eogs2k88qkap</sha1>
    </revision>
  </page>
  <page>
    <title>Modul:etymon</title>
    <ns>828</ns>
    <id>57903</id>
    <revision>
      <id>342816</id>
      <parentid>264877</parentid>
      <timestamp>2026-05-16T13:37:50Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <comment>Mengemas kini mengikut padanan Wikikamus bahasa Inggeris (semakan [[en:Special:Diff/90788814|90788814]]), terjemahan belum selesai</comment>
      <origin>342816</origin>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="61568" sha1="sd824iy93rvmo3oroit742p1i4oi4gt" xml:space="preserve">--[=[

This module implements the {{etymon}} template for structured etymology data on Wiktionary.
It enables the creation of etymology trees and text by parsing etymon chains,
scraping linked pages for their own {{etymon}} data, and recursively building a tree
of derivational relationships.

Authors:
- Original implementation: [[User:Ioaxxere]]
- Full refactor (September 2025): [[User:Fenakhay]] ([[Special:Diff/86717746]])

Modules:
- [[Module:etymon]]: main module handling parsing, validation, tree building, and page scraping
- [[Module:etymon/data]]: keyword definitions, configuration, and status constants
- [[Module:etymon/tree]]: etymology tree rendering
- [[Module:etymon/text]]: etymology text generation
- [[Module:etymon/categories]]: category generation logic

]=]

local export = {}

local etymon_data_module = &quot;Module:etymon/data&quot;
local etymon_text_module = &quot;Module:etymon/text&quot;
local etymon_tree_module = &quot;Module:etymon/tree&quot;
local etymon_categories_module = &quot;Module:etymon/categories&quot;
local etymon_descendants_module = &quot;Module:etymon/descendants&quot;

local __state = {
	cached_etymon_args = {},
	cached_etymon_pages = {},
	cached_descendants_checks = {},
	senseid_parent_etymon = {},
	available_etymon_ids = {},
	single_etymons = {},
	entry_title = nil,
	entry_lang_code = nil,
	current_page_has_inline_etymology = false,
	current_page_has_redundant_etymology = false,
	used_idless_etymon = false,
	toplevel_has_inline_etymology = false,
	toplevel_redundant_etymology = false,
	toplevel_idless_etymon = false,
	has_mismatched_id = false,
	linked_page_multiple_etymons_idless = false,
	max_depth_reached = 0,
	total_nodes = 0,
	language_count = {},
	toplevel_keyword_stats = {},
	warnings = {},
}

local loader = require(&quot;Module:module loader&quot;)

local M = loader.init({
	require = {
		data = etymon_data_module,
		tree = etymon_tree_module,
		text = etymon_text_module,
		categories = etymon_categories_module,
		descendants = etymon_descendants_module,

		anchors = &quot;Module:anchors&quot;,
		etydate = &quot;Module:etydate&quot;,
		etymology = &quot;Module:etymology&quot;,
		families = &quot;Module:families&quot;,
		languages = &quot;Module:languages&quot;,
		languages_errorgetby = &quot;Module:languages/errorGetBy&quot;,
		links = &quot;Module:links&quot;,
		pages = &quot;Module:pages&quot;,
		parameters = &quot;Module:parameters&quot;,
		string_utilities = &quot;Module:string utilities&quot;,
		template_parser = &quot;Module:template parser&quot;,
		utilities = &quot;Module:utilities&quot;,
		debug = &quot;Module:debug&quot;,
		en_utilities = &quot;Module:en-utilities&quot;,
		parse_utilities = &quot;Module:parse utilities&quot;,
		references = &quot;Module:references&quot;,
		track = &quot;Module:debug/track&quot;,
		template_styles = &quot;Module:TemplateStyles&quot;,
		script_utilities = &quot;Module:script utilities&quot;,
		JSON = &quot;Module:JSON&quot;,
		yesno = &quot;Module:yesno&quot;,
	},
	loadData = {
		headword_data = &quot;Module:headword/data&quot;,
		parameters_data = &quot;Module:parameters/data&quot;,
		text_allowed = &quot;Module:etymon/data/text_allowed&quot;,
	},
})

local Util = {}

function Util.format_error(message, preview_only)
	if preview_only and not M.pages.is_preview() then
		return nil
	end
	return '&lt;span class=&quot;error&quot;&gt;' .. message .. '&lt;/span&gt;'
end

function Util.add_warning(message, preview_only)
	local formatted = Util.format_error(message, preview_only)
	if formatted then
		table.insert(__state.warnings, formatted)
	end
end

function Util.is_text_param_allowed_for_lang(lang)
	if not lang or type(lang) ~= &quot;table&quot; then
		return false
	end
	local types = lang.getTypes and lang:getTypes()
	if types and types.family then
		local code = lang.getCode and lang:getCode()
		return code and M.text_allowed.families[code] == true
	end
	local full_code = lang.getFullCode and lang:getFullCode()
	if full_code and M.text_allowed.langs[full_code] then
		return true
	end
	if lang.inFamily then
		for family_code in pairs(M.text_allowed.families) do
			if lang:inFamily(family_code) then
				return true
			end
		end
	end
	return false
end

function Util.get_lang(code, no_error)
	if no_error then
		return M.languages.getByCode(code, nil, true)
	end
	return M.languages.getByCode(code, nil, true) or M.languages_errorgetby.code(code, true, true)
end

function Util.get_family(code)
	return M.families.getByCode(code)
end

function Util.get_lang_exception(lang)
	-- Families have no language-specific exceptions
	if lang.getTypes and lang:getTypes().family then
		return nil
	end
	local code = lang:getCode()
	local lang_exceptions = M.data.config.lang_exceptions

	if lang_exceptions[code] then
		return lang_exceptions[code]
	end

	for norm_code, exc in pairs(lang_exceptions) do
		if exc.normalize_to and code == exc.normalize_to then
			return exc
		end
		if exc.normalize_from_families then
			local should_normalize = false
			for _, family in ipairs(exc.normalize_from_families) do
				if lang:inFamily(family) then
					should_normalize = true
					break
				end
			end

			if should_normalize and exc.normalize_exclude_families then
				for _, family in ipairs(exc.normalize_exclude_families) do
					if lang:inFamily(family) then
						should_normalize = false
						break
					end
				end
			end

			if should_normalize then
				local ret = {}
				for k, v in pairs(exc) do
					ret[k] = v
				end
				ret.suppress_tr = nil
				return ret
			end
		end
	end

	return nil
end

function Util.get_norm_lang(lang)
	local exc = Util.get_lang_exception(lang)
	if exc and exc.normalize_to then
		return M.languages.getByCode(exc.normalize_to)
	end
	return lang
end

-- Add default values for boolean modifiers (e.g., &lt;unc&gt; becomes &lt;unc:1&gt;)
-- This is needed because Module:parse utilities expects boolean modifiers to have explicit values
function Util.add_boolean_defaults(str, param_mods)
	local result = str
	for name, spec in pairs(param_mods) do
		if spec.type == &quot;boolean&quot; then
			-- Replace &lt;name&gt; with &lt;name:1&gt; (but not &lt;name:...&gt; which already has a value)
			result = result:gsub(&quot;&lt;&quot; .. name .. &quot;&gt;&quot;, &quot;&lt;&quot; .. name .. &quot;:1&gt;&quot;)
		end
	end
	return result
end

-- Centralized term formatting: handles suppress_term, unknown_term, and regular terms
function Util.format_term(term, is_toplevel, opts)
	opts = opts or {}

	-- suppress_term (-) returns nil
	if term.suppress_term then
		return nil
	end

	local lang = term.lang
	local exc = Util.get_lang_exception(lang)

	if is_toplevel then
		local display_text = term.alt or term.title or &quot;&quot;
		local sc = term.sc or lang:findBestScript(display_text)
		local bold_text = tostring(mw.html.create(&quot;strong&quot;)
			:addClass(&quot;selflink&quot;)
			:wikitext(display_text))
		return M.script_utilities.tag_text(bold_text, lang, sc, &quot;term&quot;)
	end

	local link_params = { lang = lang }

	link_params.term = not term.unknown_term and term.title or nil
	link_params.alt = term.alt
	link_params.id = (not term.unknown_term and term.id and term.id ~= &quot;&quot;) and term.id or nil
	if not (exc and exc.suppress_tr) then
		link_params.tr = term.tr
		link_params.ts = term.ts
	else
		link_params.suppress_tr = true
	end
	link_params.lit = (opts.lit ~= &quot;suppress&quot;) and term.lit or nil
	if opts.gloss ~= &quot;suppress&quot; then
		link_params.gloss = term.t
	end
	if term.g and term.g ~= &quot;&quot; then
		local genders = M.string_utilities.split(term.g, &quot;,&quot;)
		for i = 1, #genders do
			genders[i] = M.string_utilities.trim(genders[i])
		end
		link_params.genders = genders
	end
	if opts.pos ~= &quot;suppress&quot; then
		link_params.pos = term.pos
		link_params.ng = term.ng
	end
	if exc and exc.suppress_tr then
		link_params.lit = nil
	end

	local show_qualifiers
	if opts.tree_ql ~= &quot;suppress&quot; then
		if term.q then
			link_params.q = term.q
		end
		if term.qq then
			link_params.qq = term.qq
		end
		if term.l then
			link_params.l = term.l
		end
		if term.ll then
			link_params.ll = term.ll
		end
		show_qualifiers = term.q or term.qq or term.l or term.ll
	end

	return M.links.full_link(link_params, &quot;term&quot;, nil, show_qualifiers and true or nil)
end

local __is_content_page_cached
function Util.is_content_page()
	if __is_content_page_cached == nil then
		__is_content_page_cached = M.pages.is_content_page(mw.title.getCurrentTitle())
	end
	return __is_content_page_cached
end

local __page_data_cached
function Util.get_page_data()
	if not __page_data_cached then
		__page_data_cached = M.headword_data.page
	end
	return __page_data_cached
end

-- Extract base keyword from param (without modifiers)
local function get_keyword_base(param)
	if type(param) ~= &quot;string&quot; then return nil end
	local base = param:match(&quot;^:?([^&lt;]+)&quot;) or param:gsub(&quot;^:&quot;, &quot;&quot;)
	return base
end

local function is_keyword(param, allow_colon_less)
	if type(param) ~= &quot;string&quot; then return false end
	local keywords = M.data.keywords
	if param:sub(1, 1) == &quot;:&quot; then
		local base = get_keyword_base(param)
		return keywords[base] ~= nil
	end
	if allow_colon_less then
		local base = get_keyword_base(param)
		return keywords[base] ~= nil
	end
	return false
end

local function get_keyword(param, allow_colon_less)
	if type(param) ~= &quot;string&quot; then return nil end
	local keywords = M.data.keywords
	if param:sub(1, 1) == &quot;:&quot; then
		return get_keyword_base(param)
	end
	if allow_colon_less then
		local base = get_keyword_base(param)
		if keywords[base] then
			return base
		end
	end
	return nil
end

local function normalize_keyword(keyword)
	if keyword:sub(1, 1) == &quot;:&quot; then
		return keyword
	end
	return &quot;:&quot; .. keyword
end

-- Resolve keyword (possibly an alias) to its canonical form. Used only at input boundaries
local function get_canonical_keyword(keyword)
	if not keyword then return keyword end
	return M.data.keyword_canonical[keyword] or keyword
end

-- Build text/phrase for nominalization with &lt;g:code&gt; (uses data module for codes only).
local function get_nominalization_label_for_g(code)
	if not code or code == &quot;&quot; then return nil end
	local codes = M.data.nominalization_g_codes
	local adj = codes[code]
	if not adj and #code == 2 then
		local gender_adj = codes[code:sub(1, 1)]
		local number_adj = codes[code:sub(2, 2)]
		if gender_adj and number_adj then
			adj = gender_adj .. &quot; &quot; .. number_adj
		end
	end
	if not adj then return nil end
	local text = adj:gsub(&quot;^%l&quot;, function(c) return string.upper(c) end) .. &quot; [[Appendix:Glossary#nominalization|nominalization]] of&quot;
	local phrase = M.en_utilities.add_indefinite_article(adj .. &quot; [[Appendix:Glossary#nominalization|nominalization]] of&quot;, false)
	return { text = text, phrase = phrase }
end

local EtymonParser = {}

-- Keyword modifier definitions
EtymonParser.keyword_param_mods = {
	unc = { type = &quot;boolean&quot; },
	ref = {},
	text = { restrict = { keywords = { &quot;from&quot;, &quot;derived&quot; } } },
	lit = { restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot;, &quot;univerbation&quot; } } },
	conj = {}, -- conjunction for alternatives: &quot;and&quot;, &quot;or&quot;, &quot;and/or&quot;, etc.
	g = { restrict = { keywords = { &quot;nominalization&quot; } } },
}

-- Term modifier definitions
EtymonParser.etymon_param_mods = {
	id = {},
	t = {},
	tr = {},
	ts = {},
	q = {},
	qq = {},
	l = {},
	ll = {},
	pos = {},
	ng = {},
	alt = {},
	g = {},
	ety = {},
	lit = {},
	unc = { type = &quot;boolean&quot; },
	ref = {},
	aftype = { restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot;, &quot;afeq&quot; } } },
	postype = {},
	bor = { type = &quot;boolean&quot;, restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot; } } },
	slbor = { type = &quot;boolean&quot;, restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot; } } },
	lbor = { type = &quot;boolean&quot;, restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot; } } },
}

local function get_clean_param_mods(param_mods)
	local clean = {}
	for mod_name, mod_def in pairs(param_mods) do
		clean[mod_name] = {}
		for key, value in pairs(mod_def) do
			if key ~= &quot;restrict&quot; then
				clean[mod_name][key] = value
			end
		end
	end
	return clean
end

function EtymonParser.check_modifier_restrictions(modifiers, current_keyword, param_mods)
	for mod_name, mod_value in pairs(modifiers) do
		-- Only check restrictions if the modifier has a non-false/nil value
		if mod_value then
			local mod_def = param_mods[mod_name]
			if mod_def and mod_def.restrict and mod_def.restrict.keywords then
				local allowed_keywords = mod_def.restrict.keywords
				local is_allowed = false
				for _, allowed_keyword in ipairs(allowed_keywords) do
					if current_keyword == allowed_keyword then
						is_allowed = true
						break
					end
				end
				if not is_allowed then
					local keyword_list = {}
					for _, kw in ipairs(allowed_keywords) do
						table.insert(keyword_list, &quot;:&quot; .. kw)
					end
					local keyword_str = table.concat(keyword_list, #keyword_list == 2 and &quot; or &quot; or &quot;, &quot;)
					if #keyword_list &gt; 2 then
						-- Replace last comma with &quot;or&quot;
						keyword_str = keyword_str:gsub(&quot;, ([^,]+)$&quot;, &quot; or %1&quot;)
					end
					local mod_display = mod_value == true and &quot;&lt;&quot; .. mod_name .. &quot;&gt;&quot; or &quot;&lt;&quot; .. mod_name .. &quot;:&quot; .. tostring(mod_value) .. &quot;&gt;&quot;
					error(&quot;The modifier `&quot; .. mod_display .. &quot;` is only allowed for the keyword&quot; .. (#keyword_list &gt; 1 and &quot;s &quot; or &quot; &quot;) .. keyword_str .. &quot;.&quot;)
				end
			end
		end
	end
end

-- Parse keyword with modifiers (e.g., &quot;:bor&lt;unc&gt;&quot; or &quot;:bor&lt;ref:{{R:example}}&gt;&quot;)
function EtymonParser.parse_keyword_modifiers(param)
	if type(param) ~= &quot;string&quot; then return nil, {} end

	local base_keyword = get_keyword_base(param)
	if not base_keyword then return nil, {} end

	local canonical_keyword = get_canonical_keyword(base_keyword)

	-- Check if there are any modifiers
	if not param:find(&quot;&lt;&quot;, 1, true) then
		return canonical_keyword, {}
	end

	-- Parse modifiers using the same mechanism as etymon parsing
	local rest_with_defaults = Util.add_boolean_defaults(param, EtymonParser.keyword_param_mods)

	local function generate_obj(ignored)
		return {}
	end

	local parsed = M.parse_utilities.parse_inline_modifiers(rest_with_defaults:gsub(&quot;^:?[^&lt;]+&quot;, &quot;&quot;),
		{ param_mods = get_clean_param_mods(EtymonParser.keyword_param_mods), generate_obj = generate_obj })

	local modifiers = {
		unc = parsed.unc or false,
		ref = parsed.ref,
		text = parsed.text,
		lit = parsed.lit,
		conj = parsed.conj,
		g = parsed.g,
	}

	-- Validate modifiers against restrictions
	EtymonParser.check_modifier_restrictions(modifiers, canonical_keyword, EtymonParser.keyword_param_mods)

	return canonical_keyword, modifiers
end

function EtymonParser.parse_balanced_segments(str)
	local segments = {}
	local current = &quot;&quot;
	local depth = 0
	local i = 1

	while i &lt;= #str do
		local char = str:sub(i, i)

		if char == &quot;&lt;&quot; then
			if depth == 0 and current ~= &quot;&quot; then
				table.insert(segments, current)
				current = &quot;&quot;
			end
			depth = depth + 1
			current = current .. char
		elseif char == &quot;&gt;&quot; then
			current = current .. char
			depth = depth - 1
			if depth == 0 then
				table.insert(segments, current)
				current = &quot;&quot;
			elseif depth &lt; 0 then
				error(&quot;Unbalanced brackets in etymon: unexpected '&gt;'&quot;)
			end
		else
			current = current .. char
		end

		i = i + 1
	end

	if depth ~= 0 then
		error(&quot;Unbalanced brackets in etymon: missing '&gt;'&quot;)
	end

	if current ~= &quot;&quot; then
		table.insert(segments, current)
	end

	return segments
end

function EtymonParser.parse_inline_ety(ety_string, context_lang)
	local segments = EtymonParser.parse_balanced_segments(ety_string)

	if #segments == 0 then
		error(&quot;Empty inline etymology&quot;)
	end

	local keyword = M.string_utilities.trim(segments[1])

	if not is_keyword(keyword, true) then
		error(&quot;Invalid keyword '&quot; .. keyword .. &quot;' in inline etymology &lt;ety:&quot; .. keyword .. &quot;...&gt;&quot;)
	end

	local args = { context_lang:getCode(), normalize_keyword(get_canonical_keyword(keyword)) }

	for i = 2, #segments do
		local segment = segments[i]
		if segment:sub(1, 1) == &quot;&lt;&quot; and segment:sub(-1) == &quot;&gt;&quot; then
			local inner = segment:sub(2, -2)
			if inner ~= &quot;&quot; then
				table.insert(args, inner)
			end
		elseif is_keyword(segment, true) then
			-- Handle keywords that appear between bracketed segments
			table.insert(args, normalize_keyword(get_canonical_keyword(get_keyword(segment, true))))
		end
	end

	return args
end

function EtymonParser.parse_etymon(param, context_lang)
	if is_keyword(param) then
		return nil
	end

	if type(param) ~= &quot;string&quot; then
		return nil
	end

	local lang, rest
	local is_family = false

	local before_bracket = param:match(&quot;^([^&lt;]*)&quot;) or param
	local lang_code, rest_match = before_bracket:match(&quot;^([a-zA-Z][a-zA-Z0-9._-]*):(.*)$&quot;)

	if lang_code then
		local potential_lang = Util.get_lang(lang_code, true)
		if potential_lang then
			lang = potential_lang
			rest = param:sub(#lang_code + 2)
		else
			local potential_family = Util.get_family(lang_code)
			if potential_family then
				lang = potential_family
				rest = param:sub(#lang_code + 2)
				is_family = true
			else
				lang = context_lang
				rest = param
			end
		end
	else
		lang = context_lang
		rest = param
	end

	if rest == &quot;&quot; then
		M.track(&quot;etymon/term/empty&quot;)
	elseif rest == &quot;?&quot; then
		M.track(&quot;etymon/term/question-mark&quot;)
	elseif rest == &quot;-&quot; then
		M.track(&quot;etymon/term/hyphen&quot;)
	end

	if rest == &quot;&quot; then
		return {
			lang = lang,
			term = nil,
			unknown_term = true,
			is_family = is_family,
		}
	end

	if rest == &quot;-&quot; then
		return {
			lang = lang,
			term = nil,
			suppress_term = true,
			is_family = is_family,
		}
	end

	if not rest:find(&quot;&lt;&quot;, 1, true) then
		return {
			lang = lang,
			term = M.string_utilities.trim(rest),
			is_family = is_family,
		}
	end

	local term_text = rest:match(&quot;^([^&lt;]*)&quot;) or &quot;&quot;
	local is_unknown = (term_text == &quot;&quot;)
	local is_suppress = (term_text == &quot;-&quot;)

	local function generate_obj(ignored_term)
		return { term = (is_unknown or is_suppress) and nil or M.string_utilities.trim(term_text) }
	end

	local rest_with_defaults = Util.add_boolean_defaults(rest, EtymonParser.etymon_param_mods)

	local parsed_obj = M.parse_utilities.parse_inline_modifiers(rest_with_defaults,
		{ param_mods = get_clean_param_mods(EtymonParser.etymon_param_mods), generate_obj = generate_obj })

	if parsed_obj.id and parsed_obj.id:match(&quot;^!&quot;) then
		parsed_obj.id = parsed_obj.id:sub(2)
		parsed_obj.override = true
	end

	parsed_obj.lang = lang
	parsed_obj.is_family = is_family
	if is_unknown then
		parsed_obj.unknown_term = true
	elseif is_suppress then
		parsed_obj.suppress_term = true
	end

	return parsed_obj
end

function EtymonParser.validate(lang, args, id, title, pos, starts_with_lang_code)
	-- id is now optional, so only validate if provided
	if id then
		if mw.ustring.len(id) &lt; 2 then
			error(&quot;The `id` parameter must have at least two characters.&quot;)
		end
		if id == title or id == Util.get_page_data().pagename then
			error(&quot;The `id` parameter must not be the same as the page title.&quot;)
		end
	end

	local valid_pos = { prefix = true, suffix = true, interfix = true, infix = true, root = true, word = true }
	if pos and not valid_pos[pos] then
		error(&quot;Unknown value provided for `pos`. Valid values: &quot; .. table.concat(require(&quot;Module:table&quot;).keysToList(valid_pos), &quot;, &quot;) .. &quot;.&quot;)
	end

	local current_keyword = &quot;from&quot;
	local etymons_in_group = {}
	local keywords = M.data.keywords

	local function checkGroup()
		if keywords[current_keyword] and keywords[current_keyword].is_group and current_keyword ~= &quot;affix&quot; and current_keyword ~= &quot;surf&quot; and current_keyword ~= &quot;afeq&quot; and current_keyword ~= &quot;univerbation&quot; and #etymons_in_group &lt;= 1 then
			error(&quot;Detected `:&quot; .. current_keyword .. &quot;` group with fewer than two etymons.&quot;)
		end
		etymons_in_group = {}
	end

	local start_index = starts_with_lang_code and 2 or 1

	for i = start_index, #args do
		local param = args[i]

		if type(param) ~= &quot;string&quot; then
		elseif param:sub(1, 1) == &quot;:&quot; and not is_keyword(param) then
			error(&quot;Invalid keyword '&quot; .. param .. &quot;'. Did you mean a valid keyword like ':bor', ':inh', etc.?&quot;)
		elseif is_keyword(param) then
			checkGroup()
			current_keyword = get_canonical_keyword(get_keyword(param))
		else
			local etymon_data = EtymonParser.parse_etymon(param, lang)
			if etymon_data then
				table.insert(etymons_in_group, param)
				local param_lang = etymon_data.lang

				if etymon_data.is_family and current_keyword == &quot;inherited&quot; then
					error(&quot;`:inh` does not support family codes; use a specific language.&quot;)
				end
				if etymon_data.is_family and not etymon_data.suppress_term then
					error(&quot;Family codes require suppressed term (use family:-).&quot;)
				end
				if current_keyword == &quot;from&quot; and param_lang:getFullCode() ~= lang:getFullCode() then
					error(&quot;`:from` is for same-language derivation, but language does not match. &quot; ..
						&quot;Expected '&quot; .. lang:getFullCode() .. &quot;', got '&quot; .. param_lang:getFullCode() .. &quot;'.&quot;)
				elseif current_keyword == &quot;inherited&quot; then
					M.etymology.check_ancestor(lang, param_lang)
				end

				-- Check modifier restrictions
				EtymonParser.check_modifier_restrictions(etymon_data, current_keyword, EtymonParser.etymon_param_mods)

				-- postype must be &quot;root&quot; or &quot;word&quot;
				local VALID_POSTYPES = { root = true, word = true }
				if etymon_data.postype and not VALID_POSTYPES[etymon_data.postype] then
					error(&quot;Invalid &lt;postype:&quot; .. etymon_data.postype .. &quot;&gt;; must be \&quot;root\&quot; or \&quot;word\&quot;.&quot;)
				end

				if etymon_data.ety then
					local inline_args = EtymonParser.parse_inline_ety(etymon_data.ety, etymon_data.lang)
					EtymonParser.validate(etymon_data.lang, inline_args, nil, nil, nil, true)
				end
			else
				table.insert(etymons_in_group, param)
			end
		end
	end

	checkGroup()
end

local DataRetriever = {}

-- Given an etymon data, scrape its page and cache the result in the global state object.
function DataRetriever.cache_page_etymons(etymon_page, etymon_title, key, etymon_lang, etymon_id, redirected_from, descendants_is_toplevel)
	local content = etymon_title:getContent()
	if not content then
		__state.cached_etymon_args[key] = M.data.STATUS.REDLINK
		return
	end

	-- Check if the linked page is a redirect. If it is, the template parsing
	-- code below will be effectively skipped, and `scrape_page` will be called
	-- again on the redirect target (see the bottom of this function)
	local lang_section_for_descendants = nil
	local redirect_target = etymon_title.redirect_target
	if not redirect_target then
		content = M.pages.get_section(content, etymon_lang:getFullName(), 2)
		if not content then
			__state.cached_etymon_args[key] = M.data.STATUS.MISSING
			return
		end
		lang_section_for_descendants = content
	end

	local etymon_lang_code = etymon_lang:getFullCode()
	local lang_page_key = etymon_lang_code .. &quot;:&quot; .. etymon_page
	local found_templates_for_lang = {}
	local found_ids = {}
	local get_node_class = M.template_parser.class_else_type

	-- Look for all {{etymon}} templates within the page content using the template parser
	-- This way the same page is never parsed more than once

	-- Build a map from senseids to their parent etymonids.
	local active_etymon_args = nil

	for node in M.template_parser.parse(content):iterate_nodes() do
		local node_class = get_node_class(node)

		if node_class == &quot;heading&quot; then
			-- A new L2 or etymology section acts as a barrier: an {{etymon}} usage
			-- used previously cannot be the parent of any subsequent senseids.
			-- Note that we don't have to check for L2s due to the usage of `M.pages.get_section` above.
			if node:get_name():find(&quot;^Etymology&quot;) then
				active_etymon_args = nil
			end
		elseif node_class == &quot;template&quot; then
			local template_name = node:get_name()

			if template_name == &quot;etymon&quot; then
				local template_args = node:get_arguments()

				-- Check if this etymon is for our language
				if template_args[1] == etymon_lang_code then
					table.insert(found_templates_for_lang, template_args)

					if template_args.id then
						local etymon_key = lang_page_key .. &quot;:&quot; .. template_args.id
						__state.cached_etymon_args[etymon_key] = template_args
						__state.cached_etymon_pages[etymon_key] = tostring(etymon_page)
						table.insert(found_ids, template_args.id)
						active_etymon_args = template_args
					else
						-- Store idless etymon with default key
						local etymon_key = lang_page_key .. &quot;:*&quot;
						__state.cached_etymon_args[etymon_key] = template_args
						__state.cached_etymon_pages[etymon_key] = tostring(etymon_page)
						table.insert(found_ids, &quot;*&quot;)
						active_etymon_args = template_args
					end
				end
			elseif active_etymon_args and template_name == &quot;senseid&quot; then
				local template_args = node:get_arguments()

				-- This should always be true for proper usages of {{senseid}}.
				if template_args[1] == etymon_lang_code and template_args[2] then
					local sense_id_key = lang_page_key .. &quot;:&quot; .. template_args[2]
					__state.senseid_parent_etymon[sense_id_key] = active_etymon_args
					__state.cached_etymon_pages[sense_id_key] = tostring(etymon_page)
				end
			end
		end
	end

	if descendants_is_toplevel and lang_section_for_descendants and #found_templates_for_lang &gt; 0 then
		M.descendants.cache_page_checks({
			lang_section = lang_section_for_descendants,
			etymon_lang_code = etymon_lang_code,
			found_templates_for_lang = found_templates_for_lang,
			entry_title = __state.entry_title,
			entry_lang_code = __state.entry_lang_code,
			entry_lang = __state.entry_lang_code and Util.get_lang(__state.entry_lang_code, true) or nil,
			cached_descendants_checks = __state.cached_descendants_checks,
			lang_page_key = lang_page_key,
			redirected_from = redirected_from,
		})
	end

	local id_data_list = {}
	for _, args in ipairs(found_templates_for_lang) do
		local id = args.id or &quot;*&quot;
		table.insert(id_data_list, { id = id, pos = args.pos })
	end
	__state.available_etymon_ids[lang_page_key] = id_data_list

	if #found_templates_for_lang == 1 then
		__state.single_etymons[lang_page_key] = found_templates_for_lang[1]
	end

	if redirected_from and __state.available_etymon_ids[lang_page_key] then
		__state.available_etymon_ids[redirected_from] = __state.available_etymon_ids[redirected_from] or {}
		for _, id_data in ipairs(__state.available_etymon_ids[lang_page_key]) do
			table.insert(__state.available_etymon_ids[redirected_from], id_data)
		end
	end

	if __state.cached_etymon_args[key] ~= nil or __state.senseid_parent_etymon[key] ~= nil then
		-- All done!
		return
	elseif redirect_target and not redirected_from then
		-- Try scraping the redirect.
		etymon_page = redirect_target.prefixedText
		DataRetriever.cache_page_etymons(etymon_page, redirect_target, lang_page_key .. &quot;:&quot; .. etymon_id, etymon_lang, etymon_id, lang_page_key, descendants_is_toplevel)
		__state.cached_etymon_args[key] = __state.cached_etymon_args[etymon_lang_code .. &quot;:&quot; .. etymon_page .. &quot;:&quot; .. etymon_id]
	else
		__state.cached_etymon_args[key] = M.data.STATUS.MISSING
	end
end

-- Given an etymon object, scrape its page (if necessary) and return its own etymon arguments as well as the page name.
function DataRetriever.get_etymon_args(etymon_data, is_toplevel)
	local page = M.links.get_link_page(etymon_data.term, etymon_data.lang)
	local norm_lang = Util.get_norm_lang(etymon_data.lang)
	local base_key = norm_lang:getFullCode() .. &quot;:&quot; .. page

	if etymon_data.id then
		local key = base_key .. &quot;:&quot; .. etymon_data.id

		local cached_args = __state.cached_etymon_args[key] or __state.senseid_parent_etymon[key]
		if cached_args == nil then
			local title = mw.title.new(page)
			if not title then error('Invalid page title &quot;' .. page .. '&quot; encountered.') end
			DataRetriever.cache_page_etymons(page, title, key, norm_lang, etymon_data.id, nil, is_toplevel)
		end
		cached_args = __state.cached_etymon_args[key] or __state.senseid_parent_etymon[key] -- refresh

		-- Get etymon_id from parent if this was resolved via senseid
		local parent_etymon = __state.senseid_parent_etymon[key]
		local resolved_etymon_id = parent_etymon and parent_etymon.id
		local descendants_check = M.descendants.get_lookup_check({
			cached_descendants_checks = __state.cached_descendants_checks,
			is_toplevel = is_toplevel,
			base_key = base_key,
			lookup = {
				explicit_id = etymon_data.id,
				parent_etymon = parent_etymon,
			},
		})
		if is_toplevel and descendants_check == nil then
			local title = mw.title.new(page)
			if title then
				DataRetriever.cache_page_etymons(page, title, key, norm_lang, etymon_data.id, nil, true)
				descendants_check = M.descendants.get_lookup_check({
					cached_descendants_checks = __state.cached_descendants_checks,
					is_toplevel = true,
					base_key = base_key,
					lookup = {
						explicit_id = etymon_data.id,
						parent_etymon = parent_etymon,
					},
				})
			end
		end
		return cached_args, __state.cached_etymon_pages[key], resolved_etymon_id, descendants_check
	else
		__state.used_idless_etymon = true
		if is_toplevel then
			__state.toplevel_idless_etymon = true
		end

		if __state.available_etymon_ids[base_key] == nil then
			local title = mw.title.new(page)
			if not title then error('Invalid page title &quot;' .. page .. '&quot; encountered.') end
			DataRetriever.cache_page_etymons(page, title, base_key .. &quot;:*&quot;, norm_lang, &quot;*&quot;, nil, is_toplevel)
		end

		local ids = __state.available_etymon_ids[base_key] or {}
		local count = #ids

		-- Try to filter by postype if available and we have multiple candidates
		if count &gt; 1 and etymon_data.postype then
			local matching_ids = {}
			for _, id_data in ipairs(ids) do
				if id_data.pos == etymon_data.postype then
					table.insert(matching_ids, id_data)
				end
			end
			
			if #matching_ids == 1 then
				local matched_id = matching_ids[1].id
				local matched_key = base_key .. &quot;:&quot; .. matched_id
				local descendants_check = M.descendants.get_lookup_check({
					cached_descendants_checks = __state.cached_descendants_checks,
					is_toplevel = is_toplevel,
					base_key = base_key,
					lookup = { id = matched_id },
				})
				if is_toplevel and descendants_check == nil then
					local title = mw.title.new(page)
					if title then
						DataRetriever.cache_page_etymons(page, title, base_key .. &quot;:*&quot;, norm_lang, &quot;*&quot;, nil, true)
						descendants_check = M.descendants.get_lookup_check({
							cached_descendants_checks = __state.cached_descendants_checks,
							is_toplevel = true,
							base_key = base_key,
							lookup = { id = matched_id },
						})
					end
				end
				return __state.cached_etymon_args[matched_key], __state.cached_etymon_pages[matched_key], nil, descendants_check
			end
		end

		if count == 1 then
			local only_id_data = ids[1]
			local only_id = (type(only_id_data) == &quot;table&quot; and only_id_data.id) or only_id_data or &quot;*&quot;
			local descendants_check = M.descendants.get_lookup_check({
				cached_descendants_checks = __state.cached_descendants_checks,
				is_toplevel = is_toplevel,
				base_key = base_key,
				lookup = { id_data = only_id_data },
			})
			if is_toplevel and descendants_check == nil then
				local title = mw.title.new(page)
				if title then
					DataRetriever.cache_page_etymons(page, title, base_key .. &quot;:*&quot;, norm_lang, &quot;*&quot;, nil, true)
					descendants_check = M.descendants.get_lookup_check({
						cached_descendants_checks = __state.cached_descendants_checks,
						is_toplevel = true,
						base_key = base_key,
						lookup = { id_data = only_id_data },
					})
				end
			end
			return __state.single_etymons[base_key], __state.cached_etymon_pages[base_key .. &quot;:&quot; .. only_id], nil, descendants_check
		elseif count &gt; 1 then
			local page_link = M.links.full_link({
				term = page,
				lang = norm_lang,
				no_generate_forms = true,
			}, &quot;term&quot;)

			local function format_id_hint(id_data, idx)
				local id = type(id_data) == &quot;table&quot; and id_data.id or id_data
				local pos = type(id_data) == &quot;table&quot; and id_data.pos
				if id and id ~= &quot;&quot; and id ~= &quot;*&quot; then
					return '&quot;' .. id .. '&quot;'
				end
				if pos and pos ~= &quot;&quot; then
					return &quot;unnamed (|pos=&quot; .. pos .. &quot;|)&quot;
				end
				return &quot;etymon #&quot; .. idx .. &quot; (no |id= on page)&quot;
			end

			local id_list = {}
			local all_idless = true
			local target_has_idless = false
			for i, id_data in ipairs(ids) do
				local id = type(id_data) == &quot;table&quot; and id_data.id or id_data
				if id and id ~= &quot;&quot; and id ~= &quot;*&quot; then
					all_idless = false
				else
					target_has_idless = true
				end
				table.insert(id_list, format_id_hint(id_data, i))
			end

			if is_toplevel and target_has_idless then
				__state.linked_page_multiple_etymons_idless = true
			end

			local any_pos = false
			for _, id_data in ipairs(ids) do
				local pos = type(id_data) == &quot;table&quot; and id_data.pos
				if pos and pos ~= &quot;&quot; then
					any_pos = true
					break
				end
			end

			local suggestion_text
			local lead = &quot;Etymology link to &quot; .. page_link .. &quot; is ambiguous (&quot; .. count .. &quot; {{etymon}} templates for &quot;
				.. norm_lang:getCanonicalName() .. &quot;).&quot;
			if all_idless then
				if any_pos then
					suggestion_text = &quot; None set `|id=` yet; add a unique `|id=` to each on &quot; .. page_link
						.. &quot;, then `&lt;id:identifier&gt;` after the term here. Section order / hints: &quot;
						.. mw.text.listToText(id_list) .. &quot;.&quot;
				else
					suggestion_text = &quot; None set `|id=` yet; add a unique `|id=` to each {{etymon}} in that section from top to bottom, then `&lt;id:identifier&gt;` after the term here (same value as `|id=`).&quot;
				end
			else
				suggestion_text = &quot; Specify which one with `&lt;id:identifier&gt;` after the term. Options: &quot; .. mw.text.listToText(id_list) .. &quot;.&quot;
			end

			Util.add_warning(lead .. suggestion_text, true)

			return M.data.STATUS.AMBIGUOUS, nil, nil, nil
		else
			return M.data.STATUS.MISSING, nil, nil, nil
		end
	end
end

local TreeBuilder = {}

local function parse_etymon_references(refs_text)
	if not refs_text or refs_text == &quot;&quot; then
		return &quot;&quot;
	end
	return M.references.parse_references(refs_text)
end

local function parse_tree_references(node)
	if node.ref then
		node.parsed_ref = parse_etymon_references(node.ref)
	end

	if node.children then
		for _, container in ipairs(node.children) do
			if container.terms then
				for _, term in ipairs(container.terms) do
					parse_tree_references(term)
				end
			end
		end
	end
end

-- Build a unique key for deduplication in the seen table
function TreeBuilder.build_key(lang, title, args)
	local norm_lang_code = Util.get_norm_lang(lang):getFullCode()
	local is_table = type(args) == &quot;table&quot;
	local id = (is_table and args.id) or &quot;&quot;
	
	if title then
		return norm_lang_code .. &quot;:&quot; .. M.links.get_link_page(title, lang) .. &quot;:&quot; .. id
	end
	
	if is_table and args.status == M.data.STATUS.INLINE then
		local content_parts = {}
		for i = 1, #args do
			content_parts[i] = tostring(args[i])
		end
		return norm_lang_code .. &quot;:*:&quot; .. id .. &quot;\0&quot; .. table.concat(content_parts, &quot;\0&quot;)
	end
	
	return norm_lang_code .. &quot;:*:&quot; .. id
end

function TreeBuilder.build(lang, title, args, seen, depth, stop_recursion)
	seen = seen or {}
	depth = depth or 0
	local is_toplevel = (depth == 0)

	if depth &gt; __state.max_depth_reached then
		__state.max_depth_reached = depth
	end

	__state.total_nodes = __state.total_nodes + 1

	local lang_code = lang:getCode()
	__state.language_count[lang_code] = (__state.language_count[lang_code] or 0) + 1

	local current_id = (type(args) == &quot;table&quot; and args.id) or &quot;&quot;
	local key = TreeBuilder.build_key(lang, title, args)
	
	local node = { lang = lang, title = title, id = current_id, args = args, children = {}, status = M.data.STATUS.OK }

	if type(args) ~= &quot;table&quot; or seen[key] then
		node.status = args or M.data.STATUS.MISSING
		-- Mark as duplicate if we've seen this node before
		if seen[key] then
			node.is_duplicate = true
			node.duplicate_key = key
			local original_node = seen[key]
			if type(original_node) == &quot;table&quot; and original_node.children and #original_node.children &gt; 0 then
				node.original_has_children = true
			end
		end
		return node
	end

	node.status = args.status or M.data.STATUS.OK

	seen[key] = node

	-- If stop_recursion is set, skip parsing children but check for visible children
	if stop_recursion then
		local keywords = M.data.keywords
		local has_visible_children = false
		for i = 2, #args do
			local param = args[i]
			if type(param) == &quot;string&quot; then
				local keyword_base = get_keyword_base(param)
				if keyword_base and keywords[keyword_base] then
					-- It's a keyword, check if visible in tree (invisible &quot;all&quot; or &quot;tree&quot; = hidden in tree)
					local keyword_info = keywords[keyword_base]
					local inv = keyword_info.invisible
					if not (inv == &quot;all&quot; or inv == true or inv == &quot;tree&quot;) then
						has_visible_children = true
						break
					end
				elseif param:sub(1, 1) ~= &quot;:&quot; then
					-- It's a term (not a keyword), so there are visible children
					has_visible_children = true
					break
				end
			end
		end
		node.has_visible_children = has_visible_children
		return node
	end

	-- Parse args into keyword containers
	local current_keyword = &quot;from&quot;
	local current_keyword_modifiers = {}
	local current_container = nil

	-- Helper to track keyword usage at top level
	local function track_keyword_usage(keyword, target_lang, source_lang)
		if not is_toplevel then return end

		if not __state.toplevel_keyword_stats[keyword] then
			__state.toplevel_keyword_stats[keyword] = {
				count = 0,
				target_langs = {},
				source_langs = {},
			}
		end

		local keyword_data = __state.toplevel_keyword_stats[keyword]
		keyword_data.count = keyword_data.count + 1

		local target_code = target_lang:getCode()
		keyword_data.target_langs[target_code] = (keyword_data.target_langs[target_code] or 0) + 1

		if source_lang then
			local source_code = source_lang:getCode()
			keyword_data.source_langs[source_code] = (keyword_data.source_langs[source_code] or 0) + 1
		end
	end

	local function ensure_container()
		if not current_container or current_container.keyword ~= current_keyword then
			current_container = {
				keyword = current_keyword,
				keyword_info = M.data.keywords[current_keyword],
				keyword_modifiers = current_keyword_modifiers,
				terms = {},
			}
			table.insert(node.children, current_container)
			-- Override keyword text/phrase for nominalization with &lt;g:code&gt;
			if current_keyword_modifiers.g and current_keyword == &quot;nominalization&quot; then
				local labels = get_nominalization_label_for_g(current_keyword_modifiers.g)
				if not labels then
					local codes = {}
					for c in pairs(M.data.nominalization_g_codes) do table.insert(codes, c) end
					table.sort(codes)
					error(&quot;Invalid &lt;g:&quot; .. tostring(current_keyword_modifiers.g) .. &quot;&gt;. Supported codes for nominalization: &quot; .. table.concat(codes, &quot;, &quot;))
				end
				current_container.keyword_info = {}
				for k, v in pairs(M.data.keywords[current_keyword]) do current_container.keyword_info[k] = v end
				current_container.keyword_info.text = labels.text
				current_container.keyword_info.phrase = labels.phrase
			end
		end
	end

	for i = 2, #args do
		local param = args[i]

		if is_keyword(param) then
			local keyword, modifiers = EtymonParser.parse_keyword_modifiers(param)
			current_keyword = keyword
			current_keyword_modifiers = modifiers
			current_container = nil -- Force new container for new keyword
		elseif type(param) == &quot;string&quot; and param:sub(1, 1) == &quot;:&quot; then
			error(&quot;Invalid keyword '&quot; .. param .. &quot;'. Did you mean a valid keyword like ':bor', ':inh', etc.?&quot;)
		elseif type(param) == &quot;string&quot; then
			local etymon_data = EtymonParser.parse_etymon(param, lang)

			if etymon_data then
				-- Track keyword usage at top level
				track_keyword_usage(current_keyword, lang, etymon_data.lang)

				local term_node = {}

				-- Handle suppress_term (-) and unknown_term (empty) directly
				if etymon_data.suppress_term or etymon_data.unknown_term then
					ensure_container()
					if etymon_data.ety then
						local inline_args = EtymonParser.parse_inline_ety(etymon_data.ety, etymon_data.lang)
						inline_args.id = etymon_data.id
						inline_args.status = M.data.STATUS.INLINE
						term_node = TreeBuilder.build(etymon_data.lang, nil, inline_args, seen, depth + 1)
					else
						term_node = {
							lang = etymon_data.lang,
							children = {},
							status = M.data.STATUS.OK,
						}
					end
					term_node.suppress_term = etymon_data.suppress_term
					term_node.unknown_term = etymon_data.unknown_term
					term_node.is_family = etymon_data.is_family
					term_node.is_uncertain = etymon_data.unc
					term_node.ref = etymon_data.ref
					term_node.t = etymon_data.t
					term_node.tr = etymon_data.tr
					term_node.ts = etymon_data.ts
					term_node.alt = etymon_data.alt
					term_node.g = etymon_data.g
					term_node.pos = etymon_data.pos
					term_node.ng = etymon_data.ng
					term_node.lit = etymon_data.lit
					term_node.q = etymon_data.q
					term_node.qq = etymon_data.qq
					term_node.l = etymon_data.l
					term_node.ll = etymon_data.ll
				else
					-- Regular term: fetch arguments from page
					local etymon_args, page_of, resolved_etymon_id, descendants_check = DataRetriever.get_etymon_args(etymon_data, is_toplevel)

					if etymon_data.id and etymon_args == M.data.STATUS.MISSING and not etymon_data.ety then
						local page = M.links.get_link_page(etymon_data.term, etymon_data.lang)
						local norm_lang = Util.get_norm_lang(etymon_data.lang)
						local base_key = norm_lang:getFullCode() .. &quot;:&quot; .. page
						local available_ids = __state.available_etymon_ids[base_key] or {}

						if #available_ids &gt; 0 then
							__state.has_mismatched_id = true
						end
					end

					-- Check for &lt;ety&gt; inline parameter doesn't override the scraped arguments, unless the latter are missing
					if etymon_data.ety then
						if etymon_args == M.data.STATUS.REDLINK or etymon_args == M.data.STATUS.MISSING then
							__state.current_page_has_inline_etymology = true
							if is_toplevel then
								__state.toplevel_has_inline_etymology = true
							end

							local inline_args = EtymonParser.parse_inline_ety(etymon_data.ety, etymon_data.lang)

							-- Track inline ety keywords too
							local inline_keyword = get_keyword(inline_args[2], true)
							if inline_keyword and #inline_args &gt;= 3 then
								local inline_etymon = EtymonParser.parse_etymon(inline_args[3], etymon_data.lang)
								if inline_etymon then
									track_keyword_usage(inline_keyword, etymon_data.lang, inline_etymon.lang)
								end
							end

							inline_args.id = etymon_data.id
							inline_args.status = M.data.STATUS.INLINE
							etymon_args = inline_args
							term_node.page_of = __state.cached_etymon_pages[key] -- term node is on the same page as the parent
						else
							-- Scraped arguments exist, &lt;ety&gt; is redundant and ignored
							__state.current_page_has_redundant_etymology = true
							if is_toplevel then
								__state.toplevel_redundant_etymology = true
							end
						end
					end

					-- Ensure container exists before checking keyword info
					ensure_container()
					
					-- Check if current keyword has no_child_categories - if so, stop recursion
					local keyword_info = current_container.keyword_info
					local should_stop_recursion = (stop_recursion or (keyword_info and keyword_info.no_child_categories))
					
					term_node = TreeBuilder.build(etymon_data.lang, etymon_data.term, etymon_args, seen, depth + 1, should_stop_recursion)
					term_node.target_key = Util.get_norm_lang(etymon_data.lang):getFullCode() ..
						&quot;:&quot; .. M.links.get_link_page(etymon_data.term, etymon_data.lang)
					term_node.id = etymon_data.id
					term_node.etymon_id = resolved_etymon_id  -- The actual etymon id when resolved via senseid
					term_node.t = etymon_data.t
					term_node.tr = etymon_data.tr
					term_node.ts = etymon_data.ts
					term_node.pos = etymon_data.pos
					term_node.alt = etymon_data.alt
					term_node.g = etymon_data.g
					term_node.ng = etymon_data.ng
					term_node.ref = etymon_data.ref
					term_node.is_uncertain = etymon_data.unc
					term_node.override = etymon_data.override
					term_node.page_of = page_of
					term_node.aftype = etymon_data.aftype
					term_node.postype = etymon_data.postype
					term_node.bor = etymon_data.bor
					term_node.lbor = etymon_data.lbor
					term_node.slbor = etymon_data.slbor
					term_node.lit = etymon_data.lit
					term_node.is_family = etymon_data.is_family
					term_node.q = etymon_data.q
					term_node.qq = etymon_data.qq
					term_node.l = etymon_data.l
					term_node.ll = etymon_data.ll
					term_node.missing_descendants_header, term_node.missing_descendants_entry =
						M.descendants.get_term_sync_flags(current_keyword, term_node.status, descendants_check)
				end

				table.insert(current_container.terms, term_node)
			end
		end
	end

	return node
end

-- Convert etymology tree to JSON-serializable table
local function tree_to_json(node)
	local obj = {
		term = node.title,
		lang = node.lang:getCode(),
		lang_name = node.lang:getCanonicalName(),
		id = (node.id and node.id ~= &quot;&quot;) and node.id or nil,
		status = node.status,
		is_uncertain = node.is_uncertain or nil,
		is_duplicate = node.is_duplicate or nil,
		gloss = node.t,
		transliteration = node.tr,
		transcription = node.ts,
		alt = node.alt,
		g = node.g,
		pos = node.pos,
		ng = node.ng,
		children = {},
	}

	for _, container in ipairs(node.children or {}) do
		local keyword_info = container.keyword_info
		if keyword_info then
			local container_obj = {
				keyword = container.keyword,
				keyword_label = keyword_info.text,
				keyword_abbrev = keyword_info.abbrev,
				is_group = keyword_info.is_group or nil,
				is_invisible = keyword_info.invisible or nil,
				is_uncertain = (container.keyword_modifiers and container.keyword_modifiers.unc) or nil,
				terms = {},
			}

			for _, term in ipairs(container.terms or {}) do
				table.insert(container_obj.terms, tree_to_json(term))
			end

			table.insert(obj.children, container_obj)
		end
	end

	return obj
end

local function track_ranges(base_key, value, ranges, lang_code)
	M.track(&quot;etymon/&quot; .. base_key .. &quot;/&quot; .. value)
	if lang_code then
		M.track(&quot;etymon/lang/&quot; .. lang_code .. &quot;/&quot; .. base_key .. &quot;/&quot; .. value)
	end

	for _, range in ipairs(ranges) do
		local matches = false
		if range.min and range.max then
			matches = value &gt;= range.min and value &lt;= range.max
		elseif range.min then
			matches = value &gt;= range.min
		elseif range.max then
			matches = value &lt;= range.max
		elseif range.exact then
			matches = value == range.exact
		end

		if matches then
			M.track(&quot;etymon/&quot; .. base_key .. &quot;/&quot; .. range.label)
			if lang_code then
				M.track(&quot;etymon/lang/&quot; .. lang_code .. &quot;/&quot; .. base_key .. &quot;/&quot; .. range.label)
			end
			break
		end
	end
end

local function track_title_pagename_mismatch_after_strip(lang)
	local lang_code = lang:getCode()
	M.track(&quot;etymon/title/pagename-mismatch-after-strip-diacritics&quot;)
	M.track(&quot;etymon/lang/&quot; .. lang_code .. &quot;/title/pagename-mismatch-after-strip-diacritics&quot;)
end

-- Build and return the etymology data tree for a given term.
function export.get_tree(lang, title, args, options)
	options = options or {}
	__state.entry_title = title
	__state.entry_lang_code = lang:getCode()

	if options.validate then
		EtymonParser.validate(lang, args, options.id, title, options.pos, false)
	end

	local lang_code = lang:getCode()

	local start_index = (args[1] == lang_code) and 2 or 1
	local tree_args = { [1] = lang_code, id = options.id or args.id }
	for i = start_index, #args do
		table.insert(tree_args, args[i])
	end

	__state.cached_etymon_args[lang_code .. &quot;:&quot; .. title .. &quot;:&quot; .. (tree_args.id or &quot;&quot;)] = tree_args

	local ety_data_tree = TreeBuilder.build(lang, title, tree_args)
	parse_tree_references(ety_data_tree)

	if options.json then
		return M.JSON.toJSON(tree_to_json(ety_data_tree))
	end

	return ety_data_tree
end

-- Given a language code, page name and optionally the id= parameter,
-- render the tree and only the etymology tree for the relevant page.
-- Fetches and parses the corresponding {{etymon}} from the requested page,
-- and any further pages needed to render the tree.
-- Parameters can be passed either through the #invoke or as
-- template parameters *through* an #invoke.
function export.render_tree_for_etymon_on_page(frame)
	local frame_args = frame.args
	local parent_args = frame:getParent().args
	local langcode = frame_args[1] or parent_args[1]
	local pagename = frame_args[2] or parent_args[2]
	local id = frame_args[&quot;id&quot;] or parent_args[&quot;id&quot;]
	local display_title = frame_args[&quot;title&quot;] or parent_args[&quot;title&quot;]

	local parsed_title = mw.title.new(pagename, 0)
	local title
	if parsed_title.namespace == 0 then
		title = M.pages.safe_page_name(parsed_title)
	elseif parsed_title.namespace == 118 then
		title = &quot;*&quot; .. M.pages.safe_page_name(parsed_title)
	else
		error(&quot;Unsupported namespace for render_tree_for_etymon_on_page: &quot; .. parsed_title.namespace)
	end

	local lang = Util.get_lang(langcode)
	-- Construct etymon_data for DataRetriever.get_args.
	local etymon_data = {
		lang = lang,
		term = title,
		id = id
	}
	local args, pagename = DataRetriever.get_etymon_args(etymon_data, true)
	if args == M.data.STATUS.MISSING then
		error(&quot;The etymon template was not found (language &quot; ..
			langcode ..
			&quot;, title '&quot; ..
			title ..
			&quot;'&quot; ..
			(id and &quot;, ID '&quot; .. id .. &quot;'&quot; or &quot;, no ID given&quot;) .. &quot;). Page contents may have changed in the interim.&quot;)
	end

	local tree_title = display_title or title
	if lang:stripDiacritics(M.links.remove_links(tree_title)) ~= lang:stripDiacritics(M.links.remove_links(title)) then
		track_title_pagename_mismatch_after_strip(lang)
	end

	local ety_data_tree = export.get_tree(lang, tree_title, args, {
		validate = true,
		id = id,
	})

	local output = {}
	table.insert(output, M.template_styles(&quot;Module:etymon/styles.css&quot;))
	table.insert(output, M.tree.render({
		data_tree = ety_data_tree,
		format_term_func = function(term, is_toplevel)
			return Util.format_term(term, is_toplevel, {
				gloss = &quot;suppress&quot;,
				pos = &quot;suppress&quot;,
				lit = &quot;suppress&quot;,
				tree_ql = &quot;suppress&quot;,
			})
		end,
	}))

	return table.concat(output)
end

function export.main(frame)
	local parent_args = frame:getParent().args
	local args = M.parameters.process(parent_args, M.parameters_data.etymon)
	local lang = args[1]
	local etymon_args = args[2]
	local id = args.id
	local title = args.title
	local text = args.text
	local tree = args.tree
	local etydate = args.etydate
	local rfe = args.rfe
	local page_data = Util.get_page_data()

	if not title then
		title = page_data.pagename
		if page_data.namespace == &quot;Reconstruction&quot; then title = &quot;*&quot; .. title end
	end

	local entry_pagename = page_data.pagename
	if page_data.namespace == &quot;Reconstruction&quot; then
		entry_pagename = &quot;*&quot; .. entry_pagename
	end
	if lang:stripDiacritics(M.links.remove_links(title)) ~= lang:stripDiacritics(M.links.remove_links(entry_pagename)) then
		track_title_pagename_mismatch_after_strip(lang)
	end

	local current_L2 = M.pages.get_current_L2()
	if current_L2 then
		local norm_lang = Util.get_norm_lang(lang)
		local norm_name = norm_lang:getCanonicalName()
		if current_L2 ~= norm_name then
			local lang_desc = lang:getCode() .. &quot; (&quot; .. lang:getCanonicalName() .. &quot;)&quot;
			if norm_lang:getCode() ~= lang:getCode() then
				lang_desc = lang_desc .. &quot;, normalized to &quot; .. norm_lang:getCode() .. &quot; (&quot; .. norm_name .. &quot;)&quot;
			end
			error(&quot;Language '&quot; .. lang_desc .. &quot;' does not match the L2 header (&quot; .. current_L2 .. &quot;).&quot;)
		end
	end

	local ety_data_tree = export.get_tree(lang, title, etymon_args, {
		validate = true,
		pos = args.pos,
		id = id,
		json = args.json,
	})

	if args.json then
		return ety_data_tree
	end

	local output = {}

	local text_allowlist_mode = M.text_allowed.default_mode or &quot;off&quot;
	if text and text_allowlist_mode ~= &quot;off&quot; and not Util.is_text_param_allowed_for_lang(lang) then
		local msg = &quot;Etymology texts (parameter &lt;code&gt;text=&lt;/code&gt;) are not allowed for &quot; .. lang:getFullName() ..
			&quot;; see [[Template:etymon#Text allowlist|Template:etymon § Text allowlist]] for the list of languages that may use the &lt;code&gt;text=&lt;/code&gt; parameter.&quot;
		if text_allowlist_mode == &quot;error&quot; then
			error(msg)
		else
			Util.add_warning(msg, true)
		end
	end

	local lang_exc = Util.get_lang_exception(lang)
	if lang_exc and lang_exc.disallow then
		local disallow = lang_exc.disallow
		local error_text = &quot; for &quot; .. lang:getFullName()
		if disallow.ref then
			error_text = error_text .. &quot;; see &quot; .. disallow.ref
		else
			error_text = error_text .. &quot;.&quot;
		end
		if tree and disallow.tree then
			error(&quot;Etymology trees are not allowed&quot; .. error_text)
		end
		if text and disallow.text then
			error(&quot;Etymology texts are not allowed&quot; .. error_text)
		end
	end

	if etydate then
		local etydate_param_mods = {
			ref = { list = true, type = &quot;references&quot;, allow_holes = true },
			refn = { list = true, allow_holes = true },
			nocap = { type = &quot;boolean&quot; },
		}

		local function generate_etydate_obj(etydate_text)
			local etydate_specs = {}
			for spec in etydate_text:gmatch(&quot;[^,]+&quot;) do
				table.insert(etydate_specs, mw.text.trim(spec))
			end
			return { [1] = etydate_specs }
		end

		local parsed_etydate = M.parse_utilities.parse_inline_modifiers(etydate, { param_mods = etydate_param_mods, generate_obj = generate_etydate_obj })

		local etydate_args = {
			[1] = parsed_etydate[1],
			nocap = parsed_etydate.nocap or false,
		}

		ety_data_tree.etydate = M.etydate.format_etydate(etydate_args, { omit_refs = true })

		if parsed_etydate.ref and #parsed_etydate.ref &gt; 0 then
			ety_data_tree.etydate_refs = parsed_etydate.ref
		end
	end

	if tree then
		table.insert(output, M.template_styles(&quot;Module:etymon/styles.css&quot;))
		table.insert(output, M.tree.render({
			data_tree = ety_data_tree,
			format_term_func = function(term, is_toplevel)
				return Util.format_term(term, is_toplevel, {
					gloss = &quot;suppress&quot;,
					pos = &quot;suppress&quot;,
					lit = &quot;suppress&quot;,
					tree_ql = &quot;suppress&quot;,
				})
			end,
		}))
	end

	-- Check if there are any visible children in tree (invisible &quot;all&quot; or &quot;tree&quot; = hidden in tree)
	local has_visible_children = false
	for _, child in ipairs(ety_data_tree.children or {}) do
		local child_keyword_info = child.keyword_info
		local inv = child_keyword_info and child_keyword_info.invisible
		if not (inv == &quot;all&quot; or inv == true or inv == &quot;tree&quot;) then
			has_visible_children = true
			break
		end
	end

	local tree_disallowed = lang_exc and lang_exc.disallow and lang_exc.disallow.tree
	local ety_tree_json = M.JSON.toJSON(tree_to_json(ety_data_tree))
	local anchor = M.anchors.etymonid(lang, id, {
		no_tree = args.notree,
		title = title,
		empty_tree = (not has_visible_children) or tree_disallowed,
		ety_tree_json = ety_tree_json,
	})
	table.insert(output, anchor)

	if text then
		local max_depth, stop_at_blue_link, stop_at_lang, stop_at_lang_or_bluelink
		if text == &quot;++&quot; then
			max_depth, stop_at_blue_link = false, false
		elseif text == &quot;+&quot; then
			max_depth, stop_at_blue_link = 1, false
		elseif text == &quot;*&quot; then
			max_depth, stop_at_blue_link = false, true
		elseif text:match(&quot;^:[^*]+%*$&quot;) then
			-- Stop at a specific language OR first bluelink after it, e.g., &quot;:ota*&quot;
			-- If the target language is a redlink, continue to the first bluelink
			local lang_code = text:match(&quot;^:([^*]+)%*$&quot;)
			if lang_code and lang_code ~= &quot;&quot; then
				local lang_obj = Util.get_lang(lang_code, true)
				if lang_obj then
					stop_at_lang_or_bluelink = lang_code
				else
					Util.add_warning('Invalid language code &quot;' .. lang_code .. '&quot; in text parameter. Showing full chain instead.')
					max_depth, stop_at_blue_link = false, false
				end
			else
				Util.add_warning('Empty language code in text parameter. Showing full chain instead.')
				max_depth, stop_at_blue_link = false, false
			end
		elseif text:sub(1, 1) == &quot;:&quot; then
			-- Stop at a specific language, e.g., &quot;:ar&quot; stops at first Arabic term
			local lang_code = text:sub(2)
			if lang_code ~= &quot;&quot; then
				-- Validate the language code
				local lang_obj = Util.get_lang(lang_code, true)
				if lang_obj then
					stop_at_lang = lang_code
				else
					Util.add_warning('Invalid language code &quot;' .. lang_code .. '&quot; in text parameter. Showing full chain instead.')
					max_depth, stop_at_blue_link = false, false -- default to ++
				end
			else
				Util.add_warning('Empty language code in text parameter. Showing full chain instead.')
				max_depth, stop_at_blue_link = false, false -- default to ++
			end
		else
			local num = tonumber(text)
			if num and num &gt;= 1 then
				max_depth, stop_at_blue_link = num, false
			else
				error('Invalid text value &quot;' ..
					text .. '&quot;. Valid values are: &quot;++&quot; (full chain), &quot;+&quot; (first step only), &quot;*&quot; (until first blue link), a number (max steps), &quot;:lang&quot; (stop at language), or &quot;:lang*&quot; (stop at language or first bluelink if redlink)')
			end
		end
		table.insert(output, M.text.render({
			data_tree = ety_data_tree,
			format_term_func = Util.format_term,
			max_depth = max_depth,
			stop_at_blue_link = stop_at_blue_link,
			curr_page = page_data.pagename,
			nodot = args.nodot,
			stop_at_lang = stop_at_lang,
			stop_at_lang_or_bluelink = stop_at_lang_or_bluelink,
		}))
	end

	if rfe then
		local rfe_param_mods = {
			nocat = { type = &quot;boolean&quot; },
			sort = {},
			y = {},
			m = {},
			fragment = {},
			section = {},
			box = { type = &quot;boolean&quot; },
			noes = { type = &quot;boolean&quot; },
		}

		local function generate_rfe_obj(rfe_text)
			-- Check if it's a boolean true value
			if M.yesno(rfe_text, false) then
				return { is_boolean = true }
			else
				return { text = rfe_text }
			end
		end

		local rfe_with_defaults = Util.add_boolean_defaults(rfe, rfe_param_mods)
		local parsed_rfe = M.parse_utilities.parse_inline_modifiers(rfe_with_defaults, { 
			param_mods = rfe_param_mods, 
			generate_obj = generate_rfe_obj 
		})

		local rfe_args = {
			[1] = lang:getCode(),
			nocat = parsed_rfe.nocat,
			sort = parsed_rfe.sort,
			y = parsed_rfe.y,
			m = parsed_rfe.m,
			fragment = parsed_rfe.fragment,
			section = parsed_rfe.section,
			box = parsed_rfe.box,
			noes = parsed_rfe.noes,
		}

		if not parsed_rfe.is_boolean then
			rfe_args[2] = parsed_rfe.text
		end

		table.insert(output, frame:expandTemplate({
			title = &quot;rfe&quot;,
			args = rfe_args
		}))
	end

	if Util.is_content_page() and __state.max_depth_reached &gt; 0 then
		local lang_code = lang:getCode()

		local depth_ranges = {
			{ min = 50, label = &quot;extremely-deep&quot; },
			{ min = 20, label = &quot;20+&quot; },
			{ min = 10, max = 19,                label = &quot;10-19&quot; },
			{ min = 5,  max = 9,                 label = &quot;5-9&quot; },
			{ min = 3,  max = 4,                 label = &quot;3-4&quot; },
			{ max = 2,  label = &quot;1-2&quot; }
		}

		local node_ranges = {
			{ min = 100, label = &quot;extremely-large&quot; },
			{ min = 50,  label = &quot;50+&quot; },
			{ min = 20,  max = 49,                 label = &quot;20-49&quot; },
			{ min = 10,  max = 19,                 label = &quot;10-19&quot; },
			{ min = 5,   max = 9,                  label = &quot;5-9&quot; },
			{ max = 4,   label = &quot;1-4&quot; }
		}

		local language_ranges = {
			{ min = 10,  label = &quot;10+&quot; },
			{ min = 5,   max = 9,      label = &quot;5-9&quot; },
			{ min = 3,   max = 4,      label = &quot;3-4&quot; },
			{ exact = 2, label = &quot;2&quot; },
			{ exact = 1, label = &quot;1&quot; }
		}

		track_ranges(&quot;depth&quot;, __state.max_depth_reached, depth_ranges, lang_code)
		track_ranges(&quot;nodes&quot;, __state.total_nodes, node_ranges, lang_code)

		local unique_languages = 0
		for _ in pairs(__state.language_count) do
			unique_languages = unique_languages + 1
		end
		track_ranges(&quot;unique-languages&quot;, unique_languages, language_ranges, lang_code)

		if __state.total_nodes == __state.max_depth_reached + 1 then
			track_ranges(&quot;linear-depth&quot;, __state.max_depth_reached, depth_ranges, lang_code)
		end
	end

	local categories = {}
	if Util.is_content_page() then
		local should_suppress_categories = lang_exc and lang_exc.suppress_categories
		if not should_suppress_categories and not args.nocat then
			categories = M.categories.render({
				data_tree = ety_data_tree,
				page_lang = lang,
				available_etymon_ids = __state.available_etymon_ids,
				senseid_parent_etymon = __state.senseid_parent_etymon,
				get_norm_lang_func = Util.get_norm_lang,
				lang_exc = lang_exc,
			})
		end

		local target_lang_code = lang:getCode()
		for keyword, keyword_data in pairs(__state.toplevel_keyword_stats) do
			-- Track keyword globally
			M.track(&quot;etymon/keyword/&quot; .. keyword)

			-- Track keyword per target language
			M.track(&quot;etymon/keyword/&quot; .. keyword .. &quot;/target/&quot; .. target_lang_code)

			-- Track keyword per source language
			for source_code, count in pairs(keyword_data.source_langs) do
				M.track(&quot;etymon/keyword/&quot; .. keyword .. &quot;/source/&quot; .. source_code)

				-- Track keyword per target+source combination
				M.track(&quot;etymon/keyword/&quot; .. keyword .. &quot;/target/&quot; .. target_lang_code .. &quot;/source/&quot; .. source_code)
			end
		end

		if tree then
			table.insert(categories, &quot;Pages with etymology trees&quot;)
			table.insert(categories, lang:getCanonicalName() .. &quot; entries with etymology trees&quot;)
		end
		if text then table.insert(categories, lang:getCanonicalName() .. &quot; entries with etymology texts&quot;) end
		if args.exnihilo then table.insert(categories, lang:getCanonicalName() .. &quot; terms coined ex nihilo&quot;) end
		if __state.toplevel_has_inline_etymology then
			table.insert(categories, &quot;Pages with inline etymon for redlinks&quot;)
		end
		if __state.toplevel_redundant_etymology then
			table.insert(categories, &quot;Pages with redundant inline etymon&quot;)
		end
		if __state.toplevel_idless_etymon then
			table.insert(categories, &quot;Pages using etymon with no ID&quot;)
		end
		if __state.has_mismatched_id then
			table.insert(categories, lang:getCanonicalName() .. &quot; entries referencing etymons with mismatched IDs&quot;)
		end
		if __state.linked_page_multiple_etymons_idless then
			table.insert(categories,
				lang:getCanonicalName() .. &quot; entries referencing pages with multiple etymons missing IDs&quot;)
		end
	end

	if #categories &gt; 0 then
		table.insert(output, M.categories.format(categories, lang))
	end

	if __state.warnings then
		for i, warning in ipairs(__state.warnings) do
			table.insert(output, (i == 1 and &quot;\n&quot; or &quot;&quot;) .. warning .. &quot;\n&quot;)
		end
	end

	return table.concat(output)
end

return export</text>
      <sha1>sd824iy93rvmo3oroit742p1i4oi4gt</sha1>
    </revision>
    <revision>
      <id>342823</id>
      <parentid>342816</parentid>
      <timestamp>2026-05-16T13:47:59Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <origin>342823</origin>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="61582" sha1="atzf01y3q7myy0cwlzlcz4tnhqsss0s" xml:space="preserve">--[=[

This module implements the {{etymon}} template for structured etymology data on Wiktionary.
It enables the creation of etymology trees and text by parsing etymon chains,
scraping linked pages for their own {{etymon}} data, and recursively building a tree
of derivational relationships.

Authors:
- Original implementation: [[User:Ioaxxere]]
- Full refactor (September 2025): [[User:Fenakhay]] ([[Special:Diff/86717746]])

Modules:
- [[Module:etymon]]: main module handling parsing, validation, tree building, and page scraping
- [[Module:etymon/data]]: keyword definitions, configuration, and status constants
- [[Module:etymon/tree]]: etymology tree rendering
- [[Module:etymon/text]]: etymology text generation
- [[Module:etymon/categories]]: category generation logic

]=]

local export = {}

local etymon_data_module = &quot;Module:etymon/data&quot;
local etymon_text_module = &quot;Module:etymon/text&quot;
local etymon_tree_module = &quot;Module:etymon/tree&quot;
local etymon_categories_module = &quot;Module:etymon/categories&quot;
local etymon_descendants_module = &quot;Module:etymon/descendants&quot;

local __state = {
	cached_etymon_args = {},
	cached_etymon_pages = {},
	cached_descendants_checks = {},
	senseid_parent_etymon = {},
	available_etymon_ids = {},
	single_etymons = {},
	entry_title = nil,
	entry_lang_code = nil,
	current_page_has_inline_etymology = false,
	current_page_has_redundant_etymology = false,
	used_idless_etymon = false,
	toplevel_has_inline_etymology = false,
	toplevel_redundant_etymology = false,
	toplevel_idless_etymon = false,
	has_mismatched_id = false,
	linked_page_multiple_etymons_idless = false,
	max_depth_reached = 0,
	total_nodes = 0,
	language_count = {},
	toplevel_keyword_stats = {},
	warnings = {},
}

local loader = require(&quot;Module:module loader&quot;)

local M = loader.init({
	require = {
		data = etymon_data_module,
		tree = etymon_tree_module,
		text = etymon_text_module,
		categories = etymon_categories_module,
		descendants = etymon_descendants_module,

		anchors = &quot;Module:anchors&quot;,
		etydate = &quot;Module:etydate&quot;,
		etymology = &quot;Module:etymology&quot;,
		families = &quot;Module:families&quot;,
		languages = &quot;Module:languages&quot;,
		languages_errorgetby = &quot;Module:languages/errorGetBy&quot;,
		links = &quot;Module:links&quot;,
		pages = &quot;Module:pages&quot;,
		parameters = &quot;Module:parameters&quot;,
		string_utilities = &quot;Module:string utilities&quot;,
		template_parser = &quot;Module:template parser&quot;,
		utilities = &quot;Module:utilities&quot;,
		debug = &quot;Module:debug&quot;,
		en_utilities = &quot;Module:en-utilities&quot;,
		parse_utilities = &quot;Module:parse utilities&quot;,
		references = &quot;Module:references&quot;,
		track = &quot;Module:debug/track&quot;,
		template_styles = &quot;Module:TemplateStyles&quot;,
		script_utilities = &quot;Module:script utilities&quot;,
		JSON = &quot;Module:JSON&quot;,
		yesno = &quot;Module:yesno&quot;,
	},
	loadData = {
		headword_data = &quot;Module:headword/data&quot;,
		parameters_data = &quot;Module:parameters/data&quot;,
		text_allowed = &quot;Module:etymon/data/text_allowed&quot;,
	},
})

local Util = {}

function Util.format_error(message, preview_only)
	if preview_only and not M.pages.is_preview() then
		return nil
	end
	return '&lt;span class=&quot;error&quot;&gt;' .. message .. '&lt;/span&gt;'
end

function Util.add_warning(message, preview_only)
	local formatted = Util.format_error(message, preview_only)
	if formatted then
		table.insert(__state.warnings, formatted)
	end
end

function Util.is_text_param_allowed_for_lang(lang)
	if not lang or type(lang) ~= &quot;table&quot; then
		return false
	end
	local types = lang.getTypes and lang:getTypes()
	if types and types.family then
		local code = lang.getCode and lang:getCode()
		return code and M.text_allowed.families[code] == true
	end
	local full_code = lang.getFullCode and lang:getFullCode()
	if full_code and M.text_allowed.langs[full_code] then
		return true
	end
	if lang.inFamily then
		for family_code in pairs(M.text_allowed.families) do
			if lang:inFamily(family_code) then
				return true
			end
		end
	end
	return false
end

function Util.get_lang(code, no_error)
	if no_error then
		return M.languages.getByCode(code, nil, true)
	end
	return M.languages.getByCode(code, nil, true) or M.languages_errorgetby.code(code, true, true)
end

function Util.get_family(code)
	return M.families.getByCode(code)
end

function Util.get_lang_exception(lang)
	-- Families have no language-specific exceptions
	if lang.getTypes and lang:getTypes().family then
		return nil
	end
	local code = lang:getCode()
	local lang_exceptions = M.data.config.lang_exceptions

	if lang_exceptions[code] then
		return lang_exceptions[code]
	end

	for norm_code, exc in pairs(lang_exceptions) do
		if exc.normalize_to and code == exc.normalize_to then
			return exc
		end
		if exc.normalize_from_families then
			local should_normalize = false
			for _, family in ipairs(exc.normalize_from_families) do
				if lang:inFamily(family) then
					should_normalize = true
					break
				end
			end

			if should_normalize and exc.normalize_exclude_families then
				for _, family in ipairs(exc.normalize_exclude_families) do
					if lang:inFamily(family) then
						should_normalize = false
						break
					end
				end
			end

			if should_normalize then
				local ret = {}
				for k, v in pairs(exc) do
					ret[k] = v
				end
				ret.suppress_tr = nil
				return ret
			end
		end
	end

	return nil
end

function Util.get_norm_lang(lang)
	local exc = Util.get_lang_exception(lang)
	if exc and exc.normalize_to then
		return M.languages.getByCode(exc.normalize_to)
	end
	return lang
end

-- Add default values for boolean modifiers (e.g., &lt;unc&gt; becomes &lt;unc:1&gt;)
-- This is needed because Module:parse utilities expects boolean modifiers to have explicit values
function Util.add_boolean_defaults(str, param_mods)
	local result = str
	for name, spec in pairs(param_mods) do
		if spec.type == &quot;boolean&quot; then
			-- Replace &lt;name&gt; with &lt;name:1&gt; (but not &lt;name:...&gt; which already has a value)
			result = result:gsub(&quot;&lt;&quot; .. name .. &quot;&gt;&quot;, &quot;&lt;&quot; .. name .. &quot;:1&gt;&quot;)
		end
	end
	return result
end

-- Centralized term formatting: handles suppress_term, unknown_term, and regular terms
function Util.format_term(term, is_toplevel, opts)
	opts = opts or {}

	-- suppress_term (-) returns nil
	if term.suppress_term then
		return nil
	end

	local lang = term.lang
	local exc = Util.get_lang_exception(lang)

	if is_toplevel then
		local display_text = term.alt or term.title or &quot;&quot;
		local sc = term.sc or lang:findBestScript(display_text)
		local bold_text = tostring(mw.html.create(&quot;strong&quot;)
			:addClass(&quot;selflink&quot;)
			:wikitext(display_text))
		return M.script_utilities.tag_text(bold_text, lang, sc, &quot;term&quot;)
	end

	local link_params = { lang = lang }

	link_params.term = not term.unknown_term and term.title or nil
	link_params.alt = term.alt
	link_params.id = (not term.unknown_term and term.id and term.id ~= &quot;&quot;) and term.id or nil
	if not (exc and exc.suppress_tr) then
		link_params.tr = term.tr
		link_params.ts = term.ts
	else
		link_params.suppress_tr = true
	end
	link_params.lit = (opts.lit ~= &quot;suppress&quot;) and term.lit or nil
	if opts.gloss ~= &quot;suppress&quot; then
		link_params.gloss = term.t
	end
	if term.g and term.g ~= &quot;&quot; then
		local genders = M.string_utilities.split(term.g, &quot;,&quot;)
		for i = 1, #genders do
			genders[i] = M.string_utilities.trim(genders[i])
		end
		link_params.genders = genders
	end
	if opts.pos ~= &quot;suppress&quot; then
		link_params.pos = term.pos
		link_params.ng = term.ng
	end
	if exc and exc.suppress_tr then
		link_params.lit = nil
	end

	local show_qualifiers
	if opts.tree_ql ~= &quot;suppress&quot; then
		if term.q then
			link_params.q = term.q
		end
		if term.qq then
			link_params.qq = term.qq
		end
		if term.l then
			link_params.l = term.l
		end
		if term.ll then
			link_params.ll = term.ll
		end
		show_qualifiers = term.q or term.qq or term.l or term.ll
	end

	return M.links.full_link(link_params, &quot;term&quot;, nil, show_qualifiers and true or nil)
end

local __is_content_page_cached
function Util.is_content_page()
	if __is_content_page_cached == nil then
		__is_content_page_cached = M.pages.is_content_page(mw.title.getCurrentTitle())
	end
	return __is_content_page_cached
end

local __page_data_cached
function Util.get_page_data()
	if not __page_data_cached then
		__page_data_cached = M.headword_data.page
	end
	return __page_data_cached
end

-- Extract base keyword from param (without modifiers)
local function get_keyword_base(param)
	if type(param) ~= &quot;string&quot; then return nil end
	local base = param:match(&quot;^:?([^&lt;]+)&quot;) or param:gsub(&quot;^:&quot;, &quot;&quot;)
	return base
end

local function is_keyword(param, allow_colon_less)
	if type(param) ~= &quot;string&quot; then return false end
	local keywords = M.data.keywords
	if param:sub(1, 1) == &quot;:&quot; then
		local base = get_keyword_base(param)
		return keywords[base] ~= nil
	end
	if allow_colon_less then
		local base = get_keyword_base(param)
		return keywords[base] ~= nil
	end
	return false
end

local function get_keyword(param, allow_colon_less)
	if type(param) ~= &quot;string&quot; then return nil end
	local keywords = M.data.keywords
	if param:sub(1, 1) == &quot;:&quot; then
		return get_keyword_base(param)
	end
	if allow_colon_less then
		local base = get_keyword_base(param)
		if keywords[base] then
			return base
		end
	end
	return nil
end

local function normalize_keyword(keyword)
	if keyword:sub(1, 1) == &quot;:&quot; then
		return keyword
	end
	return &quot;:&quot; .. keyword
end

-- Resolve keyword (possibly an alias) to its canonical form. Used only at input boundaries
local function get_canonical_keyword(keyword)
	if not keyword then return keyword end
	return M.data.keyword_canonical[keyword] or keyword
end

-- Build text/phrase for nominalization with &lt;g:code&gt; (uses data module for codes only).
local function get_nominalization_label_for_g(code)
	if not code or code == &quot;&quot; then return nil end
	local codes = M.data.nominalization_g_codes
	local adj = codes[code]
	if not adj and #code == 2 then
		local gender_adj = codes[code:sub(1, 1)]
		local number_adj = codes[code:sub(2, 2)]
		if gender_adj and number_adj then
			adj = gender_adj .. &quot; &quot; .. number_adj
		end
	end
	if not adj then return nil end
	local text = adj:gsub(&quot;^%l&quot;, function(c) return string.upper(c) end) .. &quot; [[Appendix:Glossary#nominalization|nominalization]] of&quot;
	local phrase = M.en_utilities.add_indefinite_article(adj .. &quot; [[Appendix:Glossary#nominalization|nominalization]] of&quot;, false)
	return { text = text, phrase = phrase }
end

local EtymonParser = {}

-- Keyword modifier definitions
EtymonParser.keyword_param_mods = {
	unc = { type = &quot;boolean&quot; },
	ref = {},
	text = { restrict = { keywords = { &quot;from&quot;, &quot;derived&quot; } } },
	lit = { restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot;, &quot;univerbation&quot; } } },
	conj = {}, -- conjunction for alternatives: &quot;and&quot;, &quot;or&quot;, &quot;and/or&quot;, etc.
	g = { restrict = { keywords = { &quot;nominalization&quot; } } },
}

-- Term modifier definitions
EtymonParser.etymon_param_mods = {
	id = {},
	t = {},
	tr = {},
	ts = {},
	q = {},
	qq = {},
	l = {},
	ll = {},
	pos = {},
	ng = {},
	alt = {},
	g = {},
	ety = {},
	lit = {},
	unc = { type = &quot;boolean&quot; },
	ref = {},
	aftype = { restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot;, &quot;afeq&quot; } } },
	postype = {},
	bor = { type = &quot;boolean&quot;, restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot; } } },
	slbor = { type = &quot;boolean&quot;, restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot; } } },
	lbor = { type = &quot;boolean&quot;, restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot; } } },
}

local function get_clean_param_mods(param_mods)
	local clean = {}
	for mod_name, mod_def in pairs(param_mods) do
		clean[mod_name] = {}
		for key, value in pairs(mod_def) do
			if key ~= &quot;restrict&quot; then
				clean[mod_name][key] = value
			end
		end
	end
	return clean
end

function EtymonParser.check_modifier_restrictions(modifiers, current_keyword, param_mods)
	for mod_name, mod_value in pairs(modifiers) do
		-- Only check restrictions if the modifier has a non-false/nil value
		if mod_value then
			local mod_def = param_mods[mod_name]
			if mod_def and mod_def.restrict and mod_def.restrict.keywords then
				local allowed_keywords = mod_def.restrict.keywords
				local is_allowed = false
				for _, allowed_keyword in ipairs(allowed_keywords) do
					if current_keyword == allowed_keyword then
						is_allowed = true
						break
					end
				end
				if not is_allowed then
					local keyword_list = {}
					for _, kw in ipairs(allowed_keywords) do
						table.insert(keyword_list, &quot;:&quot; .. kw)
					end
					local keyword_str = table.concat(keyword_list, #keyword_list == 2 and &quot; or &quot; or &quot;, &quot;)
					if #keyword_list &gt; 2 then
						-- Replace last comma with &quot;or&quot;
						keyword_str = keyword_str:gsub(&quot;, ([^,]+)$&quot;, &quot; or %1&quot;)
					end
					local mod_display = mod_value == true and &quot;&lt;&quot; .. mod_name .. &quot;&gt;&quot; or &quot;&lt;&quot; .. mod_name .. &quot;:&quot; .. tostring(mod_value) .. &quot;&gt;&quot;
					error(&quot;The modifier `&quot; .. mod_display .. &quot;` is only allowed for the keyword&quot; .. (#keyword_list &gt; 1 and &quot;s &quot; or &quot; &quot;) .. keyword_str .. &quot;.&quot;)
				end
			end
		end
	end
end

-- Parse keyword with modifiers (e.g., &quot;:bor&lt;unc&gt;&quot; or &quot;:bor&lt;ref:{{R:example}}&gt;&quot;)
function EtymonParser.parse_keyword_modifiers(param)
	if type(param) ~= &quot;string&quot; then return nil, {} end

	local base_keyword = get_keyword_base(param)
	if not base_keyword then return nil, {} end

	local canonical_keyword = get_canonical_keyword(base_keyword)

	-- Check if there are any modifiers
	if not param:find(&quot;&lt;&quot;, 1, true) then
		return canonical_keyword, {}
	end

	-- Parse modifiers using the same mechanism as etymon parsing
	local rest_with_defaults = Util.add_boolean_defaults(param, EtymonParser.keyword_param_mods)

	local function generate_obj(ignored)
		return {}
	end

	local parsed = M.parse_utilities.parse_inline_modifiers(rest_with_defaults:gsub(&quot;^:?[^&lt;]+&quot;, &quot;&quot;),
		{ param_mods = get_clean_param_mods(EtymonParser.keyword_param_mods), generate_obj = generate_obj })

	local modifiers = {
		unc = parsed.unc or false,
		ref = parsed.ref,
		text = parsed.text,
		lit = parsed.lit,
		conj = parsed.conj,
		g = parsed.g,
	}

	-- Validate modifiers against restrictions
	EtymonParser.check_modifier_restrictions(modifiers, canonical_keyword, EtymonParser.keyword_param_mods)

	return canonical_keyword, modifiers
end

function EtymonParser.parse_balanced_segments(str)
	local segments = {}
	local current = &quot;&quot;
	local depth = 0
	local i = 1

	while i &lt;= #str do
		local char = str:sub(i, i)

		if char == &quot;&lt;&quot; then
			if depth == 0 and current ~= &quot;&quot; then
				table.insert(segments, current)
				current = &quot;&quot;
			end
			depth = depth + 1
			current = current .. char
		elseif char == &quot;&gt;&quot; then
			current = current .. char
			depth = depth - 1
			if depth == 0 then
				table.insert(segments, current)
				current = &quot;&quot;
			elseif depth &lt; 0 then
				error(&quot;Unbalanced brackets in etymon: unexpected '&gt;'&quot;)
			end
		else
			current = current .. char
		end

		i = i + 1
	end

	if depth ~= 0 then
		error(&quot;Unbalanced brackets in etymon: missing '&gt;'&quot;)
	end

	if current ~= &quot;&quot; then
		table.insert(segments, current)
	end

	return segments
end

function EtymonParser.parse_inline_ety(ety_string, context_lang)
	local segments = EtymonParser.parse_balanced_segments(ety_string)

	if #segments == 0 then
		error(&quot;Empty inline etymology&quot;)
	end

	local keyword = M.string_utilities.trim(segments[1])

	if not is_keyword(keyword, true) then
		error(&quot;Invalid keyword '&quot; .. keyword .. &quot;' in inline etymology &lt;ety:&quot; .. keyword .. &quot;...&gt;&quot;)
	end

	local args = { context_lang:getCode(), normalize_keyword(get_canonical_keyword(keyword)) }

	for i = 2, #segments do
		local segment = segments[i]
		if segment:sub(1, 1) == &quot;&lt;&quot; and segment:sub(-1) == &quot;&gt;&quot; then
			local inner = segment:sub(2, -2)
			if inner ~= &quot;&quot; then
				table.insert(args, inner)
			end
		elseif is_keyword(segment, true) then
			-- Handle keywords that appear between bracketed segments
			table.insert(args, normalize_keyword(get_canonical_keyword(get_keyword(segment, true))))
		end
	end

	return args
end

function EtymonParser.parse_etymon(param, context_lang)
	if is_keyword(param) then
		return nil
	end

	if type(param) ~= &quot;string&quot; then
		return nil
	end

	local lang, rest
	local is_family = false

	local before_bracket = param:match(&quot;^([^&lt;]*)&quot;) or param
	local lang_code, rest_match = before_bracket:match(&quot;^([a-zA-Z][a-zA-Z0-9._-]*):(.*)$&quot;)

	if lang_code then
		local potential_lang = Util.get_lang(lang_code, true)
		if potential_lang then
			lang = potential_lang
			rest = param:sub(#lang_code + 2)
		else
			local potential_family = Util.get_family(lang_code)
			if potential_family then
				lang = potential_family
				rest = param:sub(#lang_code + 2)
				is_family = true
			else
				lang = context_lang
				rest = param
			end
		end
	else
		lang = context_lang
		rest = param
	end

	if rest == &quot;&quot; then
		M.track(&quot;etymon/term/empty&quot;)
	elseif rest == &quot;?&quot; then
		M.track(&quot;etymon/term/question-mark&quot;)
	elseif rest == &quot;-&quot; then
		M.track(&quot;etymon/term/hyphen&quot;)
	end

	if rest == &quot;&quot; then
		return {
			lang = lang,
			term = nil,
			unknown_term = true,
			is_family = is_family,
		}
	end

	if rest == &quot;-&quot; then
		return {
			lang = lang,
			term = nil,
			suppress_term = true,
			is_family = is_family,
		}
	end

	if not rest:find(&quot;&lt;&quot;, 1, true) then
		return {
			lang = lang,
			term = M.string_utilities.trim(rest),
			is_family = is_family,
		}
	end

	local term_text = rest:match(&quot;^([^&lt;]*)&quot;) or &quot;&quot;
	local is_unknown = (term_text == &quot;&quot;)
	local is_suppress = (term_text == &quot;-&quot;)

	local function generate_obj(ignored_term)
		return { term = (is_unknown or is_suppress) and nil or M.string_utilities.trim(term_text) }
	end

	local rest_with_defaults = Util.add_boolean_defaults(rest, EtymonParser.etymon_param_mods)

	local parsed_obj = M.parse_utilities.parse_inline_modifiers(rest_with_defaults,
		{ param_mods = get_clean_param_mods(EtymonParser.etymon_param_mods), generate_obj = generate_obj })

	if parsed_obj.id and parsed_obj.id:match(&quot;^!&quot;) then
		parsed_obj.id = parsed_obj.id:sub(2)
		parsed_obj.override = true
	end

	parsed_obj.lang = lang
	parsed_obj.is_family = is_family
	if is_unknown then
		parsed_obj.unknown_term = true
	elseif is_suppress then
		parsed_obj.suppress_term = true
	end

	return parsed_obj
end

function EtymonParser.validate(lang, args, id, title, pos, starts_with_lang_code)
	-- id is now optional, so only validate if provided
	if id then
		if mw.ustring.len(id) &lt; 2 then
			error(&quot;The `id` parameter must have at least two characters.&quot;)
		end
		if id == title or id == Util.get_page_data().pagename then
			error(&quot;The `id` parameter must not be the same as the page title.&quot;)
		end
	end

	local valid_pos = { prefix = true, suffix = true, interfix = true, infix = true, root = true, word = true }
	if pos and not valid_pos[pos] then
		error(&quot;Unknown value provided for `pos`. Valid values: &quot; .. table.concat(require(&quot;Module:table&quot;).keysToList(valid_pos), &quot;, &quot;) .. &quot;.&quot;)
	end

	local current_keyword = &quot;from&quot;
	local etymons_in_group = {}
	local keywords = M.data.keywords

	local function checkGroup()
		if keywords[current_keyword] and keywords[current_keyword].is_group and current_keyword ~= &quot;affix&quot; and current_keyword ~= &quot;surf&quot; and current_keyword ~= &quot;afeq&quot; and current_keyword ~= &quot;univerbation&quot; and #etymons_in_group &lt;= 1 then
			error(&quot;Detected `:&quot; .. current_keyword .. &quot;` group with fewer than two etymons.&quot;)
		end
		etymons_in_group = {}
	end

	local start_index = starts_with_lang_code and 2 or 1

	for i = start_index, #args do
		local param = args[i]

		if type(param) ~= &quot;string&quot; then
		elseif param:sub(1, 1) == &quot;:&quot; and not is_keyword(param) then
			error(&quot;Invalid keyword '&quot; .. param .. &quot;'. Did you mean a valid keyword like ':bor', ':inh', etc.?&quot;)
		elseif is_keyword(param) then
			checkGroup()
			current_keyword = get_canonical_keyword(get_keyword(param))
		else
			local etymon_data = EtymonParser.parse_etymon(param, lang)
			if etymon_data then
				table.insert(etymons_in_group, param)
				local param_lang = etymon_data.lang

				if etymon_data.is_family and current_keyword == &quot;inherited&quot; then
					error(&quot;`:inh` does not support family codes; use a specific language.&quot;)
				end
				if etymon_data.is_family and not etymon_data.suppress_term then
					error(&quot;Family codes require suppressed term (use family:-).&quot;)
				end
				if current_keyword == &quot;from&quot; and param_lang:getFullCode() ~= lang:getFullCode() then
					error(&quot;`:from` is for same-language derivation, but language does not match. &quot; ..
						&quot;Expected '&quot; .. lang:getFullCode() .. &quot;', got '&quot; .. param_lang:getFullCode() .. &quot;'.&quot;)
				elseif current_keyword == &quot;inherited&quot; then
					M.etymology.check_ancestor(lang, param_lang)
				end

				-- Check modifier restrictions
				EtymonParser.check_modifier_restrictions(etymon_data, current_keyword, EtymonParser.etymon_param_mods)

				-- postype must be &quot;root&quot; or &quot;word&quot;
				local VALID_POSTYPES = { root = true, word = true }
				if etymon_data.postype and not VALID_POSTYPES[etymon_data.postype] then
					error(&quot;Invalid &lt;postype:&quot; .. etymon_data.postype .. &quot;&gt;; must be \&quot;root\&quot; or \&quot;word\&quot;.&quot;)
				end

				if etymon_data.ety then
					local inline_args = EtymonParser.parse_inline_ety(etymon_data.ety, etymon_data.lang)
					EtymonParser.validate(etymon_data.lang, inline_args, nil, nil, nil, true)
				end
			else
				table.insert(etymons_in_group, param)
			end
		end
	end

	checkGroup()
end

local DataRetriever = {}

-- Given an etymon data, scrape its page and cache the result in the global state object.
function DataRetriever.cache_page_etymons(etymon_page, etymon_title, key, etymon_lang, etymon_id, redirected_from, descendants_is_toplevel)
	local content = etymon_title:getContent()
	if not content then
		__state.cached_etymon_args[key] = M.data.STATUS.REDLINK
		return
	end

	-- Check if the linked page is a redirect. If it is, the template parsing
	-- code below will be effectively skipped, and `scrape_page` will be called
	-- again on the redirect target (see the bottom of this function)
	local lang_section_for_descendants = nil
	local redirect_target = etymon_title.redirect_target
	if not redirect_target then
		content = M.pages.get_section(content, etymon_lang:getFullName(), 2)
		if not content then
			__state.cached_etymon_args[key] = M.data.STATUS.MISSING
			return
		end
		lang_section_for_descendants = content
	end

	local etymon_lang_code = etymon_lang:getFullCode()
	local lang_page_key = etymon_lang_code .. &quot;:&quot; .. etymon_page
	local found_templates_for_lang = {}
	local found_ids = {}
	local get_node_class = M.template_parser.class_else_type

	-- Look for all {{etymon}} templates within the page content using the template parser
	-- This way the same page is never parsed more than once

	-- Build a map from senseids to their parent etymonids.
	local active_etymon_args = nil

	for node in M.template_parser.parse(content):iterate_nodes() do
		local node_class = get_node_class(node)

		if node_class == &quot;heading&quot; then
			-- A new L2 or etymology section acts as a barrier: an {{etymon}} usage
			-- used previously cannot be the parent of any subsequent senseids.
			-- Note that we don't have to check for L2s due to the usage of `M.pages.get_section` above.
			if node:get_name():find(&quot;^Etymology&quot;) then
				active_etymon_args = nil
			end
		elseif node_class == &quot;template&quot; then
			local template_name = node:get_name()

			if template_name == &quot;etymon&quot; then
				local template_args = node:get_arguments()

				-- Check if this etymon is for our language
				if template_args[1] == etymon_lang_code then
					table.insert(found_templates_for_lang, template_args)

					if template_args.id then
						local etymon_key = lang_page_key .. &quot;:&quot; .. template_args.id
						__state.cached_etymon_args[etymon_key] = template_args
						__state.cached_etymon_pages[etymon_key] = tostring(etymon_page)
						table.insert(found_ids, template_args.id)
						active_etymon_args = template_args
					else
						-- Store idless etymon with default key
						local etymon_key = lang_page_key .. &quot;:*&quot;
						__state.cached_etymon_args[etymon_key] = template_args
						__state.cached_etymon_pages[etymon_key] = tostring(etymon_page)
						table.insert(found_ids, &quot;*&quot;)
						active_etymon_args = template_args
					end
				end
			elseif active_etymon_args and template_name == &quot;senseid&quot; then
				local template_args = node:get_arguments()

				-- This should always be true for proper usages of {{senseid}}.
				if template_args[1] == etymon_lang_code and template_args[2] then
					local sense_id_key = lang_page_key .. &quot;:&quot; .. template_args[2]
					__state.senseid_parent_etymon[sense_id_key] = active_etymon_args
					__state.cached_etymon_pages[sense_id_key] = tostring(etymon_page)
				end
			end
		end
	end

	if descendants_is_toplevel and lang_section_for_descendants and #found_templates_for_lang &gt; 0 then
		M.descendants.cache_page_checks({
			lang_section = lang_section_for_descendants,
			etymon_lang_code = etymon_lang_code,
			found_templates_for_lang = found_templates_for_lang,
			entry_title = __state.entry_title,
			entry_lang_code = __state.entry_lang_code,
			entry_lang = __state.entry_lang_code and Util.get_lang(__state.entry_lang_code, true) or nil,
			cached_descendants_checks = __state.cached_descendants_checks,
			lang_page_key = lang_page_key,
			redirected_from = redirected_from,
		})
	end

	local id_data_list = {}
	for _, args in ipairs(found_templates_for_lang) do
		local id = args.id or &quot;*&quot;
		table.insert(id_data_list, { id = id, pos = args.pos })
	end
	__state.available_etymon_ids[lang_page_key] = id_data_list

	if #found_templates_for_lang == 1 then
		__state.single_etymons[lang_page_key] = found_templates_for_lang[1]
	end

	if redirected_from and __state.available_etymon_ids[lang_page_key] then
		__state.available_etymon_ids[redirected_from] = __state.available_etymon_ids[redirected_from] or {}
		for _, id_data in ipairs(__state.available_etymon_ids[lang_page_key]) do
			table.insert(__state.available_etymon_ids[redirected_from], id_data)
		end
	end

	if __state.cached_etymon_args[key] ~= nil or __state.senseid_parent_etymon[key] ~= nil then
		-- All done!
		return
	elseif redirect_target and not redirected_from then
		-- Try scraping the redirect.
		etymon_page = redirect_target.prefixedText
		DataRetriever.cache_page_etymons(etymon_page, redirect_target, lang_page_key .. &quot;:&quot; .. etymon_id, etymon_lang, etymon_id, lang_page_key, descendants_is_toplevel)
		__state.cached_etymon_args[key] = __state.cached_etymon_args[etymon_lang_code .. &quot;:&quot; .. etymon_page .. &quot;:&quot; .. etymon_id]
	else
		__state.cached_etymon_args[key] = M.data.STATUS.MISSING
	end
end

-- Given an etymon object, scrape its page (if necessary) and return its own etymon arguments as well as the page name.
function DataRetriever.get_etymon_args(etymon_data, is_toplevel)
	local page = M.links.get_link_page(etymon_data.term, etymon_data.lang)
	local norm_lang = Util.get_norm_lang(etymon_data.lang)
	local base_key = norm_lang:getFullCode() .. &quot;:&quot; .. page

	if etymon_data.id then
		local key = base_key .. &quot;:&quot; .. etymon_data.id

		local cached_args = __state.cached_etymon_args[key] or __state.senseid_parent_etymon[key]
		if cached_args == nil then
			local title = mw.title.new(page)
			if not title then error('Invalid page title &quot;' .. page .. '&quot; encountered.') end
			DataRetriever.cache_page_etymons(page, title, key, norm_lang, etymon_data.id, nil, is_toplevel)
		end
		cached_args = __state.cached_etymon_args[key] or __state.senseid_parent_etymon[key] -- refresh

		-- Get etymon_id from parent if this was resolved via senseid
		local parent_etymon = __state.senseid_parent_etymon[key]
		local resolved_etymon_id = parent_etymon and parent_etymon.id
		local descendants_check = M.descendants.get_lookup_check({
			cached_descendants_checks = __state.cached_descendants_checks,
			is_toplevel = is_toplevel,
			base_key = base_key,
			lookup = {
				explicit_id = etymon_data.id,
				parent_etymon = parent_etymon,
			},
		})
		if is_toplevel and descendants_check == nil then
			local title = mw.title.new(page)
			if title then
				DataRetriever.cache_page_etymons(page, title, key, norm_lang, etymon_data.id, nil, true)
				descendants_check = M.descendants.get_lookup_check({
					cached_descendants_checks = __state.cached_descendants_checks,
					is_toplevel = true,
					base_key = base_key,
					lookup = {
						explicit_id = etymon_data.id,
						parent_etymon = parent_etymon,
					},
				})
			end
		end
		return cached_args, __state.cached_etymon_pages[key], resolved_etymon_id, descendants_check
	else
		__state.used_idless_etymon = true
		if is_toplevel then
			__state.toplevel_idless_etymon = true
		end

		if __state.available_etymon_ids[base_key] == nil then
			local title = mw.title.new(page)
			if not title then error('Invalid page title &quot;' .. page .. '&quot; encountered.') end
			DataRetriever.cache_page_etymons(page, title, base_key .. &quot;:*&quot;, norm_lang, &quot;*&quot;, nil, is_toplevel)
		end

		local ids = __state.available_etymon_ids[base_key] or {}
		local count = #ids

		-- Try to filter by postype if available and we have multiple candidates
		if count &gt; 1 and etymon_data.postype then
			local matching_ids = {}
			for _, id_data in ipairs(ids) do
				if id_data.pos == etymon_data.postype then
					table.insert(matching_ids, id_data)
				end
			end
			
			if #matching_ids == 1 then
				local matched_id = matching_ids[1].id
				local matched_key = base_key .. &quot;:&quot; .. matched_id
				local descendants_check = M.descendants.get_lookup_check({
					cached_descendants_checks = __state.cached_descendants_checks,
					is_toplevel = is_toplevel,
					base_key = base_key,
					lookup = { id = matched_id },
				})
				if is_toplevel and descendants_check == nil then
					local title = mw.title.new(page)
					if title then
						DataRetriever.cache_page_etymons(page, title, base_key .. &quot;:*&quot;, norm_lang, &quot;*&quot;, nil, true)
						descendants_check = M.descendants.get_lookup_check({
							cached_descendants_checks = __state.cached_descendants_checks,
							is_toplevel = true,
							base_key = base_key,
							lookup = { id = matched_id },
						})
					end
				end
				return __state.cached_etymon_args[matched_key], __state.cached_etymon_pages[matched_key], nil, descendants_check
			end
		end

		if count == 1 then
			local only_id_data = ids[1]
			local only_id = (type(only_id_data) == &quot;table&quot; and only_id_data.id) or only_id_data or &quot;*&quot;
			local descendants_check = M.descendants.get_lookup_check({
				cached_descendants_checks = __state.cached_descendants_checks,
				is_toplevel = is_toplevel,
				base_key = base_key,
				lookup = { id_data = only_id_data },
			})
			if is_toplevel and descendants_check == nil then
				local title = mw.title.new(page)
				if title then
					DataRetriever.cache_page_etymons(page, title, base_key .. &quot;:*&quot;, norm_lang, &quot;*&quot;, nil, true)
					descendants_check = M.descendants.get_lookup_check({
						cached_descendants_checks = __state.cached_descendants_checks,
						is_toplevel = true,
						base_key = base_key,
						lookup = { id_data = only_id_data },
					})
				end
			end
			return __state.single_etymons[base_key], __state.cached_etymon_pages[base_key .. &quot;:&quot; .. only_id], nil, descendants_check
		elseif count &gt; 1 then
			local page_link = M.links.full_link({
				term = page,
				lang = norm_lang,
				no_generate_forms = true,
			}, &quot;term&quot;)

			local function format_id_hint(id_data, idx)
				local id = type(id_data) == &quot;table&quot; and id_data.id or id_data
				local pos = type(id_data) == &quot;table&quot; and id_data.pos
				if id and id ~= &quot;&quot; and id ~= &quot;*&quot; then
					return '&quot;' .. id .. '&quot;'
				end
				if pos and pos ~= &quot;&quot; then
					return &quot;unnamed (|pos=&quot; .. pos .. &quot;|)&quot;
				end
				return &quot;etymon #&quot; .. idx .. &quot; (no |id= on page)&quot;
			end

			local id_list = {}
			local all_idless = true
			local target_has_idless = false
			for i, id_data in ipairs(ids) do
				local id = type(id_data) == &quot;table&quot; and id_data.id or id_data
				if id and id ~= &quot;&quot; and id ~= &quot;*&quot; then
					all_idless = false
				else
					target_has_idless = true
				end
				table.insert(id_list, format_id_hint(id_data, i))
			end

			if is_toplevel and target_has_idless then
				__state.linked_page_multiple_etymons_idless = true
			end

			local any_pos = false
			for _, id_data in ipairs(ids) do
				local pos = type(id_data) == &quot;table&quot; and id_data.pos
				if pos and pos ~= &quot;&quot; then
					any_pos = true
					break
				end
			end

			local suggestion_text
			local lead = &quot;Etymology link to &quot; .. page_link .. &quot; is ambiguous (&quot; .. count .. &quot; {{etymon}} templates for &quot;
				.. norm_lang:getCanonicalName() .. &quot;).&quot;
			if all_idless then
				if any_pos then
					suggestion_text = &quot; None set `|id=` yet; add a unique `|id=` to each on &quot; .. page_link
						.. &quot;, then `&lt;id:identifier&gt;` after the term here. Section order / hints: &quot;
						.. mw.text.listToText(id_list) .. &quot;.&quot;
				else
					suggestion_text = &quot; None set `|id=` yet; add a unique `|id=` to each {{etymon}} in that section from top to bottom, then `&lt;id:identifier&gt;` after the term here (same value as `|id=`).&quot;
				end
			else
				suggestion_text = &quot; Specify which one with `&lt;id:identifier&gt;` after the term. Options: &quot; .. mw.text.listToText(id_list) .. &quot;.&quot;
			end

			Util.add_warning(lead .. suggestion_text, true)

			return M.data.STATUS.AMBIGUOUS, nil, nil, nil
		else
			return M.data.STATUS.MISSING, nil, nil, nil
		end
	end
end

local TreeBuilder = {}

local function parse_etymon_references(refs_text)
	if not refs_text or refs_text == &quot;&quot; then
		return &quot;&quot;
	end
	return M.references.parse_references(refs_text)
end

local function parse_tree_references(node)
	if node.ref then
		node.parsed_ref = parse_etymon_references(node.ref)
	end

	if node.children then
		for _, container in ipairs(node.children) do
			if container.terms then
				for _, term in ipairs(container.terms) do
					parse_tree_references(term)
				end
			end
		end
	end
end

-- Build a unique key for deduplication in the seen table
function TreeBuilder.build_key(lang, title, args)
	local norm_lang_code = Util.get_norm_lang(lang):getFullCode()
	local is_table = type(args) == &quot;table&quot;
	local id = (is_table and args.id) or &quot;&quot;
	
	if title then
		return norm_lang_code .. &quot;:&quot; .. M.links.get_link_page(title, lang) .. &quot;:&quot; .. id
	end
	
	if is_table and args.status == M.data.STATUS.INLINE then
		local content_parts = {}
		for i = 1, #args do
			content_parts[i] = tostring(args[i])
		end
		return norm_lang_code .. &quot;:*:&quot; .. id .. &quot;\0&quot; .. table.concat(content_parts, &quot;\0&quot;)
	end
	
	return norm_lang_code .. &quot;:*:&quot; .. id
end

function TreeBuilder.build(lang, title, args, seen, depth, stop_recursion)
	seen = seen or {}
	depth = depth or 0
	local is_toplevel = (depth == 0)

	if depth &gt; __state.max_depth_reached then
		__state.max_depth_reached = depth
	end

	__state.total_nodes = __state.total_nodes + 1

	local lang_code = lang:getCode()
	__state.language_count[lang_code] = (__state.language_count[lang_code] or 0) + 1

	local current_id = (type(args) == &quot;table&quot; and args.id) or &quot;&quot;
	local key = TreeBuilder.build_key(lang, title, args)
	
	local node = { lang = lang, title = title, id = current_id, args = args, children = {}, status = M.data.STATUS.OK }

	if type(args) ~= &quot;table&quot; or seen[key] then
		node.status = args or M.data.STATUS.MISSING
		-- Mark as duplicate if we've seen this node before
		if seen[key] then
			node.is_duplicate = true
			node.duplicate_key = key
			local original_node = seen[key]
			if type(original_node) == &quot;table&quot; and original_node.children and #original_node.children &gt; 0 then
				node.original_has_children = true
			end
		end
		return node
	end

	node.status = args.status or M.data.STATUS.OK

	seen[key] = node

	-- If stop_recursion is set, skip parsing children but check for visible children
	if stop_recursion then
		local keywords = M.data.keywords
		local has_visible_children = false
		for i = 2, #args do
			local param = args[i]
			if type(param) == &quot;string&quot; then
				local keyword_base = get_keyword_base(param)
				if keyword_base and keywords[keyword_base] then
					-- It's a keyword, check if visible in tree (invisible &quot;all&quot; or &quot;tree&quot; = hidden in tree)
					local keyword_info = keywords[keyword_base]
					local inv = keyword_info.invisible
					if not (inv == &quot;all&quot; or inv == true or inv == &quot;tree&quot;) then
						has_visible_children = true
						break
					end
				elseif param:sub(1, 1) ~= &quot;:&quot; then
					-- It's a term (not a keyword), so there are visible children
					has_visible_children = true
					break
				end
			end
		end
		node.has_visible_children = has_visible_children
		return node
	end

	-- Parse args into keyword containers
	local current_keyword = &quot;from&quot;
	local current_keyword_modifiers = {}
	local current_container = nil

	-- Helper to track keyword usage at top level
	local function track_keyword_usage(keyword, target_lang, source_lang)
		if not is_toplevel then return end

		if not __state.toplevel_keyword_stats[keyword] then
			__state.toplevel_keyword_stats[keyword] = {
				count = 0,
				target_langs = {},
				source_langs = {},
			}
		end

		local keyword_data = __state.toplevel_keyword_stats[keyword]
		keyword_data.count = keyword_data.count + 1

		local target_code = target_lang:getCode()
		keyword_data.target_langs[target_code] = (keyword_data.target_langs[target_code] or 0) + 1

		if source_lang then
			local source_code = source_lang:getCode()
			keyword_data.source_langs[source_code] = (keyword_data.source_langs[source_code] or 0) + 1
		end
	end

	local function ensure_container()
		if not current_container or current_container.keyword ~= current_keyword then
			current_container = {
				keyword = current_keyword,
				keyword_info = M.data.keywords[current_keyword],
				keyword_modifiers = current_keyword_modifiers,
				terms = {},
			}
			table.insert(node.children, current_container)
			-- Override keyword text/phrase for nominalization with &lt;g:code&gt;
			if current_keyword_modifiers.g and current_keyword == &quot;nominalization&quot; then
				local labels = get_nominalization_label_for_g(current_keyword_modifiers.g)
				if not labels then
					local codes = {}
					for c in pairs(M.data.nominalization_g_codes) do table.insert(codes, c) end
					table.sort(codes)
					error(&quot;Invalid &lt;g:&quot; .. tostring(current_keyword_modifiers.g) .. &quot;&gt;. Supported codes for nominalization: &quot; .. table.concat(codes, &quot;, &quot;))
				end
				current_container.keyword_info = {}
				for k, v in pairs(M.data.keywords[current_keyword]) do current_container.keyword_info[k] = v end
				current_container.keyword_info.text = labels.text
				current_container.keyword_info.phrase = labels.phrase
			end
		end
	end

	for i = 2, #args do
		local param = args[i]

		if is_keyword(param) then
			local keyword, modifiers = EtymonParser.parse_keyword_modifiers(param)
			current_keyword = keyword
			current_keyword_modifiers = modifiers
			current_container = nil -- Force new container for new keyword
		elseif type(param) == &quot;string&quot; and param:sub(1, 1) == &quot;:&quot; then
			error(&quot;Invalid keyword '&quot; .. param .. &quot;'. Did you mean a valid keyword like ':bor', ':inh', etc.?&quot;)
		elseif type(param) == &quot;string&quot; then
			local etymon_data = EtymonParser.parse_etymon(param, lang)

			if etymon_data then
				-- Track keyword usage at top level
				track_keyword_usage(current_keyword, lang, etymon_data.lang)

				local term_node = {}

				-- Handle suppress_term (-) and unknown_term (empty) directly
				if etymon_data.suppress_term or etymon_data.unknown_term then
					ensure_container()
					if etymon_data.ety then
						local inline_args = EtymonParser.parse_inline_ety(etymon_data.ety, etymon_data.lang)
						inline_args.id = etymon_data.id
						inline_args.status = M.data.STATUS.INLINE
						term_node = TreeBuilder.build(etymon_data.lang, nil, inline_args, seen, depth + 1)
					else
						term_node = {
							lang = etymon_data.lang,
							children = {},
							status = M.data.STATUS.OK,
						}
					end
					term_node.suppress_term = etymon_data.suppress_term
					term_node.unknown_term = etymon_data.unknown_term
					term_node.is_family = etymon_data.is_family
					term_node.is_uncertain = etymon_data.unc
					term_node.ref = etymon_data.ref
					term_node.t = etymon_data.t
					term_node.tr = etymon_data.tr
					term_node.ts = etymon_data.ts
					term_node.alt = etymon_data.alt
					term_node.g = etymon_data.g
					term_node.pos = etymon_data.pos
					term_node.ng = etymon_data.ng
					term_node.lit = etymon_data.lit
					term_node.q = etymon_data.q
					term_node.qq = etymon_data.qq
					term_node.l = etymon_data.l
					term_node.ll = etymon_data.ll
				else
					-- Regular term: fetch arguments from page
					local etymon_args, page_of, resolved_etymon_id, descendants_check = DataRetriever.get_etymon_args(etymon_data, is_toplevel)

					if etymon_data.id and etymon_args == M.data.STATUS.MISSING and not etymon_data.ety then
						local page = M.links.get_link_page(etymon_data.term, etymon_data.lang)
						local norm_lang = Util.get_norm_lang(etymon_data.lang)
						local base_key = norm_lang:getFullCode() .. &quot;:&quot; .. page
						local available_ids = __state.available_etymon_ids[base_key] or {}

						if #available_ids &gt; 0 then
							__state.has_mismatched_id = true
						end
					end

					-- Check for &lt;ety&gt; inline parameter doesn't override the scraped arguments, unless the latter are missing
					if etymon_data.ety then
						if etymon_args == M.data.STATUS.REDLINK or etymon_args == M.data.STATUS.MISSING then
							__state.current_page_has_inline_etymology = true
							if is_toplevel then
								__state.toplevel_has_inline_etymology = true
							end

							local inline_args = EtymonParser.parse_inline_ety(etymon_data.ety, etymon_data.lang)

							-- Track inline ety keywords too
							local inline_keyword = get_keyword(inline_args[2], true)
							if inline_keyword and #inline_args &gt;= 3 then
								local inline_etymon = EtymonParser.parse_etymon(inline_args[3], etymon_data.lang)
								if inline_etymon then
									track_keyword_usage(inline_keyword, etymon_data.lang, inline_etymon.lang)
								end
							end

							inline_args.id = etymon_data.id
							inline_args.status = M.data.STATUS.INLINE
							etymon_args = inline_args
							term_node.page_of = __state.cached_etymon_pages[key] -- term node is on the same page as the parent
						else
							-- Scraped arguments exist, &lt;ety&gt; is redundant and ignored
							__state.current_page_has_redundant_etymology = true
							if is_toplevel then
								__state.toplevel_redundant_etymology = true
							end
						end
					end

					-- Ensure container exists before checking keyword info
					ensure_container()
					
					-- Check if current keyword has no_child_categories - if so, stop recursion
					local keyword_info = current_container.keyword_info
					local should_stop_recursion = (stop_recursion or (keyword_info and keyword_info.no_child_categories))
					
					term_node = TreeBuilder.build(etymon_data.lang, etymon_data.term, etymon_args, seen, depth + 1, should_stop_recursion)
					term_node.target_key = Util.get_norm_lang(etymon_data.lang):getFullCode() ..
						&quot;:&quot; .. M.links.get_link_page(etymon_data.term, etymon_data.lang)
					term_node.id = etymon_data.id
					term_node.etymon_id = resolved_etymon_id  -- The actual etymon id when resolved via senseid
					term_node.t = etymon_data.t
					term_node.tr = etymon_data.tr
					term_node.ts = etymon_data.ts
					term_node.pos = etymon_data.pos
					term_node.alt = etymon_data.alt
					term_node.g = etymon_data.g
					term_node.ng = etymon_data.ng
					term_node.ref = etymon_data.ref
					term_node.is_uncertain = etymon_data.unc
					term_node.override = etymon_data.override
					term_node.page_of = page_of
					term_node.aftype = etymon_data.aftype
					term_node.postype = etymon_data.postype
					term_node.bor = etymon_data.bor
					term_node.lbor = etymon_data.lbor
					term_node.slbor = etymon_data.slbor
					term_node.lit = etymon_data.lit
					term_node.is_family = etymon_data.is_family
					term_node.q = etymon_data.q
					term_node.qq = etymon_data.qq
					term_node.l = etymon_data.l
					term_node.ll = etymon_data.ll
					term_node.missing_descendants_header, term_node.missing_descendants_entry =
						M.descendants.get_term_sync_flags(current_keyword, term_node.status, descendants_check)
				end

				table.insert(current_container.terms, term_node)
			end
		end
	end

	return node
end

-- Convert etymology tree to JSON-serializable table
local function tree_to_json(node)
	local obj = {
		term = node.title,
		lang = node.lang:getCode(),
		lang_name = node.lang:getCanonicalName(),
		id = (node.id and node.id ~= &quot;&quot;) and node.id or nil,
		status = node.status,
		is_uncertain = node.is_uncertain or nil,
		is_duplicate = node.is_duplicate or nil,
		gloss = node.t,
		transliteration = node.tr,
		transcription = node.ts,
		alt = node.alt,
		g = node.g,
		pos = node.pos,
		ng = node.ng,
		children = {},
	}

	for _, container in ipairs(node.children or {}) do
		local keyword_info = container.keyword_info
		if keyword_info then
			local container_obj = {
				keyword = container.keyword,
				keyword_label = keyword_info.text,
				keyword_abbrev = keyword_info.abbrev,
				is_group = keyword_info.is_group or nil,
				is_invisible = keyword_info.invisible or nil,
				is_uncertain = (container.keyword_modifiers and container.keyword_modifiers.unc) or nil,
				terms = {},
			}

			for _, term in ipairs(container.terms or {}) do
				table.insert(container_obj.terms, tree_to_json(term))
			end

			table.insert(obj.children, container_obj)
		end
	end

	return obj
end

local function track_ranges(base_key, value, ranges, lang_code)
	M.track(&quot;etymon/&quot; .. base_key .. &quot;/&quot; .. value)
	if lang_code then
		M.track(&quot;etymon/lang/&quot; .. lang_code .. &quot;/&quot; .. base_key .. &quot;/&quot; .. value)
	end

	for _, range in ipairs(ranges) do
		local matches = false
		if range.min and range.max then
			matches = value &gt;= range.min and value &lt;= range.max
		elseif range.min then
			matches = value &gt;= range.min
		elseif range.max then
			matches = value &lt;= range.max
		elseif range.exact then
			matches = value == range.exact
		end

		if matches then
			M.track(&quot;etymon/&quot; .. base_key .. &quot;/&quot; .. range.label)
			if lang_code then
				M.track(&quot;etymon/lang/&quot; .. lang_code .. &quot;/&quot; .. base_key .. &quot;/&quot; .. range.label)
			end
			break
		end
	end
end

local function track_title_pagename_mismatch_after_strip(lang)
	local lang_code = lang:getCode()
	M.track(&quot;etymon/title/pagename-mismatch-after-strip-diacritics&quot;)
	M.track(&quot;etymon/lang/&quot; .. lang_code .. &quot;/title/pagename-mismatch-after-strip-diacritics&quot;)
end

-- Build and return the etymology data tree for a given term.
function export.get_tree(lang, title, args, options)
	options = options or {}
	__state.entry_title = title
	__state.entry_lang_code = lang:getCode()

	if options.validate then
		EtymonParser.validate(lang, args, options.id, title, options.pos, false)
	end

	local lang_code = lang:getCode()

	local start_index = (args[1] == lang_code) and 2 or 1
	local tree_args = { [1] = lang_code, id = options.id or args.id }
	for i = start_index, #args do
		table.insert(tree_args, args[i])
	end

	__state.cached_etymon_args[lang_code .. &quot;:&quot; .. title .. &quot;:&quot; .. (tree_args.id or &quot;&quot;)] = tree_args

	local ety_data_tree = TreeBuilder.build(lang, title, tree_args)
	parse_tree_references(ety_data_tree)

	if options.json then
		return M.JSON.toJSON(tree_to_json(ety_data_tree))
	end

	return ety_data_tree
end

-- Given a language code, page name and optionally the id= parameter,
-- render the tree and only the etymology tree for the relevant page.
-- Fetches and parses the corresponding {{etymon}} from the requested page,
-- and any further pages needed to render the tree.
-- Parameters can be passed either through the #invoke or as
-- template parameters *through* an #invoke.
function export.render_tree_for_etymon_on_page(frame)
	local frame_args = frame.args
	local parent_args = frame:getParent().args
	local langcode = frame_args[1] or parent_args[1]
	local pagename = frame_args[2] or parent_args[2]
	local id = frame_args[&quot;id&quot;] or parent_args[&quot;id&quot;]
	local display_title = frame_args[&quot;title&quot;] or parent_args[&quot;title&quot;]

	local parsed_title = mw.title.new(pagename, 0)
	local title
	if parsed_title.namespace == 0 then
		title = M.pages.safe_page_name(parsed_title)
	elseif parsed_title.namespace == 118 then
		title = &quot;*&quot; .. M.pages.safe_page_name(parsed_title)
	else
		error(&quot;Unsupported namespace for render_tree_for_etymon_on_page: &quot; .. parsed_title.namespace)
	end

	local lang = Util.get_lang(langcode)
	-- Construct etymon_data for DataRetriever.get_args.
	local etymon_data = {
		lang = lang,
		term = title,
		id = id
	}
	local args, pagename = DataRetriever.get_etymon_args(etymon_data, true)
	if args == M.data.STATUS.MISSING then
		error(&quot;The etymon template was not found (language &quot; ..
			langcode ..
			&quot;, title '&quot; ..
			title ..
			&quot;'&quot; ..
			(id and &quot;, ID '&quot; .. id .. &quot;'&quot; or &quot;, no ID given&quot;) .. &quot;). Page contents may have changed in the interim.&quot;)
	end

	local tree_title = display_title or title
	if lang:stripDiacritics(M.links.remove_links(tree_title)) ~= lang:stripDiacritics(M.links.remove_links(title)) then
		track_title_pagename_mismatch_after_strip(lang)
	end

	local ety_data_tree = export.get_tree(lang, tree_title, args, {
		validate = true,
		id = id,
	})

	local output = {}
	table.insert(output, M.template_styles(&quot;Module:etymon/styles.css&quot;))
	table.insert(output, M.tree.render({
		data_tree = ety_data_tree,
		format_term_func = function(term, is_toplevel)
			return Util.format_term(term, is_toplevel, {
				gloss = &quot;suppress&quot;,
				pos = &quot;suppress&quot;,
				lit = &quot;suppress&quot;,
				tree_ql = &quot;suppress&quot;,
			})
		end,
	}))

	return table.concat(output)
end

function export.main(frame)
	local parent_args = frame:getParent().args
	local args = M.parameters.process(parent_args, M.parameters_data.etymon)
	local lang = args[1]
	local etymon_args = args[2]
	local id = args.id
	local title = args.title
	local text = args.text
	local tree = args.tree
	local etydate = args.etydate
	local rfe = args.rfe
	local page_data = Util.get_page_data()

	if not title then
		title = page_data.pagename
		if page_data.namespace == &quot;Reconstruction&quot; then title = &quot;*&quot; .. title end
	end

	local entry_pagename = page_data.pagename
	if page_data.namespace == &quot;Reconstruction&quot; then
		entry_pagename = &quot;*&quot; .. entry_pagename
	end
	if lang:stripDiacritics(M.links.remove_links(title)) ~= lang:stripDiacritics(M.links.remove_links(entry_pagename)) then
		track_title_pagename_mismatch_after_strip(lang)
	end

	local current_L2 = M.pages.get_current_L2()
	if current_L2 then
		local norm_lang = Util.get_norm_lang(lang)
		local norm_name = norm_lang:getCanonicalName()
		if current_L2 ~= norm_name then
			local lang_desc = lang:getCode() .. &quot; (Bahasa &quot; .. lang:getCanonicalName() .. &quot;)&quot;
			if norm_lang:getCode() ~= lang:getCode() then
				lang_desc = lang_desc .. &quot;, normalized to &quot; .. norm_lang:getCode() .. &quot; (Bahasa &quot; .. norm_name .. &quot;)&quot;
			end
			error(&quot;Language '&quot; .. lang_desc .. &quot;' does not match the L2 header (&quot; .. current_L2 .. &quot;).&quot;)
		end
	end

	local ety_data_tree = export.get_tree(lang, title, etymon_args, {
		validate = true,
		pos = args.pos,
		id = id,
		json = args.json,
	})

	if args.json then
		return ety_data_tree
	end

	local output = {}

	local text_allowlist_mode = M.text_allowed.default_mode or &quot;off&quot;
	if text and text_allowlist_mode ~= &quot;off&quot; and not Util.is_text_param_allowed_for_lang(lang) then
		local msg = &quot;Etymology texts (parameter &lt;code&gt;text=&lt;/code&gt;) are not allowed for &quot; .. lang:getFullName() ..
			&quot;; see [[Template:etymon#Text allowlist|Template:etymon § Text allowlist]] for the list of languages that may use the &lt;code&gt;text=&lt;/code&gt; parameter.&quot;
		if text_allowlist_mode == &quot;error&quot; then
			error(msg)
		else
			Util.add_warning(msg, true)
		end
	end

	local lang_exc = Util.get_lang_exception(lang)
	if lang_exc and lang_exc.disallow then
		local disallow = lang_exc.disallow
		local error_text = &quot; for &quot; .. lang:getFullName()
		if disallow.ref then
			error_text = error_text .. &quot;; see &quot; .. disallow.ref
		else
			error_text = error_text .. &quot;.&quot;
		end
		if tree and disallow.tree then
			error(&quot;Etymology trees are not allowed&quot; .. error_text)
		end
		if text and disallow.text then
			error(&quot;Etymology texts are not allowed&quot; .. error_text)
		end
	end

	if etydate then
		local etydate_param_mods = {
			ref = { list = true, type = &quot;references&quot;, allow_holes = true },
			refn = { list = true, allow_holes = true },
			nocap = { type = &quot;boolean&quot; },
		}

		local function generate_etydate_obj(etydate_text)
			local etydate_specs = {}
			for spec in etydate_text:gmatch(&quot;[^,]+&quot;) do
				table.insert(etydate_specs, mw.text.trim(spec))
			end
			return { [1] = etydate_specs }
		end

		local parsed_etydate = M.parse_utilities.parse_inline_modifiers(etydate, { param_mods = etydate_param_mods, generate_obj = generate_etydate_obj })

		local etydate_args = {
			[1] = parsed_etydate[1],
			nocap = parsed_etydate.nocap or false,
		}

		ety_data_tree.etydate = M.etydate.format_etydate(etydate_args, { omit_refs = true })

		if parsed_etydate.ref and #parsed_etydate.ref &gt; 0 then
			ety_data_tree.etydate_refs = parsed_etydate.ref
		end
	end

	if tree then
		table.insert(output, M.template_styles(&quot;Module:etymon/styles.css&quot;))
		table.insert(output, M.tree.render({
			data_tree = ety_data_tree,
			format_term_func = function(term, is_toplevel)
				return Util.format_term(term, is_toplevel, {
					gloss = &quot;suppress&quot;,
					pos = &quot;suppress&quot;,
					lit = &quot;suppress&quot;,
					tree_ql = &quot;suppress&quot;,
				})
			end,
		}))
	end

	-- Check if there are any visible children in tree (invisible &quot;all&quot; or &quot;tree&quot; = hidden in tree)
	local has_visible_children = false
	for _, child in ipairs(ety_data_tree.children or {}) do
		local child_keyword_info = child.keyword_info
		local inv = child_keyword_info and child_keyword_info.invisible
		if not (inv == &quot;all&quot; or inv == true or inv == &quot;tree&quot;) then
			has_visible_children = true
			break
		end
	end

	local tree_disallowed = lang_exc and lang_exc.disallow and lang_exc.disallow.tree
	local ety_tree_json = M.JSON.toJSON(tree_to_json(ety_data_tree))
	local anchor = M.anchors.etymonid(lang, id, {
		no_tree = args.notree,
		title = title,
		empty_tree = (not has_visible_children) or tree_disallowed,
		ety_tree_json = ety_tree_json,
	})
	table.insert(output, anchor)

	if text then
		local max_depth, stop_at_blue_link, stop_at_lang, stop_at_lang_or_bluelink
		if text == &quot;++&quot; then
			max_depth, stop_at_blue_link = false, false
		elseif text == &quot;+&quot; then
			max_depth, stop_at_blue_link = 1, false
		elseif text == &quot;*&quot; then
			max_depth, stop_at_blue_link = false, true
		elseif text:match(&quot;^:[^*]+%*$&quot;) then
			-- Stop at a specific language OR first bluelink after it, e.g., &quot;:ota*&quot;
			-- If the target language is a redlink, continue to the first bluelink
			local lang_code = text:match(&quot;^:([^*]+)%*$&quot;)
			if lang_code and lang_code ~= &quot;&quot; then
				local lang_obj = Util.get_lang(lang_code, true)
				if lang_obj then
					stop_at_lang_or_bluelink = lang_code
				else
					Util.add_warning('Invalid language code &quot;' .. lang_code .. '&quot; in text parameter. Showing full chain instead.')
					max_depth, stop_at_blue_link = false, false
				end
			else
				Util.add_warning('Empty language code in text parameter. Showing full chain instead.')
				max_depth, stop_at_blue_link = false, false
			end
		elseif text:sub(1, 1) == &quot;:&quot; then
			-- Stop at a specific language, e.g., &quot;:ar&quot; stops at first Arabic term
			local lang_code = text:sub(2)
			if lang_code ~= &quot;&quot; then
				-- Validate the language code
				local lang_obj = Util.get_lang(lang_code, true)
				if lang_obj then
					stop_at_lang = lang_code
				else
					Util.add_warning('Invalid language code &quot;' .. lang_code .. '&quot; in text parameter. Showing full chain instead.')
					max_depth, stop_at_blue_link = false, false -- default to ++
				end
			else
				Util.add_warning('Empty language code in text parameter. Showing full chain instead.')
				max_depth, stop_at_blue_link = false, false -- default to ++
			end
		else
			local num = tonumber(text)
			if num and num &gt;= 1 then
				max_depth, stop_at_blue_link = num, false
			else
				error('Invalid text value &quot;' ..
					text .. '&quot;. Valid values are: &quot;++&quot; (full chain), &quot;+&quot; (first step only), &quot;*&quot; (until first blue link), a number (max steps), &quot;:lang&quot; (stop at language), or &quot;:lang*&quot; (stop at language or first bluelink if redlink)')
			end
		end
		table.insert(output, M.text.render({
			data_tree = ety_data_tree,
			format_term_func = Util.format_term,
			max_depth = max_depth,
			stop_at_blue_link = stop_at_blue_link,
			curr_page = page_data.pagename,
			nodot = args.nodot,
			stop_at_lang = stop_at_lang,
			stop_at_lang_or_bluelink = stop_at_lang_or_bluelink,
		}))
	end

	if rfe then
		local rfe_param_mods = {
			nocat = { type = &quot;boolean&quot; },
			sort = {},
			y = {},
			m = {},
			fragment = {},
			section = {},
			box = { type = &quot;boolean&quot; },
			noes = { type = &quot;boolean&quot; },
		}

		local function generate_rfe_obj(rfe_text)
			-- Check if it's a boolean true value
			if M.yesno(rfe_text, false) then
				return { is_boolean = true }
			else
				return { text = rfe_text }
			end
		end

		local rfe_with_defaults = Util.add_boolean_defaults(rfe, rfe_param_mods)
		local parsed_rfe = M.parse_utilities.parse_inline_modifiers(rfe_with_defaults, { 
			param_mods = rfe_param_mods, 
			generate_obj = generate_rfe_obj 
		})

		local rfe_args = {
			[1] = lang:getCode(),
			nocat = parsed_rfe.nocat,
			sort = parsed_rfe.sort,
			y = parsed_rfe.y,
			m = parsed_rfe.m,
			fragment = parsed_rfe.fragment,
			section = parsed_rfe.section,
			box = parsed_rfe.box,
			noes = parsed_rfe.noes,
		}

		if not parsed_rfe.is_boolean then
			rfe_args[2] = parsed_rfe.text
		end

		table.insert(output, frame:expandTemplate({
			title = &quot;rfe&quot;,
			args = rfe_args
		}))
	end

	if Util.is_content_page() and __state.max_depth_reached &gt; 0 then
		local lang_code = lang:getCode()

		local depth_ranges = {
			{ min = 50, label = &quot;extremely-deep&quot; },
			{ min = 20, label = &quot;20+&quot; },
			{ min = 10, max = 19,                label = &quot;10-19&quot; },
			{ min = 5,  max = 9,                 label = &quot;5-9&quot; },
			{ min = 3,  max = 4,                 label = &quot;3-4&quot; },
			{ max = 2,  label = &quot;1-2&quot; }
		}

		local node_ranges = {
			{ min = 100, label = &quot;extremely-large&quot; },
			{ min = 50,  label = &quot;50+&quot; },
			{ min = 20,  max = 49,                 label = &quot;20-49&quot; },
			{ min = 10,  max = 19,                 label = &quot;10-19&quot; },
			{ min = 5,   max = 9,                  label = &quot;5-9&quot; },
			{ max = 4,   label = &quot;1-4&quot; }
		}

		local language_ranges = {
			{ min = 10,  label = &quot;10+&quot; },
			{ min = 5,   max = 9,      label = &quot;5-9&quot; },
			{ min = 3,   max = 4,      label = &quot;3-4&quot; },
			{ exact = 2, label = &quot;2&quot; },
			{ exact = 1, label = &quot;1&quot; }
		}

		track_ranges(&quot;depth&quot;, __state.max_depth_reached, depth_ranges, lang_code)
		track_ranges(&quot;nodes&quot;, __state.total_nodes, node_ranges, lang_code)

		local unique_languages = 0
		for _ in pairs(__state.language_count) do
			unique_languages = unique_languages + 1
		end
		track_ranges(&quot;unique-languages&quot;, unique_languages, language_ranges, lang_code)

		if __state.total_nodes == __state.max_depth_reached + 1 then
			track_ranges(&quot;linear-depth&quot;, __state.max_depth_reached, depth_ranges, lang_code)
		end
	end

	local categories = {}
	if Util.is_content_page() then
		local should_suppress_categories = lang_exc and lang_exc.suppress_categories
		if not should_suppress_categories and not args.nocat then
			categories = M.categories.render({
				data_tree = ety_data_tree,
				page_lang = lang,
				available_etymon_ids = __state.available_etymon_ids,
				senseid_parent_etymon = __state.senseid_parent_etymon,
				get_norm_lang_func = Util.get_norm_lang,
				lang_exc = lang_exc,
			})
		end

		local target_lang_code = lang:getCode()
		for keyword, keyword_data in pairs(__state.toplevel_keyword_stats) do
			-- Track keyword globally
			M.track(&quot;etymon/keyword/&quot; .. keyword)

			-- Track keyword per target language
			M.track(&quot;etymon/keyword/&quot; .. keyword .. &quot;/target/&quot; .. target_lang_code)

			-- Track keyword per source language
			for source_code, count in pairs(keyword_data.source_langs) do
				M.track(&quot;etymon/keyword/&quot; .. keyword .. &quot;/source/&quot; .. source_code)

				-- Track keyword per target+source combination
				M.track(&quot;etymon/keyword/&quot; .. keyword .. &quot;/target/&quot; .. target_lang_code .. &quot;/source/&quot; .. source_code)
			end
		end

		if tree then
			table.insert(categories, &quot;Pages with etymology trees&quot;)
			table.insert(categories, lang:getCanonicalName() .. &quot; entries with etymology trees&quot;)
		end
		if text then table.insert(categories, lang:getCanonicalName() .. &quot; entries with etymology texts&quot;) end
		if args.exnihilo then table.insert(categories, lang:getCanonicalName() .. &quot; terms coined ex nihilo&quot;) end
		if __state.toplevel_has_inline_etymology then
			table.insert(categories, &quot;Pages with inline etymon for redlinks&quot;)
		end
		if __state.toplevel_redundant_etymology then
			table.insert(categories, &quot;Pages with redundant inline etymon&quot;)
		end
		if __state.toplevel_idless_etymon then
			table.insert(categories, &quot;Pages using etymon with no ID&quot;)
		end
		if __state.has_mismatched_id then
			table.insert(categories, lang:getCanonicalName() .. &quot; entries referencing etymons with mismatched IDs&quot;)
		end
		if __state.linked_page_multiple_etymons_idless then
			table.insert(categories,
				lang:getCanonicalName() .. &quot; entries referencing pages with multiple etymons missing IDs&quot;)
		end
	end

	if #categories &gt; 0 then
		table.insert(output, M.categories.format(categories, lang))
	end

	if __state.warnings then
		for i, warning in ipairs(__state.warnings) do
			table.insert(output, (i == 1 and &quot;\n&quot; or &quot;&quot;) .. warning .. &quot;\n&quot;)
		end
	end

	return table.concat(output)
end

return export</text>
      <sha1>atzf01y3q7myy0cwlzlcz4tnhqsss0s</sha1>
    </revision>
    <revision>
      <id>342824</id>
      <parentid>342823</parentid>
      <timestamp>2026-05-16T13:49:08Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <origin>342824</origin>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="61608" sha1="i3qmyo14t6emnj9rtl3gahpnditiud4" xml:space="preserve">--[=[

This module implements the {{etymon}} template for structured etymology data on Wiktionary.
It enables the creation of etymology trees and text by parsing etymon chains,
scraping linked pages for their own {{etymon}} data, and recursively building a tree
of derivational relationships.

Authors:
- Original implementation: [[User:Ioaxxere]]
- Full refactor (September 2025): [[User:Fenakhay]] ([[Special:Diff/86717746]])

Modules:
- [[Module:etymon]]: main module handling parsing, validation, tree building, and page scraping
- [[Module:etymon/data]]: keyword definitions, configuration, and status constants
- [[Module:etymon/tree]]: etymology tree rendering
- [[Module:etymon/text]]: etymology text generation
- [[Module:etymon/categories]]: category generation logic

]=]

local export = {}

local etymon_data_module = &quot;Module:etymon/data&quot;
local etymon_text_module = &quot;Module:etymon/text&quot;
local etymon_tree_module = &quot;Module:etymon/tree&quot;
local etymon_categories_module = &quot;Module:etymon/categories&quot;
local etymon_descendants_module = &quot;Module:etymon/descendants&quot;

local __state = {
	cached_etymon_args = {},
	cached_etymon_pages = {},
	cached_descendants_checks = {},
	senseid_parent_etymon = {},
	available_etymon_ids = {},
	single_etymons = {},
	entry_title = nil,
	entry_lang_code = nil,
	current_page_has_inline_etymology = false,
	current_page_has_redundant_etymology = false,
	used_idless_etymon = false,
	toplevel_has_inline_etymology = false,
	toplevel_redundant_etymology = false,
	toplevel_idless_etymon = false,
	has_mismatched_id = false,
	linked_page_multiple_etymons_idless = false,
	max_depth_reached = 0,
	total_nodes = 0,
	language_count = {},
	toplevel_keyword_stats = {},
	warnings = {},
}

local loader = require(&quot;Module:module loader&quot;)

local M = loader.init({
	require = {
		data = etymon_data_module,
		tree = etymon_tree_module,
		text = etymon_text_module,
		categories = etymon_categories_module,
		descendants = etymon_descendants_module,

		anchors = &quot;Module:anchors&quot;,
		etydate = &quot;Module:etydate&quot;,
		etymology = &quot;Module:etymology&quot;,
		families = &quot;Module:families&quot;,
		languages = &quot;Module:languages&quot;,
		languages_errorgetby = &quot;Module:languages/errorGetBy&quot;,
		links = &quot;Module:links&quot;,
		pages = &quot;Module:pages&quot;,
		parameters = &quot;Module:parameters&quot;,
		string_utilities = &quot;Module:string utilities&quot;,
		template_parser = &quot;Module:template parser&quot;,
		utilities = &quot;Module:utilities&quot;,
		debug = &quot;Module:debug&quot;,
		en_utilities = &quot;Module:en-utilities&quot;,
		parse_utilities = &quot;Module:parse utilities&quot;,
		references = &quot;Module:references&quot;,
		track = &quot;Module:debug/track&quot;,
		template_styles = &quot;Module:TemplateStyles&quot;,
		script_utilities = &quot;Module:script utilities&quot;,
		JSON = &quot;Module:JSON&quot;,
		yesno = &quot;Module:yesno&quot;,
	},
	loadData = {
		headword_data = &quot;Module:headword/data&quot;,
		parameters_data = &quot;Module:parameters/data&quot;,
		text_allowed = &quot;Module:etymon/data/text_allowed&quot;,
	},
})

local Util = {}

function Util.format_error(message, preview_only)
	if preview_only and not M.pages.is_preview() then
		return nil
	end
	return '&lt;span class=&quot;error&quot;&gt;' .. message .. '&lt;/span&gt;'
end

function Util.add_warning(message, preview_only)
	local formatted = Util.format_error(message, preview_only)
	if formatted then
		table.insert(__state.warnings, formatted)
	end
end

function Util.is_text_param_allowed_for_lang(lang)
	if not lang or type(lang) ~= &quot;table&quot; then
		return false
	end
	local types = lang.getTypes and lang:getTypes()
	if types and types.family then
		local code = lang.getCode and lang:getCode()
		return code and M.text_allowed.families[code] == true
	end
	local full_code = lang.getFullCode and lang:getFullCode()
	if full_code and M.text_allowed.langs[full_code] then
		return true
	end
	if lang.inFamily then
		for family_code in pairs(M.text_allowed.families) do
			if lang:inFamily(family_code) then
				return true
			end
		end
	end
	return false
end

function Util.get_lang(code, no_error)
	if no_error then
		return M.languages.getByCode(code, nil, true)
	end
	return M.languages.getByCode(code, nil, true) or M.languages_errorgetby.code(code, true, true)
end

function Util.get_family(code)
	return M.families.getByCode(code)
end

function Util.get_lang_exception(lang)
	-- Families have no language-specific exceptions
	if lang.getTypes and lang:getTypes().family then
		return nil
	end
	local code = lang:getCode()
	local lang_exceptions = M.data.config.lang_exceptions

	if lang_exceptions[code] then
		return lang_exceptions[code]
	end

	for norm_code, exc in pairs(lang_exceptions) do
		if exc.normalize_to and code == exc.normalize_to then
			return exc
		end
		if exc.normalize_from_families then
			local should_normalize = false
			for _, family in ipairs(exc.normalize_from_families) do
				if lang:inFamily(family) then
					should_normalize = true
					break
				end
			end

			if should_normalize and exc.normalize_exclude_families then
				for _, family in ipairs(exc.normalize_exclude_families) do
					if lang:inFamily(family) then
						should_normalize = false
						break
					end
				end
			end

			if should_normalize then
				local ret = {}
				for k, v in pairs(exc) do
					ret[k] = v
				end
				ret.suppress_tr = nil
				return ret
			end
		end
	end

	return nil
end

function Util.get_norm_lang(lang)
	local exc = Util.get_lang_exception(lang)
	if exc and exc.normalize_to then
		return M.languages.getByCode(exc.normalize_to)
	end
	return lang
end

-- Add default values for boolean modifiers (e.g., &lt;unc&gt; becomes &lt;unc:1&gt;)
-- This is needed because Module:parse utilities expects boolean modifiers to have explicit values
function Util.add_boolean_defaults(str, param_mods)
	local result = str
	for name, spec in pairs(param_mods) do
		if spec.type == &quot;boolean&quot; then
			-- Replace &lt;name&gt; with &lt;name:1&gt; (but not &lt;name:...&gt; which already has a value)
			result = result:gsub(&quot;&lt;&quot; .. name .. &quot;&gt;&quot;, &quot;&lt;&quot; .. name .. &quot;:1&gt;&quot;)
		end
	end
	return result
end

-- Centralized term formatting: handles suppress_term, unknown_term, and regular terms
function Util.format_term(term, is_toplevel, opts)
	opts = opts or {}

	-- suppress_term (-) returns nil
	if term.suppress_term then
		return nil
	end

	local lang = term.lang
	local exc = Util.get_lang_exception(lang)

	if is_toplevel then
		local display_text = term.alt or term.title or &quot;&quot;
		local sc = term.sc or lang:findBestScript(display_text)
		local bold_text = tostring(mw.html.create(&quot;strong&quot;)
			:addClass(&quot;selflink&quot;)
			:wikitext(display_text))
		return M.script_utilities.tag_text(bold_text, lang, sc, &quot;term&quot;)
	end

	local link_params = { lang = lang }

	link_params.term = not term.unknown_term and term.title or nil
	link_params.alt = term.alt
	link_params.id = (not term.unknown_term and term.id and term.id ~= &quot;&quot;) and term.id or nil
	if not (exc and exc.suppress_tr) then
		link_params.tr = term.tr
		link_params.ts = term.ts
	else
		link_params.suppress_tr = true
	end
	link_params.lit = (opts.lit ~= &quot;suppress&quot;) and term.lit or nil
	if opts.gloss ~= &quot;suppress&quot; then
		link_params.gloss = term.t
	end
	if term.g and term.g ~= &quot;&quot; then
		local genders = M.string_utilities.split(term.g, &quot;,&quot;)
		for i = 1, #genders do
			genders[i] = M.string_utilities.trim(genders[i])
		end
		link_params.genders = genders
	end
	if opts.pos ~= &quot;suppress&quot; then
		link_params.pos = term.pos
		link_params.ng = term.ng
	end
	if exc and exc.suppress_tr then
		link_params.lit = nil
	end

	local show_qualifiers
	if opts.tree_ql ~= &quot;suppress&quot; then
		if term.q then
			link_params.q = term.q
		end
		if term.qq then
			link_params.qq = term.qq
		end
		if term.l then
			link_params.l = term.l
		end
		if term.ll then
			link_params.ll = term.ll
		end
		show_qualifiers = term.q or term.qq or term.l or term.ll
	end

	return M.links.full_link(link_params, &quot;term&quot;, nil, show_qualifiers and true or nil)
end

local __is_content_page_cached
function Util.is_content_page()
	if __is_content_page_cached == nil then
		__is_content_page_cached = M.pages.is_content_page(mw.title.getCurrentTitle())
	end
	return __is_content_page_cached
end

local __page_data_cached
function Util.get_page_data()
	if not __page_data_cached then
		__page_data_cached = M.headword_data.page
	end
	return __page_data_cached
end

-- Extract base keyword from param (without modifiers)
local function get_keyword_base(param)
	if type(param) ~= &quot;string&quot; then return nil end
	local base = param:match(&quot;^:?([^&lt;]+)&quot;) or param:gsub(&quot;^:&quot;, &quot;&quot;)
	return base
end

local function is_keyword(param, allow_colon_less)
	if type(param) ~= &quot;string&quot; then return false end
	local keywords = M.data.keywords
	if param:sub(1, 1) == &quot;:&quot; then
		local base = get_keyword_base(param)
		return keywords[base] ~= nil
	end
	if allow_colon_less then
		local base = get_keyword_base(param)
		return keywords[base] ~= nil
	end
	return false
end

local function get_keyword(param, allow_colon_less)
	if type(param) ~= &quot;string&quot; then return nil end
	local keywords = M.data.keywords
	if param:sub(1, 1) == &quot;:&quot; then
		return get_keyword_base(param)
	end
	if allow_colon_less then
		local base = get_keyword_base(param)
		if keywords[base] then
			return base
		end
	end
	return nil
end

local function normalize_keyword(keyword)
	if keyword:sub(1, 1) == &quot;:&quot; then
		return keyword
	end
	return &quot;:&quot; .. keyword
end

-- Resolve keyword (possibly an alias) to its canonical form. Used only at input boundaries
local function get_canonical_keyword(keyword)
	if not keyword then return keyword end
	return M.data.keyword_canonical[keyword] or keyword
end

-- Build text/phrase for nominalization with &lt;g:code&gt; (uses data module for codes only).
local function get_nominalization_label_for_g(code)
	if not code or code == &quot;&quot; then return nil end
	local codes = M.data.nominalization_g_codes
	local adj = codes[code]
	if not adj and #code == 2 then
		local gender_adj = codes[code:sub(1, 1)]
		local number_adj = codes[code:sub(2, 2)]
		if gender_adj and number_adj then
			adj = gender_adj .. &quot; &quot; .. number_adj
		end
	end
	if not adj then return nil end
	local text = adj:gsub(&quot;^%l&quot;, function(c) return string.upper(c) end) .. &quot; [[Appendix:Glossary#nominalization|nominalization]] of&quot;
	local phrase = M.en_utilities.add_indefinite_article(adj .. &quot; [[Appendix:Glossary#nominalization|nominalization]] of&quot;, false)
	return { text = text, phrase = phrase }
end

local EtymonParser = {}

-- Keyword modifier definitions
EtymonParser.keyword_param_mods = {
	unc = { type = &quot;boolean&quot; },
	ref = {},
	text = { restrict = { keywords = { &quot;from&quot;, &quot;derived&quot; } } },
	lit = { restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot;, &quot;univerbation&quot; } } },
	conj = {}, -- conjunction for alternatives: &quot;and&quot;, &quot;or&quot;, &quot;and/or&quot;, etc.
	g = { restrict = { keywords = { &quot;nominalization&quot; } } },
}

-- Term modifier definitions
EtymonParser.etymon_param_mods = {
	id = {},
	t = {},
	tr = {},
	ts = {},
	q = {},
	qq = {},
	l = {},
	ll = {},
	pos = {},
	ng = {},
	alt = {},
	g = {},
	ety = {},
	lit = {},
	unc = { type = &quot;boolean&quot; },
	ref = {},
	aftype = { restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot;, &quot;afeq&quot; } } },
	postype = {},
	bor = { type = &quot;boolean&quot;, restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot; } } },
	slbor = { type = &quot;boolean&quot;, restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot; } } },
	lbor = { type = &quot;boolean&quot;, restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot; } } },
}

local function get_clean_param_mods(param_mods)
	local clean = {}
	for mod_name, mod_def in pairs(param_mods) do
		clean[mod_name] = {}
		for key, value in pairs(mod_def) do
			if key ~= &quot;restrict&quot; then
				clean[mod_name][key] = value
			end
		end
	end
	return clean
end

function EtymonParser.check_modifier_restrictions(modifiers, current_keyword, param_mods)
	for mod_name, mod_value in pairs(modifiers) do
		-- Only check restrictions if the modifier has a non-false/nil value
		if mod_value then
			local mod_def = param_mods[mod_name]
			if mod_def and mod_def.restrict and mod_def.restrict.keywords then
				local allowed_keywords = mod_def.restrict.keywords
				local is_allowed = false
				for _, allowed_keyword in ipairs(allowed_keywords) do
					if current_keyword == allowed_keyword then
						is_allowed = true
						break
					end
				end
				if not is_allowed then
					local keyword_list = {}
					for _, kw in ipairs(allowed_keywords) do
						table.insert(keyword_list, &quot;:&quot; .. kw)
					end
					local keyword_str = table.concat(keyword_list, #keyword_list == 2 and &quot; or &quot; or &quot;, &quot;)
					if #keyword_list &gt; 2 then
						-- Replace last comma with &quot;or&quot;
						keyword_str = keyword_str:gsub(&quot;, ([^,]+)$&quot;, &quot; or %1&quot;)
					end
					local mod_display = mod_value == true and &quot;&lt;&quot; .. mod_name .. &quot;&gt;&quot; or &quot;&lt;&quot; .. mod_name .. &quot;:&quot; .. tostring(mod_value) .. &quot;&gt;&quot;
					error(&quot;The modifier `&quot; .. mod_display .. &quot;` is only allowed for the keyword&quot; .. (#keyword_list &gt; 1 and &quot;s &quot; or &quot; &quot;) .. keyword_str .. &quot;.&quot;)
				end
			end
		end
	end
end

-- Parse keyword with modifiers (e.g., &quot;:bor&lt;unc&gt;&quot; or &quot;:bor&lt;ref:{{R:example}}&gt;&quot;)
function EtymonParser.parse_keyword_modifiers(param)
	if type(param) ~= &quot;string&quot; then return nil, {} end

	local base_keyword = get_keyword_base(param)
	if not base_keyword then return nil, {} end

	local canonical_keyword = get_canonical_keyword(base_keyword)

	-- Check if there are any modifiers
	if not param:find(&quot;&lt;&quot;, 1, true) then
		return canonical_keyword, {}
	end

	-- Parse modifiers using the same mechanism as etymon parsing
	local rest_with_defaults = Util.add_boolean_defaults(param, EtymonParser.keyword_param_mods)

	local function generate_obj(ignored)
		return {}
	end

	local parsed = M.parse_utilities.parse_inline_modifiers(rest_with_defaults:gsub(&quot;^:?[^&lt;]+&quot;, &quot;&quot;),
		{ param_mods = get_clean_param_mods(EtymonParser.keyword_param_mods), generate_obj = generate_obj })

	local modifiers = {
		unc = parsed.unc or false,
		ref = parsed.ref,
		text = parsed.text,
		lit = parsed.lit,
		conj = parsed.conj,
		g = parsed.g,
	}

	-- Validate modifiers against restrictions
	EtymonParser.check_modifier_restrictions(modifiers, canonical_keyword, EtymonParser.keyword_param_mods)

	return canonical_keyword, modifiers
end

function EtymonParser.parse_balanced_segments(str)
	local segments = {}
	local current = &quot;&quot;
	local depth = 0
	local i = 1

	while i &lt;= #str do
		local char = str:sub(i, i)

		if char == &quot;&lt;&quot; then
			if depth == 0 and current ~= &quot;&quot; then
				table.insert(segments, current)
				current = &quot;&quot;
			end
			depth = depth + 1
			current = current .. char
		elseif char == &quot;&gt;&quot; then
			current = current .. char
			depth = depth - 1
			if depth == 0 then
				table.insert(segments, current)
				current = &quot;&quot;
			elseif depth &lt; 0 then
				error(&quot;Unbalanced brackets in etymon: unexpected '&gt;'&quot;)
			end
		else
			current = current .. char
		end

		i = i + 1
	end

	if depth ~= 0 then
		error(&quot;Unbalanced brackets in etymon: missing '&gt;'&quot;)
	end

	if current ~= &quot;&quot; then
		table.insert(segments, current)
	end

	return segments
end

function EtymonParser.parse_inline_ety(ety_string, context_lang)
	local segments = EtymonParser.parse_balanced_segments(ety_string)

	if #segments == 0 then
		error(&quot;Empty inline etymology&quot;)
	end

	local keyword = M.string_utilities.trim(segments[1])

	if not is_keyword(keyword, true) then
		error(&quot;Invalid keyword '&quot; .. keyword .. &quot;' in inline etymology &lt;ety:&quot; .. keyword .. &quot;...&gt;&quot;)
	end

	local args = { context_lang:getCode(), normalize_keyword(get_canonical_keyword(keyword)) }

	for i = 2, #segments do
		local segment = segments[i]
		if segment:sub(1, 1) == &quot;&lt;&quot; and segment:sub(-1) == &quot;&gt;&quot; then
			local inner = segment:sub(2, -2)
			if inner ~= &quot;&quot; then
				table.insert(args, inner)
			end
		elseif is_keyword(segment, true) then
			-- Handle keywords that appear between bracketed segments
			table.insert(args, normalize_keyword(get_canonical_keyword(get_keyword(segment, true))))
		end
	end

	return args
end

function EtymonParser.parse_etymon(param, context_lang)
	if is_keyword(param) then
		return nil
	end

	if type(param) ~= &quot;string&quot; then
		return nil
	end

	local lang, rest
	local is_family = false

	local before_bracket = param:match(&quot;^([^&lt;]*)&quot;) or param
	local lang_code, rest_match = before_bracket:match(&quot;^([a-zA-Z][a-zA-Z0-9._-]*):(.*)$&quot;)

	if lang_code then
		local potential_lang = Util.get_lang(lang_code, true)
		if potential_lang then
			lang = potential_lang
			rest = param:sub(#lang_code + 2)
		else
			local potential_family = Util.get_family(lang_code)
			if potential_family then
				lang = potential_family
				rest = param:sub(#lang_code + 2)
				is_family = true
			else
				lang = context_lang
				rest = param
			end
		end
	else
		lang = context_lang
		rest = param
	end

	if rest == &quot;&quot; then
		M.track(&quot;etymon/term/empty&quot;)
	elseif rest == &quot;?&quot; then
		M.track(&quot;etymon/term/question-mark&quot;)
	elseif rest == &quot;-&quot; then
		M.track(&quot;etymon/term/hyphen&quot;)
	end

	if rest == &quot;&quot; then
		return {
			lang = lang,
			term = nil,
			unknown_term = true,
			is_family = is_family,
		}
	end

	if rest == &quot;-&quot; then
		return {
			lang = lang,
			term = nil,
			suppress_term = true,
			is_family = is_family,
		}
	end

	if not rest:find(&quot;&lt;&quot;, 1, true) then
		return {
			lang = lang,
			term = M.string_utilities.trim(rest),
			is_family = is_family,
		}
	end

	local term_text = rest:match(&quot;^([^&lt;]*)&quot;) or &quot;&quot;
	local is_unknown = (term_text == &quot;&quot;)
	local is_suppress = (term_text == &quot;-&quot;)

	local function generate_obj(ignored_term)
		return { term = (is_unknown or is_suppress) and nil or M.string_utilities.trim(term_text) }
	end

	local rest_with_defaults = Util.add_boolean_defaults(rest, EtymonParser.etymon_param_mods)

	local parsed_obj = M.parse_utilities.parse_inline_modifiers(rest_with_defaults,
		{ param_mods = get_clean_param_mods(EtymonParser.etymon_param_mods), generate_obj = generate_obj })

	if parsed_obj.id and parsed_obj.id:match(&quot;^!&quot;) then
		parsed_obj.id = parsed_obj.id:sub(2)
		parsed_obj.override = true
	end

	parsed_obj.lang = lang
	parsed_obj.is_family = is_family
	if is_unknown then
		parsed_obj.unknown_term = true
	elseif is_suppress then
		parsed_obj.suppress_term = true
	end

	return parsed_obj
end

function EtymonParser.validate(lang, args, id, title, pos, starts_with_lang_code)
	-- id is now optional, so only validate if provided
	if id then
		if mw.ustring.len(id) &lt; 2 then
			error(&quot;The `id` parameter must have at least two characters.&quot;)
		end
		if id == title or id == Util.get_page_data().pagename then
			error(&quot;The `id` parameter must not be the same as the page title.&quot;)
		end
	end

	local valid_pos = { prefix = true, suffix = true, interfix = true, infix = true, root = true, word = true }
	if pos and not valid_pos[pos] then
		error(&quot;Unknown value provided for `pos`. Valid values: &quot; .. table.concat(require(&quot;Module:table&quot;).keysToList(valid_pos), &quot;, &quot;) .. &quot;.&quot;)
	end

	local current_keyword = &quot;from&quot;
	local etymons_in_group = {}
	local keywords = M.data.keywords

	local function checkGroup()
		if keywords[current_keyword] and keywords[current_keyword].is_group and current_keyword ~= &quot;affix&quot; and current_keyword ~= &quot;surf&quot; and current_keyword ~= &quot;afeq&quot; and current_keyword ~= &quot;univerbation&quot; and #etymons_in_group &lt;= 1 then
			error(&quot;Detected `:&quot; .. current_keyword .. &quot;` group with fewer than two etymons.&quot;)
		end
		etymons_in_group = {}
	end

	local start_index = starts_with_lang_code and 2 or 1

	for i = start_index, #args do
		local param = args[i]

		if type(param) ~= &quot;string&quot; then
		elseif param:sub(1, 1) == &quot;:&quot; and not is_keyword(param) then
			error(&quot;Invalid keyword '&quot; .. param .. &quot;'. Did you mean a valid keyword like ':bor', ':inh', etc.?&quot;)
		elseif is_keyword(param) then
			checkGroup()
			current_keyword = get_canonical_keyword(get_keyword(param))
		else
			local etymon_data = EtymonParser.parse_etymon(param, lang)
			if etymon_data then
				table.insert(etymons_in_group, param)
				local param_lang = etymon_data.lang

				if etymon_data.is_family and current_keyword == &quot;inherited&quot; then
					error(&quot;`:inh` does not support family codes; use a specific language.&quot;)
				end
				if etymon_data.is_family and not etymon_data.suppress_term then
					error(&quot;Family codes require suppressed term (use family:-).&quot;)
				end
				if current_keyword == &quot;from&quot; and param_lang:getFullCode() ~= lang:getFullCode() then
					error(&quot;`:from` is for same-language derivation, but language does not match. &quot; ..
						&quot;Expected '&quot; .. lang:getFullCode() .. &quot;', got '&quot; .. param_lang:getFullCode() .. &quot;'.&quot;)
				elseif current_keyword == &quot;inherited&quot; then
					M.etymology.check_ancestor(lang, param_lang)
				end

				-- Check modifier restrictions
				EtymonParser.check_modifier_restrictions(etymon_data, current_keyword, EtymonParser.etymon_param_mods)

				-- postype must be &quot;root&quot; or &quot;word&quot;
				local VALID_POSTYPES = { root = true, word = true }
				if etymon_data.postype and not VALID_POSTYPES[etymon_data.postype] then
					error(&quot;Invalid &lt;postype:&quot; .. etymon_data.postype .. &quot;&gt;; must be \&quot;root\&quot; or \&quot;word\&quot;.&quot;)
				end

				if etymon_data.ety then
					local inline_args = EtymonParser.parse_inline_ety(etymon_data.ety, etymon_data.lang)
					EtymonParser.validate(etymon_data.lang, inline_args, nil, nil, nil, true)
				end
			else
				table.insert(etymons_in_group, param)
			end
		end
	end

	checkGroup()
end

local DataRetriever = {}

-- Given an etymon data, scrape its page and cache the result in the global state object.
function DataRetriever.cache_page_etymons(etymon_page, etymon_title, key, etymon_lang, etymon_id, redirected_from, descendants_is_toplevel)
	local content = etymon_title:getContent()
	if not content then
		__state.cached_etymon_args[key] = M.data.STATUS.REDLINK
		return
	end

	-- Check if the linked page is a redirect. If it is, the template parsing
	-- code below will be effectively skipped, and `scrape_page` will be called
	-- again on the redirect target (see the bottom of this function)
	local lang_section_for_descendants = nil
	local redirect_target = etymon_title.redirect_target
	if not redirect_target then
		content = M.pages.get_section(content, etymon_lang:getFullName(), 2)
		if not content then
			__state.cached_etymon_args[key] = M.data.STATUS.MISSING
			return
		end
		lang_section_for_descendants = content
	end

	local etymon_lang_code = etymon_lang:getFullCode()
	local lang_page_key = etymon_lang_code .. &quot;:&quot; .. etymon_page
	local found_templates_for_lang = {}
	local found_ids = {}
	local get_node_class = M.template_parser.class_else_type

	-- Look for all {{etymon}} templates within the page content using the template parser
	-- This way the same page is never parsed more than once

	-- Build a map from senseids to their parent etymonids.
	local active_etymon_args = nil

	for node in M.template_parser.parse(content):iterate_nodes() do
		local node_class = get_node_class(node)

		if node_class == &quot;heading&quot; then
			-- A new L2 or etymology section acts as a barrier: an {{etymon}} usage
			-- used previously cannot be the parent of any subsequent senseids.
			-- Note that we don't have to check for L2s due to the usage of `M.pages.get_section` above.
			if node:get_name():find(&quot;^Etymology&quot;) then
				active_etymon_args = nil
			end
		elseif node_class == &quot;template&quot; then
			local template_name = node:get_name()

			if template_name == &quot;etymon&quot; then
				local template_args = node:get_arguments()

				-- Check if this etymon is for our language
				if template_args[1] == etymon_lang_code then
					table.insert(found_templates_for_lang, template_args)

					if template_args.id then
						local etymon_key = lang_page_key .. &quot;:&quot; .. template_args.id
						__state.cached_etymon_args[etymon_key] = template_args
						__state.cached_etymon_pages[etymon_key] = tostring(etymon_page)
						table.insert(found_ids, template_args.id)
						active_etymon_args = template_args
					else
						-- Store idless etymon with default key
						local etymon_key = lang_page_key .. &quot;:*&quot;
						__state.cached_etymon_args[etymon_key] = template_args
						__state.cached_etymon_pages[etymon_key] = tostring(etymon_page)
						table.insert(found_ids, &quot;*&quot;)
						active_etymon_args = template_args
					end
				end
			elseif active_etymon_args and template_name == &quot;senseid&quot; then
				local template_args = node:get_arguments()

				-- This should always be true for proper usages of {{senseid}}.
				if template_args[1] == etymon_lang_code and template_args[2] then
					local sense_id_key = lang_page_key .. &quot;:&quot; .. template_args[2]
					__state.senseid_parent_etymon[sense_id_key] = active_etymon_args
					__state.cached_etymon_pages[sense_id_key] = tostring(etymon_page)
				end
			end
		end
	end

	if descendants_is_toplevel and lang_section_for_descendants and #found_templates_for_lang &gt; 0 then
		M.descendants.cache_page_checks({
			lang_section = lang_section_for_descendants,
			etymon_lang_code = etymon_lang_code,
			found_templates_for_lang = found_templates_for_lang,
			entry_title = __state.entry_title,
			entry_lang_code = __state.entry_lang_code,
			entry_lang = __state.entry_lang_code and Util.get_lang(__state.entry_lang_code, true) or nil,
			cached_descendants_checks = __state.cached_descendants_checks,
			lang_page_key = lang_page_key,
			redirected_from = redirected_from,
		})
	end

	local id_data_list = {}
	for _, args in ipairs(found_templates_for_lang) do
		local id = args.id or &quot;*&quot;
		table.insert(id_data_list, { id = id, pos = args.pos })
	end
	__state.available_etymon_ids[lang_page_key] = id_data_list

	if #found_templates_for_lang == 1 then
		__state.single_etymons[lang_page_key] = found_templates_for_lang[1]
	end

	if redirected_from and __state.available_etymon_ids[lang_page_key] then
		__state.available_etymon_ids[redirected_from] = __state.available_etymon_ids[redirected_from] or {}
		for _, id_data in ipairs(__state.available_etymon_ids[lang_page_key]) do
			table.insert(__state.available_etymon_ids[redirected_from], id_data)
		end
	end

	if __state.cached_etymon_args[key] ~= nil or __state.senseid_parent_etymon[key] ~= nil then
		-- All done!
		return
	elseif redirect_target and not redirected_from then
		-- Try scraping the redirect.
		etymon_page = redirect_target.prefixedText
		DataRetriever.cache_page_etymons(etymon_page, redirect_target, lang_page_key .. &quot;:&quot; .. etymon_id, etymon_lang, etymon_id, lang_page_key, descendants_is_toplevel)
		__state.cached_etymon_args[key] = __state.cached_etymon_args[etymon_lang_code .. &quot;:&quot; .. etymon_page .. &quot;:&quot; .. etymon_id]
	else
		__state.cached_etymon_args[key] = M.data.STATUS.MISSING
	end
end

-- Given an etymon object, scrape its page (if necessary) and return its own etymon arguments as well as the page name.
function DataRetriever.get_etymon_args(etymon_data, is_toplevel)
	local page = M.links.get_link_page(etymon_data.term, etymon_data.lang)
	local norm_lang = Util.get_norm_lang(etymon_data.lang)
	local base_key = norm_lang:getFullCode() .. &quot;:&quot; .. page

	if etymon_data.id then
		local key = base_key .. &quot;:&quot; .. etymon_data.id

		local cached_args = __state.cached_etymon_args[key] or __state.senseid_parent_etymon[key]
		if cached_args == nil then
			local title = mw.title.new(page)
			if not title then error('Invalid page title &quot;' .. page .. '&quot; encountered.') end
			DataRetriever.cache_page_etymons(page, title, key, norm_lang, etymon_data.id, nil, is_toplevel)
		end
		cached_args = __state.cached_etymon_args[key] or __state.senseid_parent_etymon[key] -- refresh

		-- Get etymon_id from parent if this was resolved via senseid
		local parent_etymon = __state.senseid_parent_etymon[key]
		local resolved_etymon_id = parent_etymon and parent_etymon.id
		local descendants_check = M.descendants.get_lookup_check({
			cached_descendants_checks = __state.cached_descendants_checks,
			is_toplevel = is_toplevel,
			base_key = base_key,
			lookup = {
				explicit_id = etymon_data.id,
				parent_etymon = parent_etymon,
			},
		})
		if is_toplevel and descendants_check == nil then
			local title = mw.title.new(page)
			if title then
				DataRetriever.cache_page_etymons(page, title, key, norm_lang, etymon_data.id, nil, true)
				descendants_check = M.descendants.get_lookup_check({
					cached_descendants_checks = __state.cached_descendants_checks,
					is_toplevel = true,
					base_key = base_key,
					lookup = {
						explicit_id = etymon_data.id,
						parent_etymon = parent_etymon,
					},
				})
			end
		end
		return cached_args, __state.cached_etymon_pages[key], resolved_etymon_id, descendants_check
	else
		__state.used_idless_etymon = true
		if is_toplevel then
			__state.toplevel_idless_etymon = true
		end

		if __state.available_etymon_ids[base_key] == nil then
			local title = mw.title.new(page)
			if not title then error('Invalid page title &quot;' .. page .. '&quot; encountered.') end
			DataRetriever.cache_page_etymons(page, title, base_key .. &quot;:*&quot;, norm_lang, &quot;*&quot;, nil, is_toplevel)
		end

		local ids = __state.available_etymon_ids[base_key] or {}
		local count = #ids

		-- Try to filter by postype if available and we have multiple candidates
		if count &gt; 1 and etymon_data.postype then
			local matching_ids = {}
			for _, id_data in ipairs(ids) do
				if id_data.pos == etymon_data.postype then
					table.insert(matching_ids, id_data)
				end
			end
			
			if #matching_ids == 1 then
				local matched_id = matching_ids[1].id
				local matched_key = base_key .. &quot;:&quot; .. matched_id
				local descendants_check = M.descendants.get_lookup_check({
					cached_descendants_checks = __state.cached_descendants_checks,
					is_toplevel = is_toplevel,
					base_key = base_key,
					lookup = { id = matched_id },
				})
				if is_toplevel and descendants_check == nil then
					local title = mw.title.new(page)
					if title then
						DataRetriever.cache_page_etymons(page, title, base_key .. &quot;:*&quot;, norm_lang, &quot;*&quot;, nil, true)
						descendants_check = M.descendants.get_lookup_check({
							cached_descendants_checks = __state.cached_descendants_checks,
							is_toplevel = true,
							base_key = base_key,
							lookup = { id = matched_id },
						})
					end
				end
				return __state.cached_etymon_args[matched_key], __state.cached_etymon_pages[matched_key], nil, descendants_check
			end
		end

		if count == 1 then
			local only_id_data = ids[1]
			local only_id = (type(only_id_data) == &quot;table&quot; and only_id_data.id) or only_id_data or &quot;*&quot;
			local descendants_check = M.descendants.get_lookup_check({
				cached_descendants_checks = __state.cached_descendants_checks,
				is_toplevel = is_toplevel,
				base_key = base_key,
				lookup = { id_data = only_id_data },
			})
			if is_toplevel and descendants_check == nil then
				local title = mw.title.new(page)
				if title then
					DataRetriever.cache_page_etymons(page, title, base_key .. &quot;:*&quot;, norm_lang, &quot;*&quot;, nil, true)
					descendants_check = M.descendants.get_lookup_check({
						cached_descendants_checks = __state.cached_descendants_checks,
						is_toplevel = true,
						base_key = base_key,
						lookup = { id_data = only_id_data },
					})
				end
			end
			return __state.single_etymons[base_key], __state.cached_etymon_pages[base_key .. &quot;:&quot; .. only_id], nil, descendants_check
		elseif count &gt; 1 then
			local page_link = M.links.full_link({
				term = page,
				lang = norm_lang,
				no_generate_forms = true,
			}, &quot;term&quot;)

			local function format_id_hint(id_data, idx)
				local id = type(id_data) == &quot;table&quot; and id_data.id or id_data
				local pos = type(id_data) == &quot;table&quot; and id_data.pos
				if id and id ~= &quot;&quot; and id ~= &quot;*&quot; then
					return '&quot;' .. id .. '&quot;'
				end
				if pos and pos ~= &quot;&quot; then
					return &quot;unnamed (|pos=&quot; .. pos .. &quot;|)&quot;
				end
				return &quot;etymon #&quot; .. idx .. &quot; (no |id= on page)&quot;
			end

			local id_list = {}
			local all_idless = true
			local target_has_idless = false
			for i, id_data in ipairs(ids) do
				local id = type(id_data) == &quot;table&quot; and id_data.id or id_data
				if id and id ~= &quot;&quot; and id ~= &quot;*&quot; then
					all_idless = false
				else
					target_has_idless = true
				end
				table.insert(id_list, format_id_hint(id_data, i))
			end

			if is_toplevel and target_has_idless then
				__state.linked_page_multiple_etymons_idless = true
			end

			local any_pos = false
			for _, id_data in ipairs(ids) do
				local pos = type(id_data) == &quot;table&quot; and id_data.pos
				if pos and pos ~= &quot;&quot; then
					any_pos = true
					break
				end
			end

			local suggestion_text
			local lead = &quot;Etymology link to &quot; .. page_link .. &quot; is ambiguous (&quot; .. count .. &quot; {{etymon}} templates for &quot;
				.. norm_lang:getCanonicalName() .. &quot;).&quot;
			if all_idless then
				if any_pos then
					suggestion_text = &quot; None set `|id=` yet; add a unique `|id=` to each on &quot; .. page_link
						.. &quot;, then `&lt;id:identifier&gt;` after the term here. Section order / hints: &quot;
						.. mw.text.listToText(id_list) .. &quot;.&quot;
				else
					suggestion_text = &quot; None set `|id=` yet; add a unique `|id=` to each {{etymon}} in that section from top to bottom, then `&lt;id:identifier&gt;` after the term here (same value as `|id=`).&quot;
				end
			else
				suggestion_text = &quot; Specify which one with `&lt;id:identifier&gt;` after the term. Options: &quot; .. mw.text.listToText(id_list) .. &quot;.&quot;
			end

			Util.add_warning(lead .. suggestion_text, true)

			return M.data.STATUS.AMBIGUOUS, nil, nil, nil
		else
			return M.data.STATUS.MISSING, nil, nil, nil
		end
	end
end

local TreeBuilder = {}

local function parse_etymon_references(refs_text)
	if not refs_text or refs_text == &quot;&quot; then
		return &quot;&quot;
	end
	return M.references.parse_references(refs_text)
end

local function parse_tree_references(node)
	if node.ref then
		node.parsed_ref = parse_etymon_references(node.ref)
	end

	if node.children then
		for _, container in ipairs(node.children) do
			if container.terms then
				for _, term in ipairs(container.terms) do
					parse_tree_references(term)
				end
			end
		end
	end
end

-- Build a unique key for deduplication in the seen table
function TreeBuilder.build_key(lang, title, args)
	local norm_lang_code = Util.get_norm_lang(lang):getFullCode()
	local is_table = type(args) == &quot;table&quot;
	local id = (is_table and args.id) or &quot;&quot;
	
	if title then
		return norm_lang_code .. &quot;:&quot; .. M.links.get_link_page(title, lang) .. &quot;:&quot; .. id
	end
	
	if is_table and args.status == M.data.STATUS.INLINE then
		local content_parts = {}
		for i = 1, #args do
			content_parts[i] = tostring(args[i])
		end
		return norm_lang_code .. &quot;:*:&quot; .. id .. &quot;\0&quot; .. table.concat(content_parts, &quot;\0&quot;)
	end
	
	return norm_lang_code .. &quot;:*:&quot; .. id
end

function TreeBuilder.build(lang, title, args, seen, depth, stop_recursion)
	seen = seen or {}
	depth = depth or 0
	local is_toplevel = (depth == 0)

	if depth &gt; __state.max_depth_reached then
		__state.max_depth_reached = depth
	end

	__state.total_nodes = __state.total_nodes + 1

	local lang_code = lang:getCode()
	__state.language_count[lang_code] = (__state.language_count[lang_code] or 0) + 1

	local current_id = (type(args) == &quot;table&quot; and args.id) or &quot;&quot;
	local key = TreeBuilder.build_key(lang, title, args)
	
	local node = { lang = lang, title = title, id = current_id, args = args, children = {}, status = M.data.STATUS.OK }

	if type(args) ~= &quot;table&quot; or seen[key] then
		node.status = args or M.data.STATUS.MISSING
		-- Mark as duplicate if we've seen this node before
		if seen[key] then
			node.is_duplicate = true
			node.duplicate_key = key
			local original_node = seen[key]
			if type(original_node) == &quot;table&quot; and original_node.children and #original_node.children &gt; 0 then
				node.original_has_children = true
			end
		end
		return node
	end

	node.status = args.status or M.data.STATUS.OK

	seen[key] = node

	-- If stop_recursion is set, skip parsing children but check for visible children
	if stop_recursion then
		local keywords = M.data.keywords
		local has_visible_children = false
		for i = 2, #args do
			local param = args[i]
			if type(param) == &quot;string&quot; then
				local keyword_base = get_keyword_base(param)
				if keyword_base and keywords[keyword_base] then
					-- It's a keyword, check if visible in tree (invisible &quot;all&quot; or &quot;tree&quot; = hidden in tree)
					local keyword_info = keywords[keyword_base]
					local inv = keyword_info.invisible
					if not (inv == &quot;all&quot; or inv == true or inv == &quot;tree&quot;) then
						has_visible_children = true
						break
					end
				elseif param:sub(1, 1) ~= &quot;:&quot; then
					-- It's a term (not a keyword), so there are visible children
					has_visible_children = true
					break
				end
			end
		end
		node.has_visible_children = has_visible_children
		return node
	end

	-- Parse args into keyword containers
	local current_keyword = &quot;from&quot;
	local current_keyword_modifiers = {}
	local current_container = nil

	-- Helper to track keyword usage at top level
	local function track_keyword_usage(keyword, target_lang, source_lang)
		if not is_toplevel then return end

		if not __state.toplevel_keyword_stats[keyword] then
			__state.toplevel_keyword_stats[keyword] = {
				count = 0,
				target_langs = {},
				source_langs = {},
			}
		end

		local keyword_data = __state.toplevel_keyword_stats[keyword]
		keyword_data.count = keyword_data.count + 1

		local target_code = target_lang:getCode()
		keyword_data.target_langs[target_code] = (keyword_data.target_langs[target_code] or 0) + 1

		if source_lang then
			local source_code = source_lang:getCode()
			keyword_data.source_langs[source_code] = (keyword_data.source_langs[source_code] or 0) + 1
		end
	end

	local function ensure_container()
		if not current_container or current_container.keyword ~= current_keyword then
			current_container = {
				keyword = current_keyword,
				keyword_info = M.data.keywords[current_keyword],
				keyword_modifiers = current_keyword_modifiers,
				terms = {},
			}
			table.insert(node.children, current_container)
			-- Override keyword text/phrase for nominalization with &lt;g:code&gt;
			if current_keyword_modifiers.g and current_keyword == &quot;nominalization&quot; then
				local labels = get_nominalization_label_for_g(current_keyword_modifiers.g)
				if not labels then
					local codes = {}
					for c in pairs(M.data.nominalization_g_codes) do table.insert(codes, c) end
					table.sort(codes)
					error(&quot;Invalid &lt;g:&quot; .. tostring(current_keyword_modifiers.g) .. &quot;&gt;. Supported codes for nominalization: &quot; .. table.concat(codes, &quot;, &quot;))
				end
				current_container.keyword_info = {}
				for k, v in pairs(M.data.keywords[current_keyword]) do current_container.keyword_info[k] = v end
				current_container.keyword_info.text = labels.text
				current_container.keyword_info.phrase = labels.phrase
			end
		end
	end

	for i = 2, #args do
		local param = args[i]

		if is_keyword(param) then
			local keyword, modifiers = EtymonParser.parse_keyword_modifiers(param)
			current_keyword = keyword
			current_keyword_modifiers = modifiers
			current_container = nil -- Force new container for new keyword
		elseif type(param) == &quot;string&quot; and param:sub(1, 1) == &quot;:&quot; then
			error(&quot;Invalid keyword '&quot; .. param .. &quot;'. Did you mean a valid keyword like ':bor', ':inh', etc.?&quot;)
		elseif type(param) == &quot;string&quot; then
			local etymon_data = EtymonParser.parse_etymon(param, lang)

			if etymon_data then
				-- Track keyword usage at top level
				track_keyword_usage(current_keyword, lang, etymon_data.lang)

				local term_node = {}

				-- Handle suppress_term (-) and unknown_term (empty) directly
				if etymon_data.suppress_term or etymon_data.unknown_term then
					ensure_container()
					if etymon_data.ety then
						local inline_args = EtymonParser.parse_inline_ety(etymon_data.ety, etymon_data.lang)
						inline_args.id = etymon_data.id
						inline_args.status = M.data.STATUS.INLINE
						term_node = TreeBuilder.build(etymon_data.lang, nil, inline_args, seen, depth + 1)
					else
						term_node = {
							lang = etymon_data.lang,
							children = {},
							status = M.data.STATUS.OK,
						}
					end
					term_node.suppress_term = etymon_data.suppress_term
					term_node.unknown_term = etymon_data.unknown_term
					term_node.is_family = etymon_data.is_family
					term_node.is_uncertain = etymon_data.unc
					term_node.ref = etymon_data.ref
					term_node.t = etymon_data.t
					term_node.tr = etymon_data.tr
					term_node.ts = etymon_data.ts
					term_node.alt = etymon_data.alt
					term_node.g = etymon_data.g
					term_node.pos = etymon_data.pos
					term_node.ng = etymon_data.ng
					term_node.lit = etymon_data.lit
					term_node.q = etymon_data.q
					term_node.qq = etymon_data.qq
					term_node.l = etymon_data.l
					term_node.ll = etymon_data.ll
				else
					-- Regular term: fetch arguments from page
					local etymon_args, page_of, resolved_etymon_id, descendants_check = DataRetriever.get_etymon_args(etymon_data, is_toplevel)

					if etymon_data.id and etymon_args == M.data.STATUS.MISSING and not etymon_data.ety then
						local page = M.links.get_link_page(etymon_data.term, etymon_data.lang)
						local norm_lang = Util.get_norm_lang(etymon_data.lang)
						local base_key = norm_lang:getFullCode() .. &quot;:&quot; .. page
						local available_ids = __state.available_etymon_ids[base_key] or {}

						if #available_ids &gt; 0 then
							__state.has_mismatched_id = true
						end
					end

					-- Check for &lt;ety&gt; inline parameter doesn't override the scraped arguments, unless the latter are missing
					if etymon_data.ety then
						if etymon_args == M.data.STATUS.REDLINK or etymon_args == M.data.STATUS.MISSING then
							__state.current_page_has_inline_etymology = true
							if is_toplevel then
								__state.toplevel_has_inline_etymology = true
							end

							local inline_args = EtymonParser.parse_inline_ety(etymon_data.ety, etymon_data.lang)

							-- Track inline ety keywords too
							local inline_keyword = get_keyword(inline_args[2], true)
							if inline_keyword and #inline_args &gt;= 3 then
								local inline_etymon = EtymonParser.parse_etymon(inline_args[3], etymon_data.lang)
								if inline_etymon then
									track_keyword_usage(inline_keyword, etymon_data.lang, inline_etymon.lang)
								end
							end

							inline_args.id = etymon_data.id
							inline_args.status = M.data.STATUS.INLINE
							etymon_args = inline_args
							term_node.page_of = __state.cached_etymon_pages[key] -- term node is on the same page as the parent
						else
							-- Scraped arguments exist, &lt;ety&gt; is redundant and ignored
							__state.current_page_has_redundant_etymology = true
							if is_toplevel then
								__state.toplevel_redundant_etymology = true
							end
						end
					end

					-- Ensure container exists before checking keyword info
					ensure_container()
					
					-- Check if current keyword has no_child_categories - if so, stop recursion
					local keyword_info = current_container.keyword_info
					local should_stop_recursion = (stop_recursion or (keyword_info and keyword_info.no_child_categories))
					
					term_node = TreeBuilder.build(etymon_data.lang, etymon_data.term, etymon_args, seen, depth + 1, should_stop_recursion)
					term_node.target_key = Util.get_norm_lang(etymon_data.lang):getFullCode() ..
						&quot;:&quot; .. M.links.get_link_page(etymon_data.term, etymon_data.lang)
					term_node.id = etymon_data.id
					term_node.etymon_id = resolved_etymon_id  -- The actual etymon id when resolved via senseid
					term_node.t = etymon_data.t
					term_node.tr = etymon_data.tr
					term_node.ts = etymon_data.ts
					term_node.pos = etymon_data.pos
					term_node.alt = etymon_data.alt
					term_node.g = etymon_data.g
					term_node.ng = etymon_data.ng
					term_node.ref = etymon_data.ref
					term_node.is_uncertain = etymon_data.unc
					term_node.override = etymon_data.override
					term_node.page_of = page_of
					term_node.aftype = etymon_data.aftype
					term_node.postype = etymon_data.postype
					term_node.bor = etymon_data.bor
					term_node.lbor = etymon_data.lbor
					term_node.slbor = etymon_data.slbor
					term_node.lit = etymon_data.lit
					term_node.is_family = etymon_data.is_family
					term_node.q = etymon_data.q
					term_node.qq = etymon_data.qq
					term_node.l = etymon_data.l
					term_node.ll = etymon_data.ll
					term_node.missing_descendants_header, term_node.missing_descendants_entry =
						M.descendants.get_term_sync_flags(current_keyword, term_node.status, descendants_check)
				end

				table.insert(current_container.terms, term_node)
			end
		end
	end

	return node
end

-- Convert etymology tree to JSON-serializable table
local function tree_to_json(node)
	local obj = {
		term = node.title,
		lang = node.lang:getCode(),
		lang_name = node.lang:getCanonicalName(),
		id = (node.id and node.id ~= &quot;&quot;) and node.id or nil,
		status = node.status,
		is_uncertain = node.is_uncertain or nil,
		is_duplicate = node.is_duplicate or nil,
		gloss = node.t,
		transliteration = node.tr,
		transcription = node.ts,
		alt = node.alt,
		g = node.g,
		pos = node.pos,
		ng = node.ng,
		children = {},
	}

	for _, container in ipairs(node.children or {}) do
		local keyword_info = container.keyword_info
		if keyword_info then
			local container_obj = {
				keyword = container.keyword,
				keyword_label = keyword_info.text,
				keyword_abbrev = keyword_info.abbrev,
				is_group = keyword_info.is_group or nil,
				is_invisible = keyword_info.invisible or nil,
				is_uncertain = (container.keyword_modifiers and container.keyword_modifiers.unc) or nil,
				terms = {},
			}

			for _, term in ipairs(container.terms or {}) do
				table.insert(container_obj.terms, tree_to_json(term))
			end

			table.insert(obj.children, container_obj)
		end
	end

	return obj
end

local function track_ranges(base_key, value, ranges, lang_code)
	M.track(&quot;etymon/&quot; .. base_key .. &quot;/&quot; .. value)
	if lang_code then
		M.track(&quot;etymon/lang/&quot; .. lang_code .. &quot;/&quot; .. base_key .. &quot;/&quot; .. value)
	end

	for _, range in ipairs(ranges) do
		local matches = false
		if range.min and range.max then
			matches = value &gt;= range.min and value &lt;= range.max
		elseif range.min then
			matches = value &gt;= range.min
		elseif range.max then
			matches = value &lt;= range.max
		elseif range.exact then
			matches = value == range.exact
		end

		if matches then
			M.track(&quot;etymon/&quot; .. base_key .. &quot;/&quot; .. range.label)
			if lang_code then
				M.track(&quot;etymon/lang/&quot; .. lang_code .. &quot;/&quot; .. base_key .. &quot;/&quot; .. range.label)
			end
			break
		end
	end
end

local function track_title_pagename_mismatch_after_strip(lang)
	local lang_code = lang:getCode()
	M.track(&quot;etymon/title/pagename-mismatch-after-strip-diacritics&quot;)
	M.track(&quot;etymon/lang/&quot; .. lang_code .. &quot;/title/pagename-mismatch-after-strip-diacritics&quot;)
end

-- Build and return the etymology data tree for a given term.
function export.get_tree(lang, title, args, options)
	options = options or {}
	__state.entry_title = title
	__state.entry_lang_code = lang:getCode()

	if options.validate then
		EtymonParser.validate(lang, args, options.id, title, options.pos, false)
	end

	local lang_code = lang:getCode()

	local start_index = (args[1] == lang_code) and 2 or 1
	local tree_args = { [1] = lang_code, id = options.id or args.id }
	for i = start_index, #args do
		table.insert(tree_args, args[i])
	end

	__state.cached_etymon_args[lang_code .. &quot;:&quot; .. title .. &quot;:&quot; .. (tree_args.id or &quot;&quot;)] = tree_args

	local ety_data_tree = TreeBuilder.build(lang, title, tree_args)
	parse_tree_references(ety_data_tree)

	if options.json then
		return M.JSON.toJSON(tree_to_json(ety_data_tree))
	end

	return ety_data_tree
end

-- Given a language code, page name and optionally the id= parameter,
-- render the tree and only the etymology tree for the relevant page.
-- Fetches and parses the corresponding {{etymon}} from the requested page,
-- and any further pages needed to render the tree.
-- Parameters can be passed either through the #invoke or as
-- template parameters *through* an #invoke.
function export.render_tree_for_etymon_on_page(frame)
	local frame_args = frame.args
	local parent_args = frame:getParent().args
	local langcode = frame_args[1] or parent_args[1]
	local pagename = frame_args[2] or parent_args[2]
	local id = frame_args[&quot;id&quot;] or parent_args[&quot;id&quot;]
	local display_title = frame_args[&quot;title&quot;] or parent_args[&quot;title&quot;]

	local parsed_title = mw.title.new(pagename, 0)
	local title
	if parsed_title.namespace == 0 then
		title = M.pages.safe_page_name(parsed_title)
	elseif parsed_title.namespace == 118 then
		title = &quot;*&quot; .. M.pages.safe_page_name(parsed_title)
	else
		error(&quot;Unsupported namespace for render_tree_for_etymon_on_page: &quot; .. parsed_title.namespace)
	end

	local lang = Util.get_lang(langcode)
	-- Construct etymon_data for DataRetriever.get_args.
	local etymon_data = {
		lang = lang,
		term = title,
		id = id
	}
	local args, pagename = DataRetriever.get_etymon_args(etymon_data, true)
	if args == M.data.STATUS.MISSING then
		error(&quot;The etymon template was not found (language &quot; ..
			langcode ..
			&quot;, title '&quot; ..
			title ..
			&quot;'&quot; ..
			(id and &quot;, ID '&quot; .. id .. &quot;'&quot; or &quot;, no ID given&quot;) .. &quot;). Page contents may have changed in the interim.&quot;)
	end

	local tree_title = display_title or title
	if lang:stripDiacritics(M.links.remove_links(tree_title)) ~= lang:stripDiacritics(M.links.remove_links(title)) then
		track_title_pagename_mismatch_after_strip(lang)
	end

	local ety_data_tree = export.get_tree(lang, tree_title, args, {
		validate = true,
		id = id,
	})

	local output = {}
	table.insert(output, M.template_styles(&quot;Module:etymon/styles.css&quot;))
	table.insert(output, M.tree.render({
		data_tree = ety_data_tree,
		format_term_func = function(term, is_toplevel)
			return Util.format_term(term, is_toplevel, {
				gloss = &quot;suppress&quot;,
				pos = &quot;suppress&quot;,
				lit = &quot;suppress&quot;,
				tree_ql = &quot;suppress&quot;,
			})
		end,
	}))

	return table.concat(output)
end

function export.main(frame)
	local parent_args = frame:getParent().args
	local args = M.parameters.process(parent_args, M.parameters_data.etymon)
	local lang = args[1]
	local etymon_args = args[2]
	local id = args.id
	local title = args.title
	local text = args.text
	local tree = args.tree
	local etydate = args.etydate
	local rfe = args.rfe
	local page_data = Util.get_page_data()

	if not title then
		title = page_data.pagename
		if page_data.namespace == &quot;Reconstruction&quot; then title = &quot;*&quot; .. title end
	end

	local entry_pagename = page_data.pagename
	if page_data.namespace == &quot;Reconstruction&quot; then
		entry_pagename = &quot;*&quot; .. entry_pagename
	end
	if lang:stripDiacritics(M.links.remove_links(title)) ~= lang:stripDiacritics(M.links.remove_links(entry_pagename)) then
		track_title_pagename_mismatch_after_strip(lang)
	end

	local current_L2 = M.pages.get_current_L2()
	if current_L2 then
		local norm_lang = &quot;Bahasa &quot; .. Util.get_norm_lang(lang)
		local norm_name = &quot;Bahasa &quot; .. norm_lang:getCanonicalName()
		if current_L2 ~= norm_name then
			local lang_desc = lang:getCode() .. &quot; (Bahasa &quot; .. lang:getCanonicalName() .. &quot;)&quot;
			if norm_lang:getCode() ~= lang:getCode() then
				lang_desc = lang_desc .. &quot;, normalized to &quot; .. norm_lang:getCode() .. &quot; (Bahasa &quot; .. norm_name .. &quot;)&quot;
			end
			error(&quot;Language '&quot; .. lang_desc .. &quot;' does not match the L2 header (&quot; .. current_L2 .. &quot;).&quot;)
		end
	end

	local ety_data_tree = export.get_tree(lang, title, etymon_args, {
		validate = true,
		pos = args.pos,
		id = id,
		json = args.json,
	})

	if args.json then
		return ety_data_tree
	end

	local output = {}

	local text_allowlist_mode = M.text_allowed.default_mode or &quot;off&quot;
	if text and text_allowlist_mode ~= &quot;off&quot; and not Util.is_text_param_allowed_for_lang(lang) then
		local msg = &quot;Etymology texts (parameter &lt;code&gt;text=&lt;/code&gt;) are not allowed for &quot; .. lang:getFullName() ..
			&quot;; see [[Template:etymon#Text allowlist|Template:etymon § Text allowlist]] for the list of languages that may use the &lt;code&gt;text=&lt;/code&gt; parameter.&quot;
		if text_allowlist_mode == &quot;error&quot; then
			error(msg)
		else
			Util.add_warning(msg, true)
		end
	end

	local lang_exc = Util.get_lang_exception(lang)
	if lang_exc and lang_exc.disallow then
		local disallow = lang_exc.disallow
		local error_text = &quot; for &quot; .. lang:getFullName()
		if disallow.ref then
			error_text = error_text .. &quot;; see &quot; .. disallow.ref
		else
			error_text = error_text .. &quot;.&quot;
		end
		if tree and disallow.tree then
			error(&quot;Etymology trees are not allowed&quot; .. error_text)
		end
		if text and disallow.text then
			error(&quot;Etymology texts are not allowed&quot; .. error_text)
		end
	end

	if etydate then
		local etydate_param_mods = {
			ref = { list = true, type = &quot;references&quot;, allow_holes = true },
			refn = { list = true, allow_holes = true },
			nocap = { type = &quot;boolean&quot; },
		}

		local function generate_etydate_obj(etydate_text)
			local etydate_specs = {}
			for spec in etydate_text:gmatch(&quot;[^,]+&quot;) do
				table.insert(etydate_specs, mw.text.trim(spec))
			end
			return { [1] = etydate_specs }
		end

		local parsed_etydate = M.parse_utilities.parse_inline_modifiers(etydate, { param_mods = etydate_param_mods, generate_obj = generate_etydate_obj })

		local etydate_args = {
			[1] = parsed_etydate[1],
			nocap = parsed_etydate.nocap or false,
		}

		ety_data_tree.etydate = M.etydate.format_etydate(etydate_args, { omit_refs = true })

		if parsed_etydate.ref and #parsed_etydate.ref &gt; 0 then
			ety_data_tree.etydate_refs = parsed_etydate.ref
		end
	end

	if tree then
		table.insert(output, M.template_styles(&quot;Module:etymon/styles.css&quot;))
		table.insert(output, M.tree.render({
			data_tree = ety_data_tree,
			format_term_func = function(term, is_toplevel)
				return Util.format_term(term, is_toplevel, {
					gloss = &quot;suppress&quot;,
					pos = &quot;suppress&quot;,
					lit = &quot;suppress&quot;,
					tree_ql = &quot;suppress&quot;,
				})
			end,
		}))
	end

	-- Check if there are any visible children in tree (invisible &quot;all&quot; or &quot;tree&quot; = hidden in tree)
	local has_visible_children = false
	for _, child in ipairs(ety_data_tree.children or {}) do
		local child_keyword_info = child.keyword_info
		local inv = child_keyword_info and child_keyword_info.invisible
		if not (inv == &quot;all&quot; or inv == true or inv == &quot;tree&quot;) then
			has_visible_children = true
			break
		end
	end

	local tree_disallowed = lang_exc and lang_exc.disallow and lang_exc.disallow.tree
	local ety_tree_json = M.JSON.toJSON(tree_to_json(ety_data_tree))
	local anchor = M.anchors.etymonid(lang, id, {
		no_tree = args.notree,
		title = title,
		empty_tree = (not has_visible_children) or tree_disallowed,
		ety_tree_json = ety_tree_json,
	})
	table.insert(output, anchor)

	if text then
		local max_depth, stop_at_blue_link, stop_at_lang, stop_at_lang_or_bluelink
		if text == &quot;++&quot; then
			max_depth, stop_at_blue_link = false, false
		elseif text == &quot;+&quot; then
			max_depth, stop_at_blue_link = 1, false
		elseif text == &quot;*&quot; then
			max_depth, stop_at_blue_link = false, true
		elseif text:match(&quot;^:[^*]+%*$&quot;) then
			-- Stop at a specific language OR first bluelink after it, e.g., &quot;:ota*&quot;
			-- If the target language is a redlink, continue to the first bluelink
			local lang_code = text:match(&quot;^:([^*]+)%*$&quot;)
			if lang_code and lang_code ~= &quot;&quot; then
				local lang_obj = Util.get_lang(lang_code, true)
				if lang_obj then
					stop_at_lang_or_bluelink = lang_code
				else
					Util.add_warning('Invalid language code &quot;' .. lang_code .. '&quot; in text parameter. Showing full chain instead.')
					max_depth, stop_at_blue_link = false, false
				end
			else
				Util.add_warning('Empty language code in text parameter. Showing full chain instead.')
				max_depth, stop_at_blue_link = false, false
			end
		elseif text:sub(1, 1) == &quot;:&quot; then
			-- Stop at a specific language, e.g., &quot;:ar&quot; stops at first Arabic term
			local lang_code = text:sub(2)
			if lang_code ~= &quot;&quot; then
				-- Validate the language code
				local lang_obj = Util.get_lang(lang_code, true)
				if lang_obj then
					stop_at_lang = lang_code
				else
					Util.add_warning('Invalid language code &quot;' .. lang_code .. '&quot; in text parameter. Showing full chain instead.')
					max_depth, stop_at_blue_link = false, false -- default to ++
				end
			else
				Util.add_warning('Empty language code in text parameter. Showing full chain instead.')
				max_depth, stop_at_blue_link = false, false -- default to ++
			end
		else
			local num = tonumber(text)
			if num and num &gt;= 1 then
				max_depth, stop_at_blue_link = num, false
			else
				error('Invalid text value &quot;' ..
					text .. '&quot;. Valid values are: &quot;++&quot; (full chain), &quot;+&quot; (first step only), &quot;*&quot; (until first blue link), a number (max steps), &quot;:lang&quot; (stop at language), or &quot;:lang*&quot; (stop at language or first bluelink if redlink)')
			end
		end
		table.insert(output, M.text.render({
			data_tree = ety_data_tree,
			format_term_func = Util.format_term,
			max_depth = max_depth,
			stop_at_blue_link = stop_at_blue_link,
			curr_page = page_data.pagename,
			nodot = args.nodot,
			stop_at_lang = stop_at_lang,
			stop_at_lang_or_bluelink = stop_at_lang_or_bluelink,
		}))
	end

	if rfe then
		local rfe_param_mods = {
			nocat = { type = &quot;boolean&quot; },
			sort = {},
			y = {},
			m = {},
			fragment = {},
			section = {},
			box = { type = &quot;boolean&quot; },
			noes = { type = &quot;boolean&quot; },
		}

		local function generate_rfe_obj(rfe_text)
			-- Check if it's a boolean true value
			if M.yesno(rfe_text, false) then
				return { is_boolean = true }
			else
				return { text = rfe_text }
			end
		end

		local rfe_with_defaults = Util.add_boolean_defaults(rfe, rfe_param_mods)
		local parsed_rfe = M.parse_utilities.parse_inline_modifiers(rfe_with_defaults, { 
			param_mods = rfe_param_mods, 
			generate_obj = generate_rfe_obj 
		})

		local rfe_args = {
			[1] = lang:getCode(),
			nocat = parsed_rfe.nocat,
			sort = parsed_rfe.sort,
			y = parsed_rfe.y,
			m = parsed_rfe.m,
			fragment = parsed_rfe.fragment,
			section = parsed_rfe.section,
			box = parsed_rfe.box,
			noes = parsed_rfe.noes,
		}

		if not parsed_rfe.is_boolean then
			rfe_args[2] = parsed_rfe.text
		end

		table.insert(output, frame:expandTemplate({
			title = &quot;rfe&quot;,
			args = rfe_args
		}))
	end

	if Util.is_content_page() and __state.max_depth_reached &gt; 0 then
		local lang_code = lang:getCode()

		local depth_ranges = {
			{ min = 50, label = &quot;extremely-deep&quot; },
			{ min = 20, label = &quot;20+&quot; },
			{ min = 10, max = 19,                label = &quot;10-19&quot; },
			{ min = 5,  max = 9,                 label = &quot;5-9&quot; },
			{ min = 3,  max = 4,                 label = &quot;3-4&quot; },
			{ max = 2,  label = &quot;1-2&quot; }
		}

		local node_ranges = {
			{ min = 100, label = &quot;extremely-large&quot; },
			{ min = 50,  label = &quot;50+&quot; },
			{ min = 20,  max = 49,                 label = &quot;20-49&quot; },
			{ min = 10,  max = 19,                 label = &quot;10-19&quot; },
			{ min = 5,   max = 9,                  label = &quot;5-9&quot; },
			{ max = 4,   label = &quot;1-4&quot; }
		}

		local language_ranges = {
			{ min = 10,  label = &quot;10+&quot; },
			{ min = 5,   max = 9,      label = &quot;5-9&quot; },
			{ min = 3,   max = 4,      label = &quot;3-4&quot; },
			{ exact = 2, label = &quot;2&quot; },
			{ exact = 1, label = &quot;1&quot; }
		}

		track_ranges(&quot;depth&quot;, __state.max_depth_reached, depth_ranges, lang_code)
		track_ranges(&quot;nodes&quot;, __state.total_nodes, node_ranges, lang_code)

		local unique_languages = 0
		for _ in pairs(__state.language_count) do
			unique_languages = unique_languages + 1
		end
		track_ranges(&quot;unique-languages&quot;, unique_languages, language_ranges, lang_code)

		if __state.total_nodes == __state.max_depth_reached + 1 then
			track_ranges(&quot;linear-depth&quot;, __state.max_depth_reached, depth_ranges, lang_code)
		end
	end

	local categories = {}
	if Util.is_content_page() then
		local should_suppress_categories = lang_exc and lang_exc.suppress_categories
		if not should_suppress_categories and not args.nocat then
			categories = M.categories.render({
				data_tree = ety_data_tree,
				page_lang = lang,
				available_etymon_ids = __state.available_etymon_ids,
				senseid_parent_etymon = __state.senseid_parent_etymon,
				get_norm_lang_func = Util.get_norm_lang,
				lang_exc = lang_exc,
			})
		end

		local target_lang_code = lang:getCode()
		for keyword, keyword_data in pairs(__state.toplevel_keyword_stats) do
			-- Track keyword globally
			M.track(&quot;etymon/keyword/&quot; .. keyword)

			-- Track keyword per target language
			M.track(&quot;etymon/keyword/&quot; .. keyword .. &quot;/target/&quot; .. target_lang_code)

			-- Track keyword per source language
			for source_code, count in pairs(keyword_data.source_langs) do
				M.track(&quot;etymon/keyword/&quot; .. keyword .. &quot;/source/&quot; .. source_code)

				-- Track keyword per target+source combination
				M.track(&quot;etymon/keyword/&quot; .. keyword .. &quot;/target/&quot; .. target_lang_code .. &quot;/source/&quot; .. source_code)
			end
		end

		if tree then
			table.insert(categories, &quot;Pages with etymology trees&quot;)
			table.insert(categories, lang:getCanonicalName() .. &quot; entries with etymology trees&quot;)
		end
		if text then table.insert(categories, lang:getCanonicalName() .. &quot; entries with etymology texts&quot;) end
		if args.exnihilo then table.insert(categories, lang:getCanonicalName() .. &quot; terms coined ex nihilo&quot;) end
		if __state.toplevel_has_inline_etymology then
			table.insert(categories, &quot;Pages with inline etymon for redlinks&quot;)
		end
		if __state.toplevel_redundant_etymology then
			table.insert(categories, &quot;Pages with redundant inline etymon&quot;)
		end
		if __state.toplevel_idless_etymon then
			table.insert(categories, &quot;Pages using etymon with no ID&quot;)
		end
		if __state.has_mismatched_id then
			table.insert(categories, lang:getCanonicalName() .. &quot; entries referencing etymons with mismatched IDs&quot;)
		end
		if __state.linked_page_multiple_etymons_idless then
			table.insert(categories,
				lang:getCanonicalName() .. &quot; entries referencing pages with multiple etymons missing IDs&quot;)
		end
	end

	if #categories &gt; 0 then
		table.insert(output, M.categories.format(categories, lang))
	end

	if __state.warnings then
		for i, warning in ipairs(__state.warnings) do
			table.insert(output, (i == 1 and &quot;\n&quot; or &quot;&quot;) .. warning .. &quot;\n&quot;)
		end
	end

	return table.concat(output)
end

return export</text>
      <sha1>i3qmyo14t6emnj9rtl3gahpnditiud4</sha1>
    </revision>
    <revision>
      <id>342825</id>
      <parentid>342824</parentid>
      <timestamp>2026-05-16T13:49:33Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <origin>342825</origin>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="61568" sha1="sd824iy93rvmo3oroit742p1i4oi4gt" xml:space="preserve">--[=[

This module implements the {{etymon}} template for structured etymology data on Wiktionary.
It enables the creation of etymology trees and text by parsing etymon chains,
scraping linked pages for their own {{etymon}} data, and recursively building a tree
of derivational relationships.

Authors:
- Original implementation: [[User:Ioaxxere]]
- Full refactor (September 2025): [[User:Fenakhay]] ([[Special:Diff/86717746]])

Modules:
- [[Module:etymon]]: main module handling parsing, validation, tree building, and page scraping
- [[Module:etymon/data]]: keyword definitions, configuration, and status constants
- [[Module:etymon/tree]]: etymology tree rendering
- [[Module:etymon/text]]: etymology text generation
- [[Module:etymon/categories]]: category generation logic

]=]

local export = {}

local etymon_data_module = &quot;Module:etymon/data&quot;
local etymon_text_module = &quot;Module:etymon/text&quot;
local etymon_tree_module = &quot;Module:etymon/tree&quot;
local etymon_categories_module = &quot;Module:etymon/categories&quot;
local etymon_descendants_module = &quot;Module:etymon/descendants&quot;

local __state = {
	cached_etymon_args = {},
	cached_etymon_pages = {},
	cached_descendants_checks = {},
	senseid_parent_etymon = {},
	available_etymon_ids = {},
	single_etymons = {},
	entry_title = nil,
	entry_lang_code = nil,
	current_page_has_inline_etymology = false,
	current_page_has_redundant_etymology = false,
	used_idless_etymon = false,
	toplevel_has_inline_etymology = false,
	toplevel_redundant_etymology = false,
	toplevel_idless_etymon = false,
	has_mismatched_id = false,
	linked_page_multiple_etymons_idless = false,
	max_depth_reached = 0,
	total_nodes = 0,
	language_count = {},
	toplevel_keyword_stats = {},
	warnings = {},
}

local loader = require(&quot;Module:module loader&quot;)

local M = loader.init({
	require = {
		data = etymon_data_module,
		tree = etymon_tree_module,
		text = etymon_text_module,
		categories = etymon_categories_module,
		descendants = etymon_descendants_module,

		anchors = &quot;Module:anchors&quot;,
		etydate = &quot;Module:etydate&quot;,
		etymology = &quot;Module:etymology&quot;,
		families = &quot;Module:families&quot;,
		languages = &quot;Module:languages&quot;,
		languages_errorgetby = &quot;Module:languages/errorGetBy&quot;,
		links = &quot;Module:links&quot;,
		pages = &quot;Module:pages&quot;,
		parameters = &quot;Module:parameters&quot;,
		string_utilities = &quot;Module:string utilities&quot;,
		template_parser = &quot;Module:template parser&quot;,
		utilities = &quot;Module:utilities&quot;,
		debug = &quot;Module:debug&quot;,
		en_utilities = &quot;Module:en-utilities&quot;,
		parse_utilities = &quot;Module:parse utilities&quot;,
		references = &quot;Module:references&quot;,
		track = &quot;Module:debug/track&quot;,
		template_styles = &quot;Module:TemplateStyles&quot;,
		script_utilities = &quot;Module:script utilities&quot;,
		JSON = &quot;Module:JSON&quot;,
		yesno = &quot;Module:yesno&quot;,
	},
	loadData = {
		headword_data = &quot;Module:headword/data&quot;,
		parameters_data = &quot;Module:parameters/data&quot;,
		text_allowed = &quot;Module:etymon/data/text_allowed&quot;,
	},
})

local Util = {}

function Util.format_error(message, preview_only)
	if preview_only and not M.pages.is_preview() then
		return nil
	end
	return '&lt;span class=&quot;error&quot;&gt;' .. message .. '&lt;/span&gt;'
end

function Util.add_warning(message, preview_only)
	local formatted = Util.format_error(message, preview_only)
	if formatted then
		table.insert(__state.warnings, formatted)
	end
end

function Util.is_text_param_allowed_for_lang(lang)
	if not lang or type(lang) ~= &quot;table&quot; then
		return false
	end
	local types = lang.getTypes and lang:getTypes()
	if types and types.family then
		local code = lang.getCode and lang:getCode()
		return code and M.text_allowed.families[code] == true
	end
	local full_code = lang.getFullCode and lang:getFullCode()
	if full_code and M.text_allowed.langs[full_code] then
		return true
	end
	if lang.inFamily then
		for family_code in pairs(M.text_allowed.families) do
			if lang:inFamily(family_code) then
				return true
			end
		end
	end
	return false
end

function Util.get_lang(code, no_error)
	if no_error then
		return M.languages.getByCode(code, nil, true)
	end
	return M.languages.getByCode(code, nil, true) or M.languages_errorgetby.code(code, true, true)
end

function Util.get_family(code)
	return M.families.getByCode(code)
end

function Util.get_lang_exception(lang)
	-- Families have no language-specific exceptions
	if lang.getTypes and lang:getTypes().family then
		return nil
	end
	local code = lang:getCode()
	local lang_exceptions = M.data.config.lang_exceptions

	if lang_exceptions[code] then
		return lang_exceptions[code]
	end

	for norm_code, exc in pairs(lang_exceptions) do
		if exc.normalize_to and code == exc.normalize_to then
			return exc
		end
		if exc.normalize_from_families then
			local should_normalize = false
			for _, family in ipairs(exc.normalize_from_families) do
				if lang:inFamily(family) then
					should_normalize = true
					break
				end
			end

			if should_normalize and exc.normalize_exclude_families then
				for _, family in ipairs(exc.normalize_exclude_families) do
					if lang:inFamily(family) then
						should_normalize = false
						break
					end
				end
			end

			if should_normalize then
				local ret = {}
				for k, v in pairs(exc) do
					ret[k] = v
				end
				ret.suppress_tr = nil
				return ret
			end
		end
	end

	return nil
end

function Util.get_norm_lang(lang)
	local exc = Util.get_lang_exception(lang)
	if exc and exc.normalize_to then
		return M.languages.getByCode(exc.normalize_to)
	end
	return lang
end

-- Add default values for boolean modifiers (e.g., &lt;unc&gt; becomes &lt;unc:1&gt;)
-- This is needed because Module:parse utilities expects boolean modifiers to have explicit values
function Util.add_boolean_defaults(str, param_mods)
	local result = str
	for name, spec in pairs(param_mods) do
		if spec.type == &quot;boolean&quot; then
			-- Replace &lt;name&gt; with &lt;name:1&gt; (but not &lt;name:...&gt; which already has a value)
			result = result:gsub(&quot;&lt;&quot; .. name .. &quot;&gt;&quot;, &quot;&lt;&quot; .. name .. &quot;:1&gt;&quot;)
		end
	end
	return result
end

-- Centralized term formatting: handles suppress_term, unknown_term, and regular terms
function Util.format_term(term, is_toplevel, opts)
	opts = opts or {}

	-- suppress_term (-) returns nil
	if term.suppress_term then
		return nil
	end

	local lang = term.lang
	local exc = Util.get_lang_exception(lang)

	if is_toplevel then
		local display_text = term.alt or term.title or &quot;&quot;
		local sc = term.sc or lang:findBestScript(display_text)
		local bold_text = tostring(mw.html.create(&quot;strong&quot;)
			:addClass(&quot;selflink&quot;)
			:wikitext(display_text))
		return M.script_utilities.tag_text(bold_text, lang, sc, &quot;term&quot;)
	end

	local link_params = { lang = lang }

	link_params.term = not term.unknown_term and term.title or nil
	link_params.alt = term.alt
	link_params.id = (not term.unknown_term and term.id and term.id ~= &quot;&quot;) and term.id or nil
	if not (exc and exc.suppress_tr) then
		link_params.tr = term.tr
		link_params.ts = term.ts
	else
		link_params.suppress_tr = true
	end
	link_params.lit = (opts.lit ~= &quot;suppress&quot;) and term.lit or nil
	if opts.gloss ~= &quot;suppress&quot; then
		link_params.gloss = term.t
	end
	if term.g and term.g ~= &quot;&quot; then
		local genders = M.string_utilities.split(term.g, &quot;,&quot;)
		for i = 1, #genders do
			genders[i] = M.string_utilities.trim(genders[i])
		end
		link_params.genders = genders
	end
	if opts.pos ~= &quot;suppress&quot; then
		link_params.pos = term.pos
		link_params.ng = term.ng
	end
	if exc and exc.suppress_tr then
		link_params.lit = nil
	end

	local show_qualifiers
	if opts.tree_ql ~= &quot;suppress&quot; then
		if term.q then
			link_params.q = term.q
		end
		if term.qq then
			link_params.qq = term.qq
		end
		if term.l then
			link_params.l = term.l
		end
		if term.ll then
			link_params.ll = term.ll
		end
		show_qualifiers = term.q or term.qq or term.l or term.ll
	end

	return M.links.full_link(link_params, &quot;term&quot;, nil, show_qualifiers and true or nil)
end

local __is_content_page_cached
function Util.is_content_page()
	if __is_content_page_cached == nil then
		__is_content_page_cached = M.pages.is_content_page(mw.title.getCurrentTitle())
	end
	return __is_content_page_cached
end

local __page_data_cached
function Util.get_page_data()
	if not __page_data_cached then
		__page_data_cached = M.headword_data.page
	end
	return __page_data_cached
end

-- Extract base keyword from param (without modifiers)
local function get_keyword_base(param)
	if type(param) ~= &quot;string&quot; then return nil end
	local base = param:match(&quot;^:?([^&lt;]+)&quot;) or param:gsub(&quot;^:&quot;, &quot;&quot;)
	return base
end

local function is_keyword(param, allow_colon_less)
	if type(param) ~= &quot;string&quot; then return false end
	local keywords = M.data.keywords
	if param:sub(1, 1) == &quot;:&quot; then
		local base = get_keyword_base(param)
		return keywords[base] ~= nil
	end
	if allow_colon_less then
		local base = get_keyword_base(param)
		return keywords[base] ~= nil
	end
	return false
end

local function get_keyword(param, allow_colon_less)
	if type(param) ~= &quot;string&quot; then return nil end
	local keywords = M.data.keywords
	if param:sub(1, 1) == &quot;:&quot; then
		return get_keyword_base(param)
	end
	if allow_colon_less then
		local base = get_keyword_base(param)
		if keywords[base] then
			return base
		end
	end
	return nil
end

local function normalize_keyword(keyword)
	if keyword:sub(1, 1) == &quot;:&quot; then
		return keyword
	end
	return &quot;:&quot; .. keyword
end

-- Resolve keyword (possibly an alias) to its canonical form. Used only at input boundaries
local function get_canonical_keyword(keyword)
	if not keyword then return keyword end
	return M.data.keyword_canonical[keyword] or keyword
end

-- Build text/phrase for nominalization with &lt;g:code&gt; (uses data module for codes only).
local function get_nominalization_label_for_g(code)
	if not code or code == &quot;&quot; then return nil end
	local codes = M.data.nominalization_g_codes
	local adj = codes[code]
	if not adj and #code == 2 then
		local gender_adj = codes[code:sub(1, 1)]
		local number_adj = codes[code:sub(2, 2)]
		if gender_adj and number_adj then
			adj = gender_adj .. &quot; &quot; .. number_adj
		end
	end
	if not adj then return nil end
	local text = adj:gsub(&quot;^%l&quot;, function(c) return string.upper(c) end) .. &quot; [[Appendix:Glossary#nominalization|nominalization]] of&quot;
	local phrase = M.en_utilities.add_indefinite_article(adj .. &quot; [[Appendix:Glossary#nominalization|nominalization]] of&quot;, false)
	return { text = text, phrase = phrase }
end

local EtymonParser = {}

-- Keyword modifier definitions
EtymonParser.keyword_param_mods = {
	unc = { type = &quot;boolean&quot; },
	ref = {},
	text = { restrict = { keywords = { &quot;from&quot;, &quot;derived&quot; } } },
	lit = { restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot;, &quot;univerbation&quot; } } },
	conj = {}, -- conjunction for alternatives: &quot;and&quot;, &quot;or&quot;, &quot;and/or&quot;, etc.
	g = { restrict = { keywords = { &quot;nominalization&quot; } } },
}

-- Term modifier definitions
EtymonParser.etymon_param_mods = {
	id = {},
	t = {},
	tr = {},
	ts = {},
	q = {},
	qq = {},
	l = {},
	ll = {},
	pos = {},
	ng = {},
	alt = {},
	g = {},
	ety = {},
	lit = {},
	unc = { type = &quot;boolean&quot; },
	ref = {},
	aftype = { restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot;, &quot;afeq&quot; } } },
	postype = {},
	bor = { type = &quot;boolean&quot;, restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot; } } },
	slbor = { type = &quot;boolean&quot;, restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot; } } },
	lbor = { type = &quot;boolean&quot;, restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot; } } },
}

local function get_clean_param_mods(param_mods)
	local clean = {}
	for mod_name, mod_def in pairs(param_mods) do
		clean[mod_name] = {}
		for key, value in pairs(mod_def) do
			if key ~= &quot;restrict&quot; then
				clean[mod_name][key] = value
			end
		end
	end
	return clean
end

function EtymonParser.check_modifier_restrictions(modifiers, current_keyword, param_mods)
	for mod_name, mod_value in pairs(modifiers) do
		-- Only check restrictions if the modifier has a non-false/nil value
		if mod_value then
			local mod_def = param_mods[mod_name]
			if mod_def and mod_def.restrict and mod_def.restrict.keywords then
				local allowed_keywords = mod_def.restrict.keywords
				local is_allowed = false
				for _, allowed_keyword in ipairs(allowed_keywords) do
					if current_keyword == allowed_keyword then
						is_allowed = true
						break
					end
				end
				if not is_allowed then
					local keyword_list = {}
					for _, kw in ipairs(allowed_keywords) do
						table.insert(keyword_list, &quot;:&quot; .. kw)
					end
					local keyword_str = table.concat(keyword_list, #keyword_list == 2 and &quot; or &quot; or &quot;, &quot;)
					if #keyword_list &gt; 2 then
						-- Replace last comma with &quot;or&quot;
						keyword_str = keyword_str:gsub(&quot;, ([^,]+)$&quot;, &quot; or %1&quot;)
					end
					local mod_display = mod_value == true and &quot;&lt;&quot; .. mod_name .. &quot;&gt;&quot; or &quot;&lt;&quot; .. mod_name .. &quot;:&quot; .. tostring(mod_value) .. &quot;&gt;&quot;
					error(&quot;The modifier `&quot; .. mod_display .. &quot;` is only allowed for the keyword&quot; .. (#keyword_list &gt; 1 and &quot;s &quot; or &quot; &quot;) .. keyword_str .. &quot;.&quot;)
				end
			end
		end
	end
end

-- Parse keyword with modifiers (e.g., &quot;:bor&lt;unc&gt;&quot; or &quot;:bor&lt;ref:{{R:example}}&gt;&quot;)
function EtymonParser.parse_keyword_modifiers(param)
	if type(param) ~= &quot;string&quot; then return nil, {} end

	local base_keyword = get_keyword_base(param)
	if not base_keyword then return nil, {} end

	local canonical_keyword = get_canonical_keyword(base_keyword)

	-- Check if there are any modifiers
	if not param:find(&quot;&lt;&quot;, 1, true) then
		return canonical_keyword, {}
	end

	-- Parse modifiers using the same mechanism as etymon parsing
	local rest_with_defaults = Util.add_boolean_defaults(param, EtymonParser.keyword_param_mods)

	local function generate_obj(ignored)
		return {}
	end

	local parsed = M.parse_utilities.parse_inline_modifiers(rest_with_defaults:gsub(&quot;^:?[^&lt;]+&quot;, &quot;&quot;),
		{ param_mods = get_clean_param_mods(EtymonParser.keyword_param_mods), generate_obj = generate_obj })

	local modifiers = {
		unc = parsed.unc or false,
		ref = parsed.ref,
		text = parsed.text,
		lit = parsed.lit,
		conj = parsed.conj,
		g = parsed.g,
	}

	-- Validate modifiers against restrictions
	EtymonParser.check_modifier_restrictions(modifiers, canonical_keyword, EtymonParser.keyword_param_mods)

	return canonical_keyword, modifiers
end

function EtymonParser.parse_balanced_segments(str)
	local segments = {}
	local current = &quot;&quot;
	local depth = 0
	local i = 1

	while i &lt;= #str do
		local char = str:sub(i, i)

		if char == &quot;&lt;&quot; then
			if depth == 0 and current ~= &quot;&quot; then
				table.insert(segments, current)
				current = &quot;&quot;
			end
			depth = depth + 1
			current = current .. char
		elseif char == &quot;&gt;&quot; then
			current = current .. char
			depth = depth - 1
			if depth == 0 then
				table.insert(segments, current)
				current = &quot;&quot;
			elseif depth &lt; 0 then
				error(&quot;Unbalanced brackets in etymon: unexpected '&gt;'&quot;)
			end
		else
			current = current .. char
		end

		i = i + 1
	end

	if depth ~= 0 then
		error(&quot;Unbalanced brackets in etymon: missing '&gt;'&quot;)
	end

	if current ~= &quot;&quot; then
		table.insert(segments, current)
	end

	return segments
end

function EtymonParser.parse_inline_ety(ety_string, context_lang)
	local segments = EtymonParser.parse_balanced_segments(ety_string)

	if #segments == 0 then
		error(&quot;Empty inline etymology&quot;)
	end

	local keyword = M.string_utilities.trim(segments[1])

	if not is_keyword(keyword, true) then
		error(&quot;Invalid keyword '&quot; .. keyword .. &quot;' in inline etymology &lt;ety:&quot; .. keyword .. &quot;...&gt;&quot;)
	end

	local args = { context_lang:getCode(), normalize_keyword(get_canonical_keyword(keyword)) }

	for i = 2, #segments do
		local segment = segments[i]
		if segment:sub(1, 1) == &quot;&lt;&quot; and segment:sub(-1) == &quot;&gt;&quot; then
			local inner = segment:sub(2, -2)
			if inner ~= &quot;&quot; then
				table.insert(args, inner)
			end
		elseif is_keyword(segment, true) then
			-- Handle keywords that appear between bracketed segments
			table.insert(args, normalize_keyword(get_canonical_keyword(get_keyword(segment, true))))
		end
	end

	return args
end

function EtymonParser.parse_etymon(param, context_lang)
	if is_keyword(param) then
		return nil
	end

	if type(param) ~= &quot;string&quot; then
		return nil
	end

	local lang, rest
	local is_family = false

	local before_bracket = param:match(&quot;^([^&lt;]*)&quot;) or param
	local lang_code, rest_match = before_bracket:match(&quot;^([a-zA-Z][a-zA-Z0-9._-]*):(.*)$&quot;)

	if lang_code then
		local potential_lang = Util.get_lang(lang_code, true)
		if potential_lang then
			lang = potential_lang
			rest = param:sub(#lang_code + 2)
		else
			local potential_family = Util.get_family(lang_code)
			if potential_family then
				lang = potential_family
				rest = param:sub(#lang_code + 2)
				is_family = true
			else
				lang = context_lang
				rest = param
			end
		end
	else
		lang = context_lang
		rest = param
	end

	if rest == &quot;&quot; then
		M.track(&quot;etymon/term/empty&quot;)
	elseif rest == &quot;?&quot; then
		M.track(&quot;etymon/term/question-mark&quot;)
	elseif rest == &quot;-&quot; then
		M.track(&quot;etymon/term/hyphen&quot;)
	end

	if rest == &quot;&quot; then
		return {
			lang = lang,
			term = nil,
			unknown_term = true,
			is_family = is_family,
		}
	end

	if rest == &quot;-&quot; then
		return {
			lang = lang,
			term = nil,
			suppress_term = true,
			is_family = is_family,
		}
	end

	if not rest:find(&quot;&lt;&quot;, 1, true) then
		return {
			lang = lang,
			term = M.string_utilities.trim(rest),
			is_family = is_family,
		}
	end

	local term_text = rest:match(&quot;^([^&lt;]*)&quot;) or &quot;&quot;
	local is_unknown = (term_text == &quot;&quot;)
	local is_suppress = (term_text == &quot;-&quot;)

	local function generate_obj(ignored_term)
		return { term = (is_unknown or is_suppress) and nil or M.string_utilities.trim(term_text) }
	end

	local rest_with_defaults = Util.add_boolean_defaults(rest, EtymonParser.etymon_param_mods)

	local parsed_obj = M.parse_utilities.parse_inline_modifiers(rest_with_defaults,
		{ param_mods = get_clean_param_mods(EtymonParser.etymon_param_mods), generate_obj = generate_obj })

	if parsed_obj.id and parsed_obj.id:match(&quot;^!&quot;) then
		parsed_obj.id = parsed_obj.id:sub(2)
		parsed_obj.override = true
	end

	parsed_obj.lang = lang
	parsed_obj.is_family = is_family
	if is_unknown then
		parsed_obj.unknown_term = true
	elseif is_suppress then
		parsed_obj.suppress_term = true
	end

	return parsed_obj
end

function EtymonParser.validate(lang, args, id, title, pos, starts_with_lang_code)
	-- id is now optional, so only validate if provided
	if id then
		if mw.ustring.len(id) &lt; 2 then
			error(&quot;The `id` parameter must have at least two characters.&quot;)
		end
		if id == title or id == Util.get_page_data().pagename then
			error(&quot;The `id` parameter must not be the same as the page title.&quot;)
		end
	end

	local valid_pos = { prefix = true, suffix = true, interfix = true, infix = true, root = true, word = true }
	if pos and not valid_pos[pos] then
		error(&quot;Unknown value provided for `pos`. Valid values: &quot; .. table.concat(require(&quot;Module:table&quot;).keysToList(valid_pos), &quot;, &quot;) .. &quot;.&quot;)
	end

	local current_keyword = &quot;from&quot;
	local etymons_in_group = {}
	local keywords = M.data.keywords

	local function checkGroup()
		if keywords[current_keyword] and keywords[current_keyword].is_group and current_keyword ~= &quot;affix&quot; and current_keyword ~= &quot;surf&quot; and current_keyword ~= &quot;afeq&quot; and current_keyword ~= &quot;univerbation&quot; and #etymons_in_group &lt;= 1 then
			error(&quot;Detected `:&quot; .. current_keyword .. &quot;` group with fewer than two etymons.&quot;)
		end
		etymons_in_group = {}
	end

	local start_index = starts_with_lang_code and 2 or 1

	for i = start_index, #args do
		local param = args[i]

		if type(param) ~= &quot;string&quot; then
		elseif param:sub(1, 1) == &quot;:&quot; and not is_keyword(param) then
			error(&quot;Invalid keyword '&quot; .. param .. &quot;'. Did you mean a valid keyword like ':bor', ':inh', etc.?&quot;)
		elseif is_keyword(param) then
			checkGroup()
			current_keyword = get_canonical_keyword(get_keyword(param))
		else
			local etymon_data = EtymonParser.parse_etymon(param, lang)
			if etymon_data then
				table.insert(etymons_in_group, param)
				local param_lang = etymon_data.lang

				if etymon_data.is_family and current_keyword == &quot;inherited&quot; then
					error(&quot;`:inh` does not support family codes; use a specific language.&quot;)
				end
				if etymon_data.is_family and not etymon_data.suppress_term then
					error(&quot;Family codes require suppressed term (use family:-).&quot;)
				end
				if current_keyword == &quot;from&quot; and param_lang:getFullCode() ~= lang:getFullCode() then
					error(&quot;`:from` is for same-language derivation, but language does not match. &quot; ..
						&quot;Expected '&quot; .. lang:getFullCode() .. &quot;', got '&quot; .. param_lang:getFullCode() .. &quot;'.&quot;)
				elseif current_keyword == &quot;inherited&quot; then
					M.etymology.check_ancestor(lang, param_lang)
				end

				-- Check modifier restrictions
				EtymonParser.check_modifier_restrictions(etymon_data, current_keyword, EtymonParser.etymon_param_mods)

				-- postype must be &quot;root&quot; or &quot;word&quot;
				local VALID_POSTYPES = { root = true, word = true }
				if etymon_data.postype and not VALID_POSTYPES[etymon_data.postype] then
					error(&quot;Invalid &lt;postype:&quot; .. etymon_data.postype .. &quot;&gt;; must be \&quot;root\&quot; or \&quot;word\&quot;.&quot;)
				end

				if etymon_data.ety then
					local inline_args = EtymonParser.parse_inline_ety(etymon_data.ety, etymon_data.lang)
					EtymonParser.validate(etymon_data.lang, inline_args, nil, nil, nil, true)
				end
			else
				table.insert(etymons_in_group, param)
			end
		end
	end

	checkGroup()
end

local DataRetriever = {}

-- Given an etymon data, scrape its page and cache the result in the global state object.
function DataRetriever.cache_page_etymons(etymon_page, etymon_title, key, etymon_lang, etymon_id, redirected_from, descendants_is_toplevel)
	local content = etymon_title:getContent()
	if not content then
		__state.cached_etymon_args[key] = M.data.STATUS.REDLINK
		return
	end

	-- Check if the linked page is a redirect. If it is, the template parsing
	-- code below will be effectively skipped, and `scrape_page` will be called
	-- again on the redirect target (see the bottom of this function)
	local lang_section_for_descendants = nil
	local redirect_target = etymon_title.redirect_target
	if not redirect_target then
		content = M.pages.get_section(content, etymon_lang:getFullName(), 2)
		if not content then
			__state.cached_etymon_args[key] = M.data.STATUS.MISSING
			return
		end
		lang_section_for_descendants = content
	end

	local etymon_lang_code = etymon_lang:getFullCode()
	local lang_page_key = etymon_lang_code .. &quot;:&quot; .. etymon_page
	local found_templates_for_lang = {}
	local found_ids = {}
	local get_node_class = M.template_parser.class_else_type

	-- Look for all {{etymon}} templates within the page content using the template parser
	-- This way the same page is never parsed more than once

	-- Build a map from senseids to their parent etymonids.
	local active_etymon_args = nil

	for node in M.template_parser.parse(content):iterate_nodes() do
		local node_class = get_node_class(node)

		if node_class == &quot;heading&quot; then
			-- A new L2 or etymology section acts as a barrier: an {{etymon}} usage
			-- used previously cannot be the parent of any subsequent senseids.
			-- Note that we don't have to check for L2s due to the usage of `M.pages.get_section` above.
			if node:get_name():find(&quot;^Etymology&quot;) then
				active_etymon_args = nil
			end
		elseif node_class == &quot;template&quot; then
			local template_name = node:get_name()

			if template_name == &quot;etymon&quot; then
				local template_args = node:get_arguments()

				-- Check if this etymon is for our language
				if template_args[1] == etymon_lang_code then
					table.insert(found_templates_for_lang, template_args)

					if template_args.id then
						local etymon_key = lang_page_key .. &quot;:&quot; .. template_args.id
						__state.cached_etymon_args[etymon_key] = template_args
						__state.cached_etymon_pages[etymon_key] = tostring(etymon_page)
						table.insert(found_ids, template_args.id)
						active_etymon_args = template_args
					else
						-- Store idless etymon with default key
						local etymon_key = lang_page_key .. &quot;:*&quot;
						__state.cached_etymon_args[etymon_key] = template_args
						__state.cached_etymon_pages[etymon_key] = tostring(etymon_page)
						table.insert(found_ids, &quot;*&quot;)
						active_etymon_args = template_args
					end
				end
			elseif active_etymon_args and template_name == &quot;senseid&quot; then
				local template_args = node:get_arguments()

				-- This should always be true for proper usages of {{senseid}}.
				if template_args[1] == etymon_lang_code and template_args[2] then
					local sense_id_key = lang_page_key .. &quot;:&quot; .. template_args[2]
					__state.senseid_parent_etymon[sense_id_key] = active_etymon_args
					__state.cached_etymon_pages[sense_id_key] = tostring(etymon_page)
				end
			end
		end
	end

	if descendants_is_toplevel and lang_section_for_descendants and #found_templates_for_lang &gt; 0 then
		M.descendants.cache_page_checks({
			lang_section = lang_section_for_descendants,
			etymon_lang_code = etymon_lang_code,
			found_templates_for_lang = found_templates_for_lang,
			entry_title = __state.entry_title,
			entry_lang_code = __state.entry_lang_code,
			entry_lang = __state.entry_lang_code and Util.get_lang(__state.entry_lang_code, true) or nil,
			cached_descendants_checks = __state.cached_descendants_checks,
			lang_page_key = lang_page_key,
			redirected_from = redirected_from,
		})
	end

	local id_data_list = {}
	for _, args in ipairs(found_templates_for_lang) do
		local id = args.id or &quot;*&quot;
		table.insert(id_data_list, { id = id, pos = args.pos })
	end
	__state.available_etymon_ids[lang_page_key] = id_data_list

	if #found_templates_for_lang == 1 then
		__state.single_etymons[lang_page_key] = found_templates_for_lang[1]
	end

	if redirected_from and __state.available_etymon_ids[lang_page_key] then
		__state.available_etymon_ids[redirected_from] = __state.available_etymon_ids[redirected_from] or {}
		for _, id_data in ipairs(__state.available_etymon_ids[lang_page_key]) do
			table.insert(__state.available_etymon_ids[redirected_from], id_data)
		end
	end

	if __state.cached_etymon_args[key] ~= nil or __state.senseid_parent_etymon[key] ~= nil then
		-- All done!
		return
	elseif redirect_target and not redirected_from then
		-- Try scraping the redirect.
		etymon_page = redirect_target.prefixedText
		DataRetriever.cache_page_etymons(etymon_page, redirect_target, lang_page_key .. &quot;:&quot; .. etymon_id, etymon_lang, etymon_id, lang_page_key, descendants_is_toplevel)
		__state.cached_etymon_args[key] = __state.cached_etymon_args[etymon_lang_code .. &quot;:&quot; .. etymon_page .. &quot;:&quot; .. etymon_id]
	else
		__state.cached_etymon_args[key] = M.data.STATUS.MISSING
	end
end

-- Given an etymon object, scrape its page (if necessary) and return its own etymon arguments as well as the page name.
function DataRetriever.get_etymon_args(etymon_data, is_toplevel)
	local page = M.links.get_link_page(etymon_data.term, etymon_data.lang)
	local norm_lang = Util.get_norm_lang(etymon_data.lang)
	local base_key = norm_lang:getFullCode() .. &quot;:&quot; .. page

	if etymon_data.id then
		local key = base_key .. &quot;:&quot; .. etymon_data.id

		local cached_args = __state.cached_etymon_args[key] or __state.senseid_parent_etymon[key]
		if cached_args == nil then
			local title = mw.title.new(page)
			if not title then error('Invalid page title &quot;' .. page .. '&quot; encountered.') end
			DataRetriever.cache_page_etymons(page, title, key, norm_lang, etymon_data.id, nil, is_toplevel)
		end
		cached_args = __state.cached_etymon_args[key] or __state.senseid_parent_etymon[key] -- refresh

		-- Get etymon_id from parent if this was resolved via senseid
		local parent_etymon = __state.senseid_parent_etymon[key]
		local resolved_etymon_id = parent_etymon and parent_etymon.id
		local descendants_check = M.descendants.get_lookup_check({
			cached_descendants_checks = __state.cached_descendants_checks,
			is_toplevel = is_toplevel,
			base_key = base_key,
			lookup = {
				explicit_id = etymon_data.id,
				parent_etymon = parent_etymon,
			},
		})
		if is_toplevel and descendants_check == nil then
			local title = mw.title.new(page)
			if title then
				DataRetriever.cache_page_etymons(page, title, key, norm_lang, etymon_data.id, nil, true)
				descendants_check = M.descendants.get_lookup_check({
					cached_descendants_checks = __state.cached_descendants_checks,
					is_toplevel = true,
					base_key = base_key,
					lookup = {
						explicit_id = etymon_data.id,
						parent_etymon = parent_etymon,
					},
				})
			end
		end
		return cached_args, __state.cached_etymon_pages[key], resolved_etymon_id, descendants_check
	else
		__state.used_idless_etymon = true
		if is_toplevel then
			__state.toplevel_idless_etymon = true
		end

		if __state.available_etymon_ids[base_key] == nil then
			local title = mw.title.new(page)
			if not title then error('Invalid page title &quot;' .. page .. '&quot; encountered.') end
			DataRetriever.cache_page_etymons(page, title, base_key .. &quot;:*&quot;, norm_lang, &quot;*&quot;, nil, is_toplevel)
		end

		local ids = __state.available_etymon_ids[base_key] or {}
		local count = #ids

		-- Try to filter by postype if available and we have multiple candidates
		if count &gt; 1 and etymon_data.postype then
			local matching_ids = {}
			for _, id_data in ipairs(ids) do
				if id_data.pos == etymon_data.postype then
					table.insert(matching_ids, id_data)
				end
			end
			
			if #matching_ids == 1 then
				local matched_id = matching_ids[1].id
				local matched_key = base_key .. &quot;:&quot; .. matched_id
				local descendants_check = M.descendants.get_lookup_check({
					cached_descendants_checks = __state.cached_descendants_checks,
					is_toplevel = is_toplevel,
					base_key = base_key,
					lookup = { id = matched_id },
				})
				if is_toplevel and descendants_check == nil then
					local title = mw.title.new(page)
					if title then
						DataRetriever.cache_page_etymons(page, title, base_key .. &quot;:*&quot;, norm_lang, &quot;*&quot;, nil, true)
						descendants_check = M.descendants.get_lookup_check({
							cached_descendants_checks = __state.cached_descendants_checks,
							is_toplevel = true,
							base_key = base_key,
							lookup = { id = matched_id },
						})
					end
				end
				return __state.cached_etymon_args[matched_key], __state.cached_etymon_pages[matched_key], nil, descendants_check
			end
		end

		if count == 1 then
			local only_id_data = ids[1]
			local only_id = (type(only_id_data) == &quot;table&quot; and only_id_data.id) or only_id_data or &quot;*&quot;
			local descendants_check = M.descendants.get_lookup_check({
				cached_descendants_checks = __state.cached_descendants_checks,
				is_toplevel = is_toplevel,
				base_key = base_key,
				lookup = { id_data = only_id_data },
			})
			if is_toplevel and descendants_check == nil then
				local title = mw.title.new(page)
				if title then
					DataRetriever.cache_page_etymons(page, title, base_key .. &quot;:*&quot;, norm_lang, &quot;*&quot;, nil, true)
					descendants_check = M.descendants.get_lookup_check({
						cached_descendants_checks = __state.cached_descendants_checks,
						is_toplevel = true,
						base_key = base_key,
						lookup = { id_data = only_id_data },
					})
				end
			end
			return __state.single_etymons[base_key], __state.cached_etymon_pages[base_key .. &quot;:&quot; .. only_id], nil, descendants_check
		elseif count &gt; 1 then
			local page_link = M.links.full_link({
				term = page,
				lang = norm_lang,
				no_generate_forms = true,
			}, &quot;term&quot;)

			local function format_id_hint(id_data, idx)
				local id = type(id_data) == &quot;table&quot; and id_data.id or id_data
				local pos = type(id_data) == &quot;table&quot; and id_data.pos
				if id and id ~= &quot;&quot; and id ~= &quot;*&quot; then
					return '&quot;' .. id .. '&quot;'
				end
				if pos and pos ~= &quot;&quot; then
					return &quot;unnamed (|pos=&quot; .. pos .. &quot;|)&quot;
				end
				return &quot;etymon #&quot; .. idx .. &quot; (no |id= on page)&quot;
			end

			local id_list = {}
			local all_idless = true
			local target_has_idless = false
			for i, id_data in ipairs(ids) do
				local id = type(id_data) == &quot;table&quot; and id_data.id or id_data
				if id and id ~= &quot;&quot; and id ~= &quot;*&quot; then
					all_idless = false
				else
					target_has_idless = true
				end
				table.insert(id_list, format_id_hint(id_data, i))
			end

			if is_toplevel and target_has_idless then
				__state.linked_page_multiple_etymons_idless = true
			end

			local any_pos = false
			for _, id_data in ipairs(ids) do
				local pos = type(id_data) == &quot;table&quot; and id_data.pos
				if pos and pos ~= &quot;&quot; then
					any_pos = true
					break
				end
			end

			local suggestion_text
			local lead = &quot;Etymology link to &quot; .. page_link .. &quot; is ambiguous (&quot; .. count .. &quot; {{etymon}} templates for &quot;
				.. norm_lang:getCanonicalName() .. &quot;).&quot;
			if all_idless then
				if any_pos then
					suggestion_text = &quot; None set `|id=` yet; add a unique `|id=` to each on &quot; .. page_link
						.. &quot;, then `&lt;id:identifier&gt;` after the term here. Section order / hints: &quot;
						.. mw.text.listToText(id_list) .. &quot;.&quot;
				else
					suggestion_text = &quot; None set `|id=` yet; add a unique `|id=` to each {{etymon}} in that section from top to bottom, then `&lt;id:identifier&gt;` after the term here (same value as `|id=`).&quot;
				end
			else
				suggestion_text = &quot; Specify which one with `&lt;id:identifier&gt;` after the term. Options: &quot; .. mw.text.listToText(id_list) .. &quot;.&quot;
			end

			Util.add_warning(lead .. suggestion_text, true)

			return M.data.STATUS.AMBIGUOUS, nil, nil, nil
		else
			return M.data.STATUS.MISSING, nil, nil, nil
		end
	end
end

local TreeBuilder = {}

local function parse_etymon_references(refs_text)
	if not refs_text or refs_text == &quot;&quot; then
		return &quot;&quot;
	end
	return M.references.parse_references(refs_text)
end

local function parse_tree_references(node)
	if node.ref then
		node.parsed_ref = parse_etymon_references(node.ref)
	end

	if node.children then
		for _, container in ipairs(node.children) do
			if container.terms then
				for _, term in ipairs(container.terms) do
					parse_tree_references(term)
				end
			end
		end
	end
end

-- Build a unique key for deduplication in the seen table
function TreeBuilder.build_key(lang, title, args)
	local norm_lang_code = Util.get_norm_lang(lang):getFullCode()
	local is_table = type(args) == &quot;table&quot;
	local id = (is_table and args.id) or &quot;&quot;
	
	if title then
		return norm_lang_code .. &quot;:&quot; .. M.links.get_link_page(title, lang) .. &quot;:&quot; .. id
	end
	
	if is_table and args.status == M.data.STATUS.INLINE then
		local content_parts = {}
		for i = 1, #args do
			content_parts[i] = tostring(args[i])
		end
		return norm_lang_code .. &quot;:*:&quot; .. id .. &quot;\0&quot; .. table.concat(content_parts, &quot;\0&quot;)
	end
	
	return norm_lang_code .. &quot;:*:&quot; .. id
end

function TreeBuilder.build(lang, title, args, seen, depth, stop_recursion)
	seen = seen or {}
	depth = depth or 0
	local is_toplevel = (depth == 0)

	if depth &gt; __state.max_depth_reached then
		__state.max_depth_reached = depth
	end

	__state.total_nodes = __state.total_nodes + 1

	local lang_code = lang:getCode()
	__state.language_count[lang_code] = (__state.language_count[lang_code] or 0) + 1

	local current_id = (type(args) == &quot;table&quot; and args.id) or &quot;&quot;
	local key = TreeBuilder.build_key(lang, title, args)
	
	local node = { lang = lang, title = title, id = current_id, args = args, children = {}, status = M.data.STATUS.OK }

	if type(args) ~= &quot;table&quot; or seen[key] then
		node.status = args or M.data.STATUS.MISSING
		-- Mark as duplicate if we've seen this node before
		if seen[key] then
			node.is_duplicate = true
			node.duplicate_key = key
			local original_node = seen[key]
			if type(original_node) == &quot;table&quot; and original_node.children and #original_node.children &gt; 0 then
				node.original_has_children = true
			end
		end
		return node
	end

	node.status = args.status or M.data.STATUS.OK

	seen[key] = node

	-- If stop_recursion is set, skip parsing children but check for visible children
	if stop_recursion then
		local keywords = M.data.keywords
		local has_visible_children = false
		for i = 2, #args do
			local param = args[i]
			if type(param) == &quot;string&quot; then
				local keyword_base = get_keyword_base(param)
				if keyword_base and keywords[keyword_base] then
					-- It's a keyword, check if visible in tree (invisible &quot;all&quot; or &quot;tree&quot; = hidden in tree)
					local keyword_info = keywords[keyword_base]
					local inv = keyword_info.invisible
					if not (inv == &quot;all&quot; or inv == true or inv == &quot;tree&quot;) then
						has_visible_children = true
						break
					end
				elseif param:sub(1, 1) ~= &quot;:&quot; then
					-- It's a term (not a keyword), so there are visible children
					has_visible_children = true
					break
				end
			end
		end
		node.has_visible_children = has_visible_children
		return node
	end

	-- Parse args into keyword containers
	local current_keyword = &quot;from&quot;
	local current_keyword_modifiers = {}
	local current_container = nil

	-- Helper to track keyword usage at top level
	local function track_keyword_usage(keyword, target_lang, source_lang)
		if not is_toplevel then return end

		if not __state.toplevel_keyword_stats[keyword] then
			__state.toplevel_keyword_stats[keyword] = {
				count = 0,
				target_langs = {},
				source_langs = {},
			}
		end

		local keyword_data = __state.toplevel_keyword_stats[keyword]
		keyword_data.count = keyword_data.count + 1

		local target_code = target_lang:getCode()
		keyword_data.target_langs[target_code] = (keyword_data.target_langs[target_code] or 0) + 1

		if source_lang then
			local source_code = source_lang:getCode()
			keyword_data.source_langs[source_code] = (keyword_data.source_langs[source_code] or 0) + 1
		end
	end

	local function ensure_container()
		if not current_container or current_container.keyword ~= current_keyword then
			current_container = {
				keyword = current_keyword,
				keyword_info = M.data.keywords[current_keyword],
				keyword_modifiers = current_keyword_modifiers,
				terms = {},
			}
			table.insert(node.children, current_container)
			-- Override keyword text/phrase for nominalization with &lt;g:code&gt;
			if current_keyword_modifiers.g and current_keyword == &quot;nominalization&quot; then
				local labels = get_nominalization_label_for_g(current_keyword_modifiers.g)
				if not labels then
					local codes = {}
					for c in pairs(M.data.nominalization_g_codes) do table.insert(codes, c) end
					table.sort(codes)
					error(&quot;Invalid &lt;g:&quot; .. tostring(current_keyword_modifiers.g) .. &quot;&gt;. Supported codes for nominalization: &quot; .. table.concat(codes, &quot;, &quot;))
				end
				current_container.keyword_info = {}
				for k, v in pairs(M.data.keywords[current_keyword]) do current_container.keyword_info[k] = v end
				current_container.keyword_info.text = labels.text
				current_container.keyword_info.phrase = labels.phrase
			end
		end
	end

	for i = 2, #args do
		local param = args[i]

		if is_keyword(param) then
			local keyword, modifiers = EtymonParser.parse_keyword_modifiers(param)
			current_keyword = keyword
			current_keyword_modifiers = modifiers
			current_container = nil -- Force new container for new keyword
		elseif type(param) == &quot;string&quot; and param:sub(1, 1) == &quot;:&quot; then
			error(&quot;Invalid keyword '&quot; .. param .. &quot;'. Did you mean a valid keyword like ':bor', ':inh', etc.?&quot;)
		elseif type(param) == &quot;string&quot; then
			local etymon_data = EtymonParser.parse_etymon(param, lang)

			if etymon_data then
				-- Track keyword usage at top level
				track_keyword_usage(current_keyword, lang, etymon_data.lang)

				local term_node = {}

				-- Handle suppress_term (-) and unknown_term (empty) directly
				if etymon_data.suppress_term or etymon_data.unknown_term then
					ensure_container()
					if etymon_data.ety then
						local inline_args = EtymonParser.parse_inline_ety(etymon_data.ety, etymon_data.lang)
						inline_args.id = etymon_data.id
						inline_args.status = M.data.STATUS.INLINE
						term_node = TreeBuilder.build(etymon_data.lang, nil, inline_args, seen, depth + 1)
					else
						term_node = {
							lang = etymon_data.lang,
							children = {},
							status = M.data.STATUS.OK,
						}
					end
					term_node.suppress_term = etymon_data.suppress_term
					term_node.unknown_term = etymon_data.unknown_term
					term_node.is_family = etymon_data.is_family
					term_node.is_uncertain = etymon_data.unc
					term_node.ref = etymon_data.ref
					term_node.t = etymon_data.t
					term_node.tr = etymon_data.tr
					term_node.ts = etymon_data.ts
					term_node.alt = etymon_data.alt
					term_node.g = etymon_data.g
					term_node.pos = etymon_data.pos
					term_node.ng = etymon_data.ng
					term_node.lit = etymon_data.lit
					term_node.q = etymon_data.q
					term_node.qq = etymon_data.qq
					term_node.l = etymon_data.l
					term_node.ll = etymon_data.ll
				else
					-- Regular term: fetch arguments from page
					local etymon_args, page_of, resolved_etymon_id, descendants_check = DataRetriever.get_etymon_args(etymon_data, is_toplevel)

					if etymon_data.id and etymon_args == M.data.STATUS.MISSING and not etymon_data.ety then
						local page = M.links.get_link_page(etymon_data.term, etymon_data.lang)
						local norm_lang = Util.get_norm_lang(etymon_data.lang)
						local base_key = norm_lang:getFullCode() .. &quot;:&quot; .. page
						local available_ids = __state.available_etymon_ids[base_key] or {}

						if #available_ids &gt; 0 then
							__state.has_mismatched_id = true
						end
					end

					-- Check for &lt;ety&gt; inline parameter doesn't override the scraped arguments, unless the latter are missing
					if etymon_data.ety then
						if etymon_args == M.data.STATUS.REDLINK or etymon_args == M.data.STATUS.MISSING then
							__state.current_page_has_inline_etymology = true
							if is_toplevel then
								__state.toplevel_has_inline_etymology = true
							end

							local inline_args = EtymonParser.parse_inline_ety(etymon_data.ety, etymon_data.lang)

							-- Track inline ety keywords too
							local inline_keyword = get_keyword(inline_args[2], true)
							if inline_keyword and #inline_args &gt;= 3 then
								local inline_etymon = EtymonParser.parse_etymon(inline_args[3], etymon_data.lang)
								if inline_etymon then
									track_keyword_usage(inline_keyword, etymon_data.lang, inline_etymon.lang)
								end
							end

							inline_args.id = etymon_data.id
							inline_args.status = M.data.STATUS.INLINE
							etymon_args = inline_args
							term_node.page_of = __state.cached_etymon_pages[key] -- term node is on the same page as the parent
						else
							-- Scraped arguments exist, &lt;ety&gt; is redundant and ignored
							__state.current_page_has_redundant_etymology = true
							if is_toplevel then
								__state.toplevel_redundant_etymology = true
							end
						end
					end

					-- Ensure container exists before checking keyword info
					ensure_container()
					
					-- Check if current keyword has no_child_categories - if so, stop recursion
					local keyword_info = current_container.keyword_info
					local should_stop_recursion = (stop_recursion or (keyword_info and keyword_info.no_child_categories))
					
					term_node = TreeBuilder.build(etymon_data.lang, etymon_data.term, etymon_args, seen, depth + 1, should_stop_recursion)
					term_node.target_key = Util.get_norm_lang(etymon_data.lang):getFullCode() ..
						&quot;:&quot; .. M.links.get_link_page(etymon_data.term, etymon_data.lang)
					term_node.id = etymon_data.id
					term_node.etymon_id = resolved_etymon_id  -- The actual etymon id when resolved via senseid
					term_node.t = etymon_data.t
					term_node.tr = etymon_data.tr
					term_node.ts = etymon_data.ts
					term_node.pos = etymon_data.pos
					term_node.alt = etymon_data.alt
					term_node.g = etymon_data.g
					term_node.ng = etymon_data.ng
					term_node.ref = etymon_data.ref
					term_node.is_uncertain = etymon_data.unc
					term_node.override = etymon_data.override
					term_node.page_of = page_of
					term_node.aftype = etymon_data.aftype
					term_node.postype = etymon_data.postype
					term_node.bor = etymon_data.bor
					term_node.lbor = etymon_data.lbor
					term_node.slbor = etymon_data.slbor
					term_node.lit = etymon_data.lit
					term_node.is_family = etymon_data.is_family
					term_node.q = etymon_data.q
					term_node.qq = etymon_data.qq
					term_node.l = etymon_data.l
					term_node.ll = etymon_data.ll
					term_node.missing_descendants_header, term_node.missing_descendants_entry =
						M.descendants.get_term_sync_flags(current_keyword, term_node.status, descendants_check)
				end

				table.insert(current_container.terms, term_node)
			end
		end
	end

	return node
end

-- Convert etymology tree to JSON-serializable table
local function tree_to_json(node)
	local obj = {
		term = node.title,
		lang = node.lang:getCode(),
		lang_name = node.lang:getCanonicalName(),
		id = (node.id and node.id ~= &quot;&quot;) and node.id or nil,
		status = node.status,
		is_uncertain = node.is_uncertain or nil,
		is_duplicate = node.is_duplicate or nil,
		gloss = node.t,
		transliteration = node.tr,
		transcription = node.ts,
		alt = node.alt,
		g = node.g,
		pos = node.pos,
		ng = node.ng,
		children = {},
	}

	for _, container in ipairs(node.children or {}) do
		local keyword_info = container.keyword_info
		if keyword_info then
			local container_obj = {
				keyword = container.keyword,
				keyword_label = keyword_info.text,
				keyword_abbrev = keyword_info.abbrev,
				is_group = keyword_info.is_group or nil,
				is_invisible = keyword_info.invisible or nil,
				is_uncertain = (container.keyword_modifiers and container.keyword_modifiers.unc) or nil,
				terms = {},
			}

			for _, term in ipairs(container.terms or {}) do
				table.insert(container_obj.terms, tree_to_json(term))
			end

			table.insert(obj.children, container_obj)
		end
	end

	return obj
end

local function track_ranges(base_key, value, ranges, lang_code)
	M.track(&quot;etymon/&quot; .. base_key .. &quot;/&quot; .. value)
	if lang_code then
		M.track(&quot;etymon/lang/&quot; .. lang_code .. &quot;/&quot; .. base_key .. &quot;/&quot; .. value)
	end

	for _, range in ipairs(ranges) do
		local matches = false
		if range.min and range.max then
			matches = value &gt;= range.min and value &lt;= range.max
		elseif range.min then
			matches = value &gt;= range.min
		elseif range.max then
			matches = value &lt;= range.max
		elseif range.exact then
			matches = value == range.exact
		end

		if matches then
			M.track(&quot;etymon/&quot; .. base_key .. &quot;/&quot; .. range.label)
			if lang_code then
				M.track(&quot;etymon/lang/&quot; .. lang_code .. &quot;/&quot; .. base_key .. &quot;/&quot; .. range.label)
			end
			break
		end
	end
end

local function track_title_pagename_mismatch_after_strip(lang)
	local lang_code = lang:getCode()
	M.track(&quot;etymon/title/pagename-mismatch-after-strip-diacritics&quot;)
	M.track(&quot;etymon/lang/&quot; .. lang_code .. &quot;/title/pagename-mismatch-after-strip-diacritics&quot;)
end

-- Build and return the etymology data tree for a given term.
function export.get_tree(lang, title, args, options)
	options = options or {}
	__state.entry_title = title
	__state.entry_lang_code = lang:getCode()

	if options.validate then
		EtymonParser.validate(lang, args, options.id, title, options.pos, false)
	end

	local lang_code = lang:getCode()

	local start_index = (args[1] == lang_code) and 2 or 1
	local tree_args = { [1] = lang_code, id = options.id or args.id }
	for i = start_index, #args do
		table.insert(tree_args, args[i])
	end

	__state.cached_etymon_args[lang_code .. &quot;:&quot; .. title .. &quot;:&quot; .. (tree_args.id or &quot;&quot;)] = tree_args

	local ety_data_tree = TreeBuilder.build(lang, title, tree_args)
	parse_tree_references(ety_data_tree)

	if options.json then
		return M.JSON.toJSON(tree_to_json(ety_data_tree))
	end

	return ety_data_tree
end

-- Given a language code, page name and optionally the id= parameter,
-- render the tree and only the etymology tree for the relevant page.
-- Fetches and parses the corresponding {{etymon}} from the requested page,
-- and any further pages needed to render the tree.
-- Parameters can be passed either through the #invoke or as
-- template parameters *through* an #invoke.
function export.render_tree_for_etymon_on_page(frame)
	local frame_args = frame.args
	local parent_args = frame:getParent().args
	local langcode = frame_args[1] or parent_args[1]
	local pagename = frame_args[2] or parent_args[2]
	local id = frame_args[&quot;id&quot;] or parent_args[&quot;id&quot;]
	local display_title = frame_args[&quot;title&quot;] or parent_args[&quot;title&quot;]

	local parsed_title = mw.title.new(pagename, 0)
	local title
	if parsed_title.namespace == 0 then
		title = M.pages.safe_page_name(parsed_title)
	elseif parsed_title.namespace == 118 then
		title = &quot;*&quot; .. M.pages.safe_page_name(parsed_title)
	else
		error(&quot;Unsupported namespace for render_tree_for_etymon_on_page: &quot; .. parsed_title.namespace)
	end

	local lang = Util.get_lang(langcode)
	-- Construct etymon_data for DataRetriever.get_args.
	local etymon_data = {
		lang = lang,
		term = title,
		id = id
	}
	local args, pagename = DataRetriever.get_etymon_args(etymon_data, true)
	if args == M.data.STATUS.MISSING then
		error(&quot;The etymon template was not found (language &quot; ..
			langcode ..
			&quot;, title '&quot; ..
			title ..
			&quot;'&quot; ..
			(id and &quot;, ID '&quot; .. id .. &quot;'&quot; or &quot;, no ID given&quot;) .. &quot;). Page contents may have changed in the interim.&quot;)
	end

	local tree_title = display_title or title
	if lang:stripDiacritics(M.links.remove_links(tree_title)) ~= lang:stripDiacritics(M.links.remove_links(title)) then
		track_title_pagename_mismatch_after_strip(lang)
	end

	local ety_data_tree = export.get_tree(lang, tree_title, args, {
		validate = true,
		id = id,
	})

	local output = {}
	table.insert(output, M.template_styles(&quot;Module:etymon/styles.css&quot;))
	table.insert(output, M.tree.render({
		data_tree = ety_data_tree,
		format_term_func = function(term, is_toplevel)
			return Util.format_term(term, is_toplevel, {
				gloss = &quot;suppress&quot;,
				pos = &quot;suppress&quot;,
				lit = &quot;suppress&quot;,
				tree_ql = &quot;suppress&quot;,
			})
		end,
	}))

	return table.concat(output)
end

function export.main(frame)
	local parent_args = frame:getParent().args
	local args = M.parameters.process(parent_args, M.parameters_data.etymon)
	local lang = args[1]
	local etymon_args = args[2]
	local id = args.id
	local title = args.title
	local text = args.text
	local tree = args.tree
	local etydate = args.etydate
	local rfe = args.rfe
	local page_data = Util.get_page_data()

	if not title then
		title = page_data.pagename
		if page_data.namespace == &quot;Reconstruction&quot; then title = &quot;*&quot; .. title end
	end

	local entry_pagename = page_data.pagename
	if page_data.namespace == &quot;Reconstruction&quot; then
		entry_pagename = &quot;*&quot; .. entry_pagename
	end
	if lang:stripDiacritics(M.links.remove_links(title)) ~= lang:stripDiacritics(M.links.remove_links(entry_pagename)) then
		track_title_pagename_mismatch_after_strip(lang)
	end

	local current_L2 = M.pages.get_current_L2()
	if current_L2 then
		local norm_lang = Util.get_norm_lang(lang)
		local norm_name = norm_lang:getCanonicalName()
		if current_L2 ~= norm_name then
			local lang_desc = lang:getCode() .. &quot; (&quot; .. lang:getCanonicalName() .. &quot;)&quot;
			if norm_lang:getCode() ~= lang:getCode() then
				lang_desc = lang_desc .. &quot;, normalized to &quot; .. norm_lang:getCode() .. &quot; (&quot; .. norm_name .. &quot;)&quot;
			end
			error(&quot;Language '&quot; .. lang_desc .. &quot;' does not match the L2 header (&quot; .. current_L2 .. &quot;).&quot;)
		end
	end

	local ety_data_tree = export.get_tree(lang, title, etymon_args, {
		validate = true,
		pos = args.pos,
		id = id,
		json = args.json,
	})

	if args.json then
		return ety_data_tree
	end

	local output = {}

	local text_allowlist_mode = M.text_allowed.default_mode or &quot;off&quot;
	if text and text_allowlist_mode ~= &quot;off&quot; and not Util.is_text_param_allowed_for_lang(lang) then
		local msg = &quot;Etymology texts (parameter &lt;code&gt;text=&lt;/code&gt;) are not allowed for &quot; .. lang:getFullName() ..
			&quot;; see [[Template:etymon#Text allowlist|Template:etymon § Text allowlist]] for the list of languages that may use the &lt;code&gt;text=&lt;/code&gt; parameter.&quot;
		if text_allowlist_mode == &quot;error&quot; then
			error(msg)
		else
			Util.add_warning(msg, true)
		end
	end

	local lang_exc = Util.get_lang_exception(lang)
	if lang_exc and lang_exc.disallow then
		local disallow = lang_exc.disallow
		local error_text = &quot; for &quot; .. lang:getFullName()
		if disallow.ref then
			error_text = error_text .. &quot;; see &quot; .. disallow.ref
		else
			error_text = error_text .. &quot;.&quot;
		end
		if tree and disallow.tree then
			error(&quot;Etymology trees are not allowed&quot; .. error_text)
		end
		if text and disallow.text then
			error(&quot;Etymology texts are not allowed&quot; .. error_text)
		end
	end

	if etydate then
		local etydate_param_mods = {
			ref = { list = true, type = &quot;references&quot;, allow_holes = true },
			refn = { list = true, allow_holes = true },
			nocap = { type = &quot;boolean&quot; },
		}

		local function generate_etydate_obj(etydate_text)
			local etydate_specs = {}
			for spec in etydate_text:gmatch(&quot;[^,]+&quot;) do
				table.insert(etydate_specs, mw.text.trim(spec))
			end
			return { [1] = etydate_specs }
		end

		local parsed_etydate = M.parse_utilities.parse_inline_modifiers(etydate, { param_mods = etydate_param_mods, generate_obj = generate_etydate_obj })

		local etydate_args = {
			[1] = parsed_etydate[1],
			nocap = parsed_etydate.nocap or false,
		}

		ety_data_tree.etydate = M.etydate.format_etydate(etydate_args, { omit_refs = true })

		if parsed_etydate.ref and #parsed_etydate.ref &gt; 0 then
			ety_data_tree.etydate_refs = parsed_etydate.ref
		end
	end

	if tree then
		table.insert(output, M.template_styles(&quot;Module:etymon/styles.css&quot;))
		table.insert(output, M.tree.render({
			data_tree = ety_data_tree,
			format_term_func = function(term, is_toplevel)
				return Util.format_term(term, is_toplevel, {
					gloss = &quot;suppress&quot;,
					pos = &quot;suppress&quot;,
					lit = &quot;suppress&quot;,
					tree_ql = &quot;suppress&quot;,
				})
			end,
		}))
	end

	-- Check if there are any visible children in tree (invisible &quot;all&quot; or &quot;tree&quot; = hidden in tree)
	local has_visible_children = false
	for _, child in ipairs(ety_data_tree.children or {}) do
		local child_keyword_info = child.keyword_info
		local inv = child_keyword_info and child_keyword_info.invisible
		if not (inv == &quot;all&quot; or inv == true or inv == &quot;tree&quot;) then
			has_visible_children = true
			break
		end
	end

	local tree_disallowed = lang_exc and lang_exc.disallow and lang_exc.disallow.tree
	local ety_tree_json = M.JSON.toJSON(tree_to_json(ety_data_tree))
	local anchor = M.anchors.etymonid(lang, id, {
		no_tree = args.notree,
		title = title,
		empty_tree = (not has_visible_children) or tree_disallowed,
		ety_tree_json = ety_tree_json,
	})
	table.insert(output, anchor)

	if text then
		local max_depth, stop_at_blue_link, stop_at_lang, stop_at_lang_or_bluelink
		if text == &quot;++&quot; then
			max_depth, stop_at_blue_link = false, false
		elseif text == &quot;+&quot; then
			max_depth, stop_at_blue_link = 1, false
		elseif text == &quot;*&quot; then
			max_depth, stop_at_blue_link = false, true
		elseif text:match(&quot;^:[^*]+%*$&quot;) then
			-- Stop at a specific language OR first bluelink after it, e.g., &quot;:ota*&quot;
			-- If the target language is a redlink, continue to the first bluelink
			local lang_code = text:match(&quot;^:([^*]+)%*$&quot;)
			if lang_code and lang_code ~= &quot;&quot; then
				local lang_obj = Util.get_lang(lang_code, true)
				if lang_obj then
					stop_at_lang_or_bluelink = lang_code
				else
					Util.add_warning('Invalid language code &quot;' .. lang_code .. '&quot; in text parameter. Showing full chain instead.')
					max_depth, stop_at_blue_link = false, false
				end
			else
				Util.add_warning('Empty language code in text parameter. Showing full chain instead.')
				max_depth, stop_at_blue_link = false, false
			end
		elseif text:sub(1, 1) == &quot;:&quot; then
			-- Stop at a specific language, e.g., &quot;:ar&quot; stops at first Arabic term
			local lang_code = text:sub(2)
			if lang_code ~= &quot;&quot; then
				-- Validate the language code
				local lang_obj = Util.get_lang(lang_code, true)
				if lang_obj then
					stop_at_lang = lang_code
				else
					Util.add_warning('Invalid language code &quot;' .. lang_code .. '&quot; in text parameter. Showing full chain instead.')
					max_depth, stop_at_blue_link = false, false -- default to ++
				end
			else
				Util.add_warning('Empty language code in text parameter. Showing full chain instead.')
				max_depth, stop_at_blue_link = false, false -- default to ++
			end
		else
			local num = tonumber(text)
			if num and num &gt;= 1 then
				max_depth, stop_at_blue_link = num, false
			else
				error('Invalid text value &quot;' ..
					text .. '&quot;. Valid values are: &quot;++&quot; (full chain), &quot;+&quot; (first step only), &quot;*&quot; (until first blue link), a number (max steps), &quot;:lang&quot; (stop at language), or &quot;:lang*&quot; (stop at language or first bluelink if redlink)')
			end
		end
		table.insert(output, M.text.render({
			data_tree = ety_data_tree,
			format_term_func = Util.format_term,
			max_depth = max_depth,
			stop_at_blue_link = stop_at_blue_link,
			curr_page = page_data.pagename,
			nodot = args.nodot,
			stop_at_lang = stop_at_lang,
			stop_at_lang_or_bluelink = stop_at_lang_or_bluelink,
		}))
	end

	if rfe then
		local rfe_param_mods = {
			nocat = { type = &quot;boolean&quot; },
			sort = {},
			y = {},
			m = {},
			fragment = {},
			section = {},
			box = { type = &quot;boolean&quot; },
			noes = { type = &quot;boolean&quot; },
		}

		local function generate_rfe_obj(rfe_text)
			-- Check if it's a boolean true value
			if M.yesno(rfe_text, false) then
				return { is_boolean = true }
			else
				return { text = rfe_text }
			end
		end

		local rfe_with_defaults = Util.add_boolean_defaults(rfe, rfe_param_mods)
		local parsed_rfe = M.parse_utilities.parse_inline_modifiers(rfe_with_defaults, { 
			param_mods = rfe_param_mods, 
			generate_obj = generate_rfe_obj 
		})

		local rfe_args = {
			[1] = lang:getCode(),
			nocat = parsed_rfe.nocat,
			sort = parsed_rfe.sort,
			y = parsed_rfe.y,
			m = parsed_rfe.m,
			fragment = parsed_rfe.fragment,
			section = parsed_rfe.section,
			box = parsed_rfe.box,
			noes = parsed_rfe.noes,
		}

		if not parsed_rfe.is_boolean then
			rfe_args[2] = parsed_rfe.text
		end

		table.insert(output, frame:expandTemplate({
			title = &quot;rfe&quot;,
			args = rfe_args
		}))
	end

	if Util.is_content_page() and __state.max_depth_reached &gt; 0 then
		local lang_code = lang:getCode()

		local depth_ranges = {
			{ min = 50, label = &quot;extremely-deep&quot; },
			{ min = 20, label = &quot;20+&quot; },
			{ min = 10, max = 19,                label = &quot;10-19&quot; },
			{ min = 5,  max = 9,                 label = &quot;5-9&quot; },
			{ min = 3,  max = 4,                 label = &quot;3-4&quot; },
			{ max = 2,  label = &quot;1-2&quot; }
		}

		local node_ranges = {
			{ min = 100, label = &quot;extremely-large&quot; },
			{ min = 50,  label = &quot;50+&quot; },
			{ min = 20,  max = 49,                 label = &quot;20-49&quot; },
			{ min = 10,  max = 19,                 label = &quot;10-19&quot; },
			{ min = 5,   max = 9,                  label = &quot;5-9&quot; },
			{ max = 4,   label = &quot;1-4&quot; }
		}

		local language_ranges = {
			{ min = 10,  label = &quot;10+&quot; },
			{ min = 5,   max = 9,      label = &quot;5-9&quot; },
			{ min = 3,   max = 4,      label = &quot;3-4&quot; },
			{ exact = 2, label = &quot;2&quot; },
			{ exact = 1, label = &quot;1&quot; }
		}

		track_ranges(&quot;depth&quot;, __state.max_depth_reached, depth_ranges, lang_code)
		track_ranges(&quot;nodes&quot;, __state.total_nodes, node_ranges, lang_code)

		local unique_languages = 0
		for _ in pairs(__state.language_count) do
			unique_languages = unique_languages + 1
		end
		track_ranges(&quot;unique-languages&quot;, unique_languages, language_ranges, lang_code)

		if __state.total_nodes == __state.max_depth_reached + 1 then
			track_ranges(&quot;linear-depth&quot;, __state.max_depth_reached, depth_ranges, lang_code)
		end
	end

	local categories = {}
	if Util.is_content_page() then
		local should_suppress_categories = lang_exc and lang_exc.suppress_categories
		if not should_suppress_categories and not args.nocat then
			categories = M.categories.render({
				data_tree = ety_data_tree,
				page_lang = lang,
				available_etymon_ids = __state.available_etymon_ids,
				senseid_parent_etymon = __state.senseid_parent_etymon,
				get_norm_lang_func = Util.get_norm_lang,
				lang_exc = lang_exc,
			})
		end

		local target_lang_code = lang:getCode()
		for keyword, keyword_data in pairs(__state.toplevel_keyword_stats) do
			-- Track keyword globally
			M.track(&quot;etymon/keyword/&quot; .. keyword)

			-- Track keyword per target language
			M.track(&quot;etymon/keyword/&quot; .. keyword .. &quot;/target/&quot; .. target_lang_code)

			-- Track keyword per source language
			for source_code, count in pairs(keyword_data.source_langs) do
				M.track(&quot;etymon/keyword/&quot; .. keyword .. &quot;/source/&quot; .. source_code)

				-- Track keyword per target+source combination
				M.track(&quot;etymon/keyword/&quot; .. keyword .. &quot;/target/&quot; .. target_lang_code .. &quot;/source/&quot; .. source_code)
			end
		end

		if tree then
			table.insert(categories, &quot;Pages with etymology trees&quot;)
			table.insert(categories, lang:getCanonicalName() .. &quot; entries with etymology trees&quot;)
		end
		if text then table.insert(categories, lang:getCanonicalName() .. &quot; entries with etymology texts&quot;) end
		if args.exnihilo then table.insert(categories, lang:getCanonicalName() .. &quot; terms coined ex nihilo&quot;) end
		if __state.toplevel_has_inline_etymology then
			table.insert(categories, &quot;Pages with inline etymon for redlinks&quot;)
		end
		if __state.toplevel_redundant_etymology then
			table.insert(categories, &quot;Pages with redundant inline etymon&quot;)
		end
		if __state.toplevel_idless_etymon then
			table.insert(categories, &quot;Pages using etymon with no ID&quot;)
		end
		if __state.has_mismatched_id then
			table.insert(categories, lang:getCanonicalName() .. &quot; entries referencing etymons with mismatched IDs&quot;)
		end
		if __state.linked_page_multiple_etymons_idless then
			table.insert(categories,
				lang:getCanonicalName() .. &quot; entries referencing pages with multiple etymons missing IDs&quot;)
		end
	end

	if #categories &gt; 0 then
		table.insert(output, M.categories.format(categories, lang))
	end

	if __state.warnings then
		for i, warning in ipairs(__state.warnings) do
			table.insert(output, (i == 1 and &quot;\n&quot; or &quot;&quot;) .. warning .. &quot;\n&quot;)
		end
	end

	return table.concat(output)
end

return export</text>
      <sha1>sd824iy93rvmo3oroit742p1i4oi4gt</sha1>
    </revision>
    <revision>
      <id>342826</id>
      <parentid>342825</parentid>
      <timestamp>2026-05-16T13:54:32Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <origin>342826</origin>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="61581" sha1="ntgc8yk38onjlpngtccb4xjlsblhzh9" xml:space="preserve">--[=[

This module implements the {{etymon}} template for structured etymology data on Wiktionary.
It enables the creation of etymology trees and text by parsing etymon chains,
scraping linked pages for their own {{etymon}} data, and recursively building a tree
of derivational relationships.

Authors:
- Original implementation: [[User:Ioaxxere]]
- Full refactor (September 2025): [[User:Fenakhay]] ([[Special:Diff/86717746]])

Modules:
- [[Module:etymon]]: main module handling parsing, validation, tree building, and page scraping
- [[Module:etymon/data]]: keyword definitions, configuration, and status constants
- [[Module:etymon/tree]]: etymology tree rendering
- [[Module:etymon/text]]: etymology text generation
- [[Module:etymon/categories]]: category generation logic

]=]

local export = {}

local etymon_data_module = &quot;Module:etymon/data&quot;
local etymon_text_module = &quot;Module:etymon/text&quot;
local etymon_tree_module = &quot;Module:etymon/tree&quot;
local etymon_categories_module = &quot;Module:etymon/categories&quot;
local etymon_descendants_module = &quot;Module:etymon/descendants&quot;

local __state = {
	cached_etymon_args = {},
	cached_etymon_pages = {},
	cached_descendants_checks = {},
	senseid_parent_etymon = {},
	available_etymon_ids = {},
	single_etymons = {},
	entry_title = nil,
	entry_lang_code = nil,
	current_page_has_inline_etymology = false,
	current_page_has_redundant_etymology = false,
	used_idless_etymon = false,
	toplevel_has_inline_etymology = false,
	toplevel_redundant_etymology = false,
	toplevel_idless_etymon = false,
	has_mismatched_id = false,
	linked_page_multiple_etymons_idless = false,
	max_depth_reached = 0,
	total_nodes = 0,
	language_count = {},
	toplevel_keyword_stats = {},
	warnings = {},
}

local loader = require(&quot;Module:module loader&quot;)

local M = loader.init({
	require = {
		data = etymon_data_module,
		tree = etymon_tree_module,
		text = etymon_text_module,
		categories = etymon_categories_module,
		descendants = etymon_descendants_module,

		anchors = &quot;Module:anchors&quot;,
		etydate = &quot;Module:etydate&quot;,
		etymology = &quot;Module:etymology&quot;,
		families = &quot;Module:families&quot;,
		languages = &quot;Module:languages&quot;,
		languages_errorgetby = &quot;Module:languages/errorGetBy&quot;,
		links = &quot;Module:links&quot;,
		pages = &quot;Module:pages&quot;,
		parameters = &quot;Module:parameters&quot;,
		string_utilities = &quot;Module:string utilities&quot;,
		template_parser = &quot;Module:template parser&quot;,
		utilities = &quot;Module:utilities&quot;,
		debug = &quot;Module:debug&quot;,
		en_utilities = &quot;Module:en-utilities&quot;,
		parse_utilities = &quot;Module:parse utilities&quot;,
		references = &quot;Module:references&quot;,
		track = &quot;Module:debug/track&quot;,
		template_styles = &quot;Module:TemplateStyles&quot;,
		script_utilities = &quot;Module:script utilities&quot;,
		JSON = &quot;Module:JSON&quot;,
		yesno = &quot;Module:yesno&quot;,
	},
	loadData = {
		headword_data = &quot;Module:headword/data&quot;,
		parameters_data = &quot;Module:parameters/data&quot;,
		text_allowed = &quot;Module:etymon/data/text_allowed&quot;,
	},
})

local Util = {}

function Util.format_error(message, preview_only)
	if preview_only and not M.pages.is_preview() then
		return nil
	end
	return '&lt;span class=&quot;error&quot;&gt;' .. message .. '&lt;/span&gt;'
end

function Util.add_warning(message, preview_only)
	local formatted = Util.format_error(message, preview_only)
	if formatted then
		table.insert(__state.warnings, formatted)
	end
end

function Util.is_text_param_allowed_for_lang(lang)
	if not lang or type(lang) ~= &quot;table&quot; then
		return false
	end
	local types = lang.getTypes and lang:getTypes()
	if types and types.family then
		local code = lang.getCode and lang:getCode()
		return code and M.text_allowed.families[code] == true
	end
	local full_code = lang.getFullCode and lang:getFullCode()
	if full_code and M.text_allowed.langs[full_code] then
		return true
	end
	if lang.inFamily then
		for family_code in pairs(M.text_allowed.families) do
			if lang:inFamily(family_code) then
				return true
			end
		end
	end
	return false
end

function Util.get_lang(code, no_error)
	if no_error then
		return M.languages.getByCode(code, nil, true)
	end
	return M.languages.getByCode(code, nil, true) or M.languages_errorgetby.code(code, true, true)
end

function Util.get_family(code)
	return M.families.getByCode(code)
end

function Util.get_lang_exception(lang)
	-- Families have no language-specific exceptions
	if lang.getTypes and lang:getTypes().family then
		return nil
	end
	local code = lang:getCode()
	local lang_exceptions = M.data.config.lang_exceptions

	if lang_exceptions[code] then
		return lang_exceptions[code]
	end

	for norm_code, exc in pairs(lang_exceptions) do
		if exc.normalize_to and code == exc.normalize_to then
			return exc
		end
		if exc.normalize_from_families then
			local should_normalize = false
			for _, family in ipairs(exc.normalize_from_families) do
				if lang:inFamily(family) then
					should_normalize = true
					break
				end
			end

			if should_normalize and exc.normalize_exclude_families then
				for _, family in ipairs(exc.normalize_exclude_families) do
					if lang:inFamily(family) then
						should_normalize = false
						break
					end
				end
			end

			if should_normalize then
				local ret = {}
				for k, v in pairs(exc) do
					ret[k] = v
				end
				ret.suppress_tr = nil
				return ret
			end
		end
	end

	return nil
end

function Util.get_norm_lang(lang)
	local exc = Util.get_lang_exception(lang)
	if exc and exc.normalize_to then
		return M.languages.getByCode(exc.normalize_to)
	end
	return lang
end

-- Add default values for boolean modifiers (e.g., &lt;unc&gt; becomes &lt;unc:1&gt;)
-- This is needed because Module:parse utilities expects boolean modifiers to have explicit values
function Util.add_boolean_defaults(str, param_mods)
	local result = str
	for name, spec in pairs(param_mods) do
		if spec.type == &quot;boolean&quot; then
			-- Replace &lt;name&gt; with &lt;name:1&gt; (but not &lt;name:...&gt; which already has a value)
			result = result:gsub(&quot;&lt;&quot; .. name .. &quot;&gt;&quot;, &quot;&lt;&quot; .. name .. &quot;:1&gt;&quot;)
		end
	end
	return result
end

-- Centralized term formatting: handles suppress_term, unknown_term, and regular terms
function Util.format_term(term, is_toplevel, opts)
	opts = opts or {}

	-- suppress_term (-) returns nil
	if term.suppress_term then
		return nil
	end

	local lang = term.lang
	local exc = Util.get_lang_exception(lang)

	if is_toplevel then
		local display_text = term.alt or term.title or &quot;&quot;
		local sc = term.sc or lang:findBestScript(display_text)
		local bold_text = tostring(mw.html.create(&quot;strong&quot;)
			:addClass(&quot;selflink&quot;)
			:wikitext(display_text))
		return M.script_utilities.tag_text(bold_text, lang, sc, &quot;term&quot;)
	end

	local link_params = { lang = lang }

	link_params.term = not term.unknown_term and term.title or nil
	link_params.alt = term.alt
	link_params.id = (not term.unknown_term and term.id and term.id ~= &quot;&quot;) and term.id or nil
	if not (exc and exc.suppress_tr) then
		link_params.tr = term.tr
		link_params.ts = term.ts
	else
		link_params.suppress_tr = true
	end
	link_params.lit = (opts.lit ~= &quot;suppress&quot;) and term.lit or nil
	if opts.gloss ~= &quot;suppress&quot; then
		link_params.gloss = term.t
	end
	if term.g and term.g ~= &quot;&quot; then
		local genders = M.string_utilities.split(term.g, &quot;,&quot;)
		for i = 1, #genders do
			genders[i] = M.string_utilities.trim(genders[i])
		end
		link_params.genders = genders
	end
	if opts.pos ~= &quot;suppress&quot; then
		link_params.pos = term.pos
		link_params.ng = term.ng
	end
	if exc and exc.suppress_tr then
		link_params.lit = nil
	end

	local show_qualifiers
	if opts.tree_ql ~= &quot;suppress&quot; then
		if term.q then
			link_params.q = term.q
		end
		if term.qq then
			link_params.qq = term.qq
		end
		if term.l then
			link_params.l = term.l
		end
		if term.ll then
			link_params.ll = term.ll
		end
		show_qualifiers = term.q or term.qq or term.l or term.ll
	end

	return M.links.full_link(link_params, &quot;term&quot;, nil, show_qualifiers and true or nil)
end

local __is_content_page_cached
function Util.is_content_page()
	if __is_content_page_cached == nil then
		__is_content_page_cached = M.pages.is_content_page(mw.title.getCurrentTitle())
	end
	return __is_content_page_cached
end

local __page_data_cached
function Util.get_page_data()
	if not __page_data_cached then
		__page_data_cached = M.headword_data.page
	end
	return __page_data_cached
end

-- Extract base keyword from param (without modifiers)
local function get_keyword_base(param)
	if type(param) ~= &quot;string&quot; then return nil end
	local base = param:match(&quot;^:?([^&lt;]+)&quot;) or param:gsub(&quot;^:&quot;, &quot;&quot;)
	return base
end

local function is_keyword(param, allow_colon_less)
	if type(param) ~= &quot;string&quot; then return false end
	local keywords = M.data.keywords
	if param:sub(1, 1) == &quot;:&quot; then
		local base = get_keyword_base(param)
		return keywords[base] ~= nil
	end
	if allow_colon_less then
		local base = get_keyword_base(param)
		return keywords[base] ~= nil
	end
	return false
end

local function get_keyword(param, allow_colon_less)
	if type(param) ~= &quot;string&quot; then return nil end
	local keywords = M.data.keywords
	if param:sub(1, 1) == &quot;:&quot; then
		return get_keyword_base(param)
	end
	if allow_colon_less then
		local base = get_keyword_base(param)
		if keywords[base] then
			return base
		end
	end
	return nil
end

local function normalize_keyword(keyword)
	if keyword:sub(1, 1) == &quot;:&quot; then
		return keyword
	end
	return &quot;:&quot; .. keyword
end

-- Resolve keyword (possibly an alias) to its canonical form. Used only at input boundaries
local function get_canonical_keyword(keyword)
	if not keyword then return keyword end
	return M.data.keyword_canonical[keyword] or keyword
end

-- Build text/phrase for nominalization with &lt;g:code&gt; (uses data module for codes only).
local function get_nominalization_label_for_g(code)
	if not code or code == &quot;&quot; then return nil end
	local codes = M.data.nominalization_g_codes
	local adj = codes[code]
	if not adj and #code == 2 then
		local gender_adj = codes[code:sub(1, 1)]
		local number_adj = codes[code:sub(2, 2)]
		if gender_adj and number_adj then
			adj = gender_adj .. &quot; &quot; .. number_adj
		end
	end
	if not adj then return nil end
	local text = adj:gsub(&quot;^%l&quot;, function(c) return string.upper(c) end) .. &quot; [[Appendix:Glossary#nominalization|nominalization]] of&quot;
	local phrase = M.en_utilities.add_indefinite_article(adj .. &quot; [[Appendix:Glossary#nominalization|nominalization]] of&quot;, false)
	return { text = text, phrase = phrase }
end

local EtymonParser = {}

-- Keyword modifier definitions
EtymonParser.keyword_param_mods = {
	unc = { type = &quot;boolean&quot; },
	ref = {},
	text = { restrict = { keywords = { &quot;from&quot;, &quot;derived&quot; } } },
	lit = { restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot;, &quot;univerbation&quot; } } },
	conj = {}, -- conjunction for alternatives: &quot;and&quot;, &quot;or&quot;, &quot;and/or&quot;, etc.
	g = { restrict = { keywords = { &quot;nominalization&quot; } } },
}

-- Term modifier definitions
EtymonParser.etymon_param_mods = {
	id = {},
	t = {},
	tr = {},
	ts = {},
	q = {},
	qq = {},
	l = {},
	ll = {},
	pos = {},
	ng = {},
	alt = {},
	g = {},
	ety = {},
	lit = {},
	unc = { type = &quot;boolean&quot; },
	ref = {},
	aftype = { restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot;, &quot;afeq&quot; } } },
	postype = {},
	bor = { type = &quot;boolean&quot;, restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot; } } },
	slbor = { type = &quot;boolean&quot;, restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot; } } },
	lbor = { type = &quot;boolean&quot;, restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot; } } },
}

local function get_clean_param_mods(param_mods)
	local clean = {}
	for mod_name, mod_def in pairs(param_mods) do
		clean[mod_name] = {}
		for key, value in pairs(mod_def) do
			if key ~= &quot;restrict&quot; then
				clean[mod_name][key] = value
			end
		end
	end
	return clean
end

function EtymonParser.check_modifier_restrictions(modifiers, current_keyword, param_mods)
	for mod_name, mod_value in pairs(modifiers) do
		-- Only check restrictions if the modifier has a non-false/nil value
		if mod_value then
			local mod_def = param_mods[mod_name]
			if mod_def and mod_def.restrict and mod_def.restrict.keywords then
				local allowed_keywords = mod_def.restrict.keywords
				local is_allowed = false
				for _, allowed_keyword in ipairs(allowed_keywords) do
					if current_keyword == allowed_keyword then
						is_allowed = true
						break
					end
				end
				if not is_allowed then
					local keyword_list = {}
					for _, kw in ipairs(allowed_keywords) do
						table.insert(keyword_list, &quot;:&quot; .. kw)
					end
					local keyword_str = table.concat(keyword_list, #keyword_list == 2 and &quot; or &quot; or &quot;, &quot;)
					if #keyword_list &gt; 2 then
						-- Replace last comma with &quot;or&quot;
						keyword_str = keyword_str:gsub(&quot;, ([^,]+)$&quot;, &quot; or %1&quot;)
					end
					local mod_display = mod_value == true and &quot;&lt;&quot; .. mod_name .. &quot;&gt;&quot; or &quot;&lt;&quot; .. mod_name .. &quot;:&quot; .. tostring(mod_value) .. &quot;&gt;&quot;
					error(&quot;The modifier `&quot; .. mod_display .. &quot;` is only allowed for the keyword&quot; .. (#keyword_list &gt; 1 and &quot;s &quot; or &quot; &quot;) .. keyword_str .. &quot;.&quot;)
				end
			end
		end
	end
end

-- Parse keyword with modifiers (e.g., &quot;:bor&lt;unc&gt;&quot; or &quot;:bor&lt;ref:{{R:example}}&gt;&quot;)
function EtymonParser.parse_keyword_modifiers(param)
	if type(param) ~= &quot;string&quot; then return nil, {} end

	local base_keyword = get_keyword_base(param)
	if not base_keyword then return nil, {} end

	local canonical_keyword = get_canonical_keyword(base_keyword)

	-- Check if there are any modifiers
	if not param:find(&quot;&lt;&quot;, 1, true) then
		return canonical_keyword, {}
	end

	-- Parse modifiers using the same mechanism as etymon parsing
	local rest_with_defaults = Util.add_boolean_defaults(param, EtymonParser.keyword_param_mods)

	local function generate_obj(ignored)
		return {}
	end

	local parsed = M.parse_utilities.parse_inline_modifiers(rest_with_defaults:gsub(&quot;^:?[^&lt;]+&quot;, &quot;&quot;),
		{ param_mods = get_clean_param_mods(EtymonParser.keyword_param_mods), generate_obj = generate_obj })

	local modifiers = {
		unc = parsed.unc or false,
		ref = parsed.ref,
		text = parsed.text,
		lit = parsed.lit,
		conj = parsed.conj,
		g = parsed.g,
	}

	-- Validate modifiers against restrictions
	EtymonParser.check_modifier_restrictions(modifiers, canonical_keyword, EtymonParser.keyword_param_mods)

	return canonical_keyword, modifiers
end

function EtymonParser.parse_balanced_segments(str)
	local segments = {}
	local current = &quot;&quot;
	local depth = 0
	local i = 1

	while i &lt;= #str do
		local char = str:sub(i, i)

		if char == &quot;&lt;&quot; then
			if depth == 0 and current ~= &quot;&quot; then
				table.insert(segments, current)
				current = &quot;&quot;
			end
			depth = depth + 1
			current = current .. char
		elseif char == &quot;&gt;&quot; then
			current = current .. char
			depth = depth - 1
			if depth == 0 then
				table.insert(segments, current)
				current = &quot;&quot;
			elseif depth &lt; 0 then
				error(&quot;Unbalanced brackets in etymon: unexpected '&gt;'&quot;)
			end
		else
			current = current .. char
		end

		i = i + 1
	end

	if depth ~= 0 then
		error(&quot;Unbalanced brackets in etymon: missing '&gt;'&quot;)
	end

	if current ~= &quot;&quot; then
		table.insert(segments, current)
	end

	return segments
end

function EtymonParser.parse_inline_ety(ety_string, context_lang)
	local segments = EtymonParser.parse_balanced_segments(ety_string)

	if #segments == 0 then
		error(&quot;Empty inline etymology&quot;)
	end

	local keyword = M.string_utilities.trim(segments[1])

	if not is_keyword(keyword, true) then
		error(&quot;Invalid keyword '&quot; .. keyword .. &quot;' in inline etymology &lt;ety:&quot; .. keyword .. &quot;...&gt;&quot;)
	end

	local args = { context_lang:getCode(), normalize_keyword(get_canonical_keyword(keyword)) }

	for i = 2, #segments do
		local segment = segments[i]
		if segment:sub(1, 1) == &quot;&lt;&quot; and segment:sub(-1) == &quot;&gt;&quot; then
			local inner = segment:sub(2, -2)
			if inner ~= &quot;&quot; then
				table.insert(args, inner)
			end
		elseif is_keyword(segment, true) then
			-- Handle keywords that appear between bracketed segments
			table.insert(args, normalize_keyword(get_canonical_keyword(get_keyword(segment, true))))
		end
	end

	return args
end

function EtymonParser.parse_etymon(param, context_lang)
	if is_keyword(param) then
		return nil
	end

	if type(param) ~= &quot;string&quot; then
		return nil
	end

	local lang, rest
	local is_family = false

	local before_bracket = param:match(&quot;^([^&lt;]*)&quot;) or param
	local lang_code, rest_match = before_bracket:match(&quot;^([a-zA-Z][a-zA-Z0-9._-]*):(.*)$&quot;)

	if lang_code then
		local potential_lang = Util.get_lang(lang_code, true)
		if potential_lang then
			lang = potential_lang
			rest = param:sub(#lang_code + 2)
		else
			local potential_family = Util.get_family(lang_code)
			if potential_family then
				lang = potential_family
				rest = param:sub(#lang_code + 2)
				is_family = true
			else
				lang = context_lang
				rest = param
			end
		end
	else
		lang = context_lang
		rest = param
	end

	if rest == &quot;&quot; then
		M.track(&quot;etymon/term/empty&quot;)
	elseif rest == &quot;?&quot; then
		M.track(&quot;etymon/term/question-mark&quot;)
	elseif rest == &quot;-&quot; then
		M.track(&quot;etymon/term/hyphen&quot;)
	end

	if rest == &quot;&quot; then
		return {
			lang = lang,
			term = nil,
			unknown_term = true,
			is_family = is_family,
		}
	end

	if rest == &quot;-&quot; then
		return {
			lang = lang,
			term = nil,
			suppress_term = true,
			is_family = is_family,
		}
	end

	if not rest:find(&quot;&lt;&quot;, 1, true) then
		return {
			lang = lang,
			term = M.string_utilities.trim(rest),
			is_family = is_family,
		}
	end

	local term_text = rest:match(&quot;^([^&lt;]*)&quot;) or &quot;&quot;
	local is_unknown = (term_text == &quot;&quot;)
	local is_suppress = (term_text == &quot;-&quot;)

	local function generate_obj(ignored_term)
		return { term = (is_unknown or is_suppress) and nil or M.string_utilities.trim(term_text) }
	end

	local rest_with_defaults = Util.add_boolean_defaults(rest, EtymonParser.etymon_param_mods)

	local parsed_obj = M.parse_utilities.parse_inline_modifiers(rest_with_defaults,
		{ param_mods = get_clean_param_mods(EtymonParser.etymon_param_mods), generate_obj = generate_obj })

	if parsed_obj.id and parsed_obj.id:match(&quot;^!&quot;) then
		parsed_obj.id = parsed_obj.id:sub(2)
		parsed_obj.override = true
	end

	parsed_obj.lang = lang
	parsed_obj.is_family = is_family
	if is_unknown then
		parsed_obj.unknown_term = true
	elseif is_suppress then
		parsed_obj.suppress_term = true
	end

	return parsed_obj
end

function EtymonParser.validate(lang, args, id, title, pos, starts_with_lang_code)
	-- id is now optional, so only validate if provided
	if id then
		if mw.ustring.len(id) &lt; 2 then
			error(&quot;The `id` parameter must have at least two characters.&quot;)
		end
		if id == title or id == Util.get_page_data().pagename then
			error(&quot;The `id` parameter must not be the same as the page title.&quot;)
		end
	end

	local valid_pos = { prefix = true, suffix = true, interfix = true, infix = true, root = true, word = true }
	if pos and not valid_pos[pos] then
		error(&quot;Unknown value provided for `pos`. Valid values: &quot; .. table.concat(require(&quot;Module:table&quot;).keysToList(valid_pos), &quot;, &quot;) .. &quot;.&quot;)
	end

	local current_keyword = &quot;from&quot;
	local etymons_in_group = {}
	local keywords = M.data.keywords

	local function checkGroup()
		if keywords[current_keyword] and keywords[current_keyword].is_group and current_keyword ~= &quot;affix&quot; and current_keyword ~= &quot;surf&quot; and current_keyword ~= &quot;afeq&quot; and current_keyword ~= &quot;univerbation&quot; and #etymons_in_group &lt;= 1 then
			error(&quot;Detected `:&quot; .. current_keyword .. &quot;` group with fewer than two etymons.&quot;)
		end
		etymons_in_group = {}
	end

	local start_index = starts_with_lang_code and 2 or 1

	for i = start_index, #args do
		local param = args[i]

		if type(param) ~= &quot;string&quot; then
		elseif param:sub(1, 1) == &quot;:&quot; and not is_keyword(param) then
			error(&quot;Invalid keyword '&quot; .. param .. &quot;'. Did you mean a valid keyword like ':bor', ':inh', etc.?&quot;)
		elseif is_keyword(param) then
			checkGroup()
			current_keyword = get_canonical_keyword(get_keyword(param))
		else
			local etymon_data = EtymonParser.parse_etymon(param, lang)
			if etymon_data then
				table.insert(etymons_in_group, param)
				local param_lang = etymon_data.lang

				if etymon_data.is_family and current_keyword == &quot;inherited&quot; then
					error(&quot;`:inh` does not support family codes; use a specific language.&quot;)
				end
				if etymon_data.is_family and not etymon_data.suppress_term then
					error(&quot;Family codes require suppressed term (use family:-).&quot;)
				end
				if current_keyword == &quot;from&quot; and param_lang:getFullCode() ~= lang:getFullCode() then
					error(&quot;`:from` is for same-language derivation, but language does not match. &quot; ..
						&quot;Expected '&quot; .. lang:getFullCode() .. &quot;', got '&quot; .. param_lang:getFullCode() .. &quot;'.&quot;)
				elseif current_keyword == &quot;inherited&quot; then
					M.etymology.check_ancestor(lang, param_lang)
				end

				-- Check modifier restrictions
				EtymonParser.check_modifier_restrictions(etymon_data, current_keyword, EtymonParser.etymon_param_mods)

				-- postype must be &quot;root&quot; or &quot;word&quot;
				local VALID_POSTYPES = { root = true, word = true }
				if etymon_data.postype and not VALID_POSTYPES[etymon_data.postype] then
					error(&quot;Invalid &lt;postype:&quot; .. etymon_data.postype .. &quot;&gt;; must be \&quot;root\&quot; or \&quot;word\&quot;.&quot;)
				end

				if etymon_data.ety then
					local inline_args = EtymonParser.parse_inline_ety(etymon_data.ety, etymon_data.lang)
					EtymonParser.validate(etymon_data.lang, inline_args, nil, nil, nil, true)
				end
			else
				table.insert(etymons_in_group, param)
			end
		end
	end

	checkGroup()
end

local DataRetriever = {}

-- Given an etymon data, scrape its page and cache the result in the global state object.
function DataRetriever.cache_page_etymons(etymon_page, etymon_title, key, etymon_lang, etymon_id, redirected_from, descendants_is_toplevel)
	local content = etymon_title:getContent()
	if not content then
		__state.cached_etymon_args[key] = M.data.STATUS.REDLINK
		return
	end

	-- Check if the linked page is a redirect. If it is, the template parsing
	-- code below will be effectively skipped, and `scrape_page` will be called
	-- again on the redirect target (see the bottom of this function)
	local lang_section_for_descendants = nil
	local redirect_target = etymon_title.redirect_target
	if not redirect_target then
		content = M.pages.get_section(content, etymon_lang:getFullName(), 2)
		if not content then
			__state.cached_etymon_args[key] = M.data.STATUS.MISSING
			return
		end
		lang_section_for_descendants = content
	end

	local etymon_lang_code = etymon_lang:getFullCode()
	local lang_page_key = etymon_lang_code .. &quot;:&quot; .. etymon_page
	local found_templates_for_lang = {}
	local found_ids = {}
	local get_node_class = M.template_parser.class_else_type

	-- Look for all {{etymon}} templates within the page content using the template parser
	-- This way the same page is never parsed more than once

	-- Build a map from senseids to their parent etymonids.
	local active_etymon_args = nil

	for node in M.template_parser.parse(content):iterate_nodes() do
		local node_class = get_node_class(node)

		if node_class == &quot;heading&quot; then
			-- A new L2 or etymology section acts as a barrier: an {{etymon}} usage
			-- used previously cannot be the parent of any subsequent senseids.
			-- Note that we don't have to check for L2s due to the usage of `M.pages.get_section` above.
			if node:get_name():find(&quot;^Etymology&quot;) then
				active_etymon_args = nil
			end
		elseif node_class == &quot;template&quot; then
			local template_name = node:get_name()

			if template_name == &quot;etymon&quot; then
				local template_args = node:get_arguments()

				-- Check if this etymon is for our language
				if template_args[1] == etymon_lang_code then
					table.insert(found_templates_for_lang, template_args)

					if template_args.id then
						local etymon_key = lang_page_key .. &quot;:&quot; .. template_args.id
						__state.cached_etymon_args[etymon_key] = template_args
						__state.cached_etymon_pages[etymon_key] = tostring(etymon_page)
						table.insert(found_ids, template_args.id)
						active_etymon_args = template_args
					else
						-- Store idless etymon with default key
						local etymon_key = lang_page_key .. &quot;:*&quot;
						__state.cached_etymon_args[etymon_key] = template_args
						__state.cached_etymon_pages[etymon_key] = tostring(etymon_page)
						table.insert(found_ids, &quot;*&quot;)
						active_etymon_args = template_args
					end
				end
			elseif active_etymon_args and template_name == &quot;senseid&quot; then
				local template_args = node:get_arguments()

				-- This should always be true for proper usages of {{senseid}}.
				if template_args[1] == etymon_lang_code and template_args[2] then
					local sense_id_key = lang_page_key .. &quot;:&quot; .. template_args[2]
					__state.senseid_parent_etymon[sense_id_key] = active_etymon_args
					__state.cached_etymon_pages[sense_id_key] = tostring(etymon_page)
				end
			end
		end
	end

	if descendants_is_toplevel and lang_section_for_descendants and #found_templates_for_lang &gt; 0 then
		M.descendants.cache_page_checks({
			lang_section = lang_section_for_descendants,
			etymon_lang_code = etymon_lang_code,
			found_templates_for_lang = found_templates_for_lang,
			entry_title = __state.entry_title,
			entry_lang_code = __state.entry_lang_code,
			entry_lang = __state.entry_lang_code and Util.get_lang(__state.entry_lang_code, true) or nil,
			cached_descendants_checks = __state.cached_descendants_checks,
			lang_page_key = lang_page_key,
			redirected_from = redirected_from,
		})
	end

	local id_data_list = {}
	for _, args in ipairs(found_templates_for_lang) do
		local id = args.id or &quot;*&quot;
		table.insert(id_data_list, { id = id, pos = args.pos })
	end
	__state.available_etymon_ids[lang_page_key] = id_data_list

	if #found_templates_for_lang == 1 then
		__state.single_etymons[lang_page_key] = found_templates_for_lang[1]
	end

	if redirected_from and __state.available_etymon_ids[lang_page_key] then
		__state.available_etymon_ids[redirected_from] = __state.available_etymon_ids[redirected_from] or {}
		for _, id_data in ipairs(__state.available_etymon_ids[lang_page_key]) do
			table.insert(__state.available_etymon_ids[redirected_from], id_data)
		end
	end

	if __state.cached_etymon_args[key] ~= nil or __state.senseid_parent_etymon[key] ~= nil then
		-- All done!
		return
	elseif redirect_target and not redirected_from then
		-- Try scraping the redirect.
		etymon_page = redirect_target.prefixedText
		DataRetriever.cache_page_etymons(etymon_page, redirect_target, lang_page_key .. &quot;:&quot; .. etymon_id, etymon_lang, etymon_id, lang_page_key, descendants_is_toplevel)
		__state.cached_etymon_args[key] = __state.cached_etymon_args[etymon_lang_code .. &quot;:&quot; .. etymon_page .. &quot;:&quot; .. etymon_id]
	else
		__state.cached_etymon_args[key] = M.data.STATUS.MISSING
	end
end

-- Given an etymon object, scrape its page (if necessary) and return its own etymon arguments as well as the page name.
function DataRetriever.get_etymon_args(etymon_data, is_toplevel)
	local page = M.links.get_link_page(etymon_data.term, etymon_data.lang)
	local norm_lang = Util.get_norm_lang(etymon_data.lang)
	local base_key = norm_lang:getFullCode() .. &quot;:&quot; .. page

	if etymon_data.id then
		local key = base_key .. &quot;:&quot; .. etymon_data.id

		local cached_args = __state.cached_etymon_args[key] or __state.senseid_parent_etymon[key]
		if cached_args == nil then
			local title = mw.title.new(page)
			if not title then error('Invalid page title &quot;' .. page .. '&quot; encountered.') end
			DataRetriever.cache_page_etymons(page, title, key, norm_lang, etymon_data.id, nil, is_toplevel)
		end
		cached_args = __state.cached_etymon_args[key] or __state.senseid_parent_etymon[key] -- refresh

		-- Get etymon_id from parent if this was resolved via senseid
		local parent_etymon = __state.senseid_parent_etymon[key]
		local resolved_etymon_id = parent_etymon and parent_etymon.id
		local descendants_check = M.descendants.get_lookup_check({
			cached_descendants_checks = __state.cached_descendants_checks,
			is_toplevel = is_toplevel,
			base_key = base_key,
			lookup = {
				explicit_id = etymon_data.id,
				parent_etymon = parent_etymon,
			},
		})
		if is_toplevel and descendants_check == nil then
			local title = mw.title.new(page)
			if title then
				DataRetriever.cache_page_etymons(page, title, key, norm_lang, etymon_data.id, nil, true)
				descendants_check = M.descendants.get_lookup_check({
					cached_descendants_checks = __state.cached_descendants_checks,
					is_toplevel = true,
					base_key = base_key,
					lookup = {
						explicit_id = etymon_data.id,
						parent_etymon = parent_etymon,
					},
				})
			end
		end
		return cached_args, __state.cached_etymon_pages[key], resolved_etymon_id, descendants_check
	else
		__state.used_idless_etymon = true
		if is_toplevel then
			__state.toplevel_idless_etymon = true
		end

		if __state.available_etymon_ids[base_key] == nil then
			local title = mw.title.new(page)
			if not title then error('Invalid page title &quot;' .. page .. '&quot; encountered.') end
			DataRetriever.cache_page_etymons(page, title, base_key .. &quot;:*&quot;, norm_lang, &quot;*&quot;, nil, is_toplevel)
		end

		local ids = __state.available_etymon_ids[base_key] or {}
		local count = #ids

		-- Try to filter by postype if available and we have multiple candidates
		if count &gt; 1 and etymon_data.postype then
			local matching_ids = {}
			for _, id_data in ipairs(ids) do
				if id_data.pos == etymon_data.postype then
					table.insert(matching_ids, id_data)
				end
			end
			
			if #matching_ids == 1 then
				local matched_id = matching_ids[1].id
				local matched_key = base_key .. &quot;:&quot; .. matched_id
				local descendants_check = M.descendants.get_lookup_check({
					cached_descendants_checks = __state.cached_descendants_checks,
					is_toplevel = is_toplevel,
					base_key = base_key,
					lookup = { id = matched_id },
				})
				if is_toplevel and descendants_check == nil then
					local title = mw.title.new(page)
					if title then
						DataRetriever.cache_page_etymons(page, title, base_key .. &quot;:*&quot;, norm_lang, &quot;*&quot;, nil, true)
						descendants_check = M.descendants.get_lookup_check({
							cached_descendants_checks = __state.cached_descendants_checks,
							is_toplevel = true,
							base_key = base_key,
							lookup = { id = matched_id },
						})
					end
				end
				return __state.cached_etymon_args[matched_key], __state.cached_etymon_pages[matched_key], nil, descendants_check
			end
		end

		if count == 1 then
			local only_id_data = ids[1]
			local only_id = (type(only_id_data) == &quot;table&quot; and only_id_data.id) or only_id_data or &quot;*&quot;
			local descendants_check = M.descendants.get_lookup_check({
				cached_descendants_checks = __state.cached_descendants_checks,
				is_toplevel = is_toplevel,
				base_key = base_key,
				lookup = { id_data = only_id_data },
			})
			if is_toplevel and descendants_check == nil then
				local title = mw.title.new(page)
				if title then
					DataRetriever.cache_page_etymons(page, title, base_key .. &quot;:*&quot;, norm_lang, &quot;*&quot;, nil, true)
					descendants_check = M.descendants.get_lookup_check({
						cached_descendants_checks = __state.cached_descendants_checks,
						is_toplevel = true,
						base_key = base_key,
						lookup = { id_data = only_id_data },
					})
				end
			end
			return __state.single_etymons[base_key], __state.cached_etymon_pages[base_key .. &quot;:&quot; .. only_id], nil, descendants_check
		elseif count &gt; 1 then
			local page_link = M.links.full_link({
				term = page,
				lang = norm_lang,
				no_generate_forms = true,
			}, &quot;term&quot;)

			local function format_id_hint(id_data, idx)
				local id = type(id_data) == &quot;table&quot; and id_data.id or id_data
				local pos = type(id_data) == &quot;table&quot; and id_data.pos
				if id and id ~= &quot;&quot; and id ~= &quot;*&quot; then
					return '&quot;' .. id .. '&quot;'
				end
				if pos and pos ~= &quot;&quot; then
					return &quot;unnamed (|pos=&quot; .. pos .. &quot;|)&quot;
				end
				return &quot;etymon #&quot; .. idx .. &quot; (no |id= on page)&quot;
			end

			local id_list = {}
			local all_idless = true
			local target_has_idless = false
			for i, id_data in ipairs(ids) do
				local id = type(id_data) == &quot;table&quot; and id_data.id or id_data
				if id and id ~= &quot;&quot; and id ~= &quot;*&quot; then
					all_idless = false
				else
					target_has_idless = true
				end
				table.insert(id_list, format_id_hint(id_data, i))
			end

			if is_toplevel and target_has_idless then
				__state.linked_page_multiple_etymons_idless = true
			end

			local any_pos = false
			for _, id_data in ipairs(ids) do
				local pos = type(id_data) == &quot;table&quot; and id_data.pos
				if pos and pos ~= &quot;&quot; then
					any_pos = true
					break
				end
			end

			local suggestion_text
			local lead = &quot;Etymology link to &quot; .. page_link .. &quot; is ambiguous (&quot; .. count .. &quot; {{etymon}} templates for &quot;
				.. norm_lang:getCanonicalName() .. &quot;).&quot;
			if all_idless then
				if any_pos then
					suggestion_text = &quot; None set `|id=` yet; add a unique `|id=` to each on &quot; .. page_link
						.. &quot;, then `&lt;id:identifier&gt;` after the term here. Section order / hints: &quot;
						.. mw.text.listToText(id_list) .. &quot;.&quot;
				else
					suggestion_text = &quot; None set `|id=` yet; add a unique `|id=` to each {{etymon}} in that section from top to bottom, then `&lt;id:identifier&gt;` after the term here (same value as `|id=`).&quot;
				end
			else
				suggestion_text = &quot; Specify which one with `&lt;id:identifier&gt;` after the term. Options: &quot; .. mw.text.listToText(id_list) .. &quot;.&quot;
			end

			Util.add_warning(lead .. suggestion_text, true)

			return M.data.STATUS.AMBIGUOUS, nil, nil, nil
		else
			return M.data.STATUS.MISSING, nil, nil, nil
		end
	end
end

local TreeBuilder = {}

local function parse_etymon_references(refs_text)
	if not refs_text or refs_text == &quot;&quot; then
		return &quot;&quot;
	end
	return M.references.parse_references(refs_text)
end

local function parse_tree_references(node)
	if node.ref then
		node.parsed_ref = parse_etymon_references(node.ref)
	end

	if node.children then
		for _, container in ipairs(node.children) do
			if container.terms then
				for _, term in ipairs(container.terms) do
					parse_tree_references(term)
				end
			end
		end
	end
end

-- Build a unique key for deduplication in the seen table
function TreeBuilder.build_key(lang, title, args)
	local norm_lang_code = Util.get_norm_lang(lang):getFullCode()
	local is_table = type(args) == &quot;table&quot;
	local id = (is_table and args.id) or &quot;&quot;
	
	if title then
		return norm_lang_code .. &quot;:&quot; .. M.links.get_link_page(title, lang) .. &quot;:&quot; .. id
	end
	
	if is_table and args.status == M.data.STATUS.INLINE then
		local content_parts = {}
		for i = 1, #args do
			content_parts[i] = tostring(args[i])
		end
		return norm_lang_code .. &quot;:*:&quot; .. id .. &quot;\0&quot; .. table.concat(content_parts, &quot;\0&quot;)
	end
	
	return norm_lang_code .. &quot;:*:&quot; .. id
end

function TreeBuilder.build(lang, title, args, seen, depth, stop_recursion)
	seen = seen or {}
	depth = depth or 0
	local is_toplevel = (depth == 0)

	if depth &gt; __state.max_depth_reached then
		__state.max_depth_reached = depth
	end

	__state.total_nodes = __state.total_nodes + 1

	local lang_code = lang:getCode()
	__state.language_count[lang_code] = (__state.language_count[lang_code] or 0) + 1

	local current_id = (type(args) == &quot;table&quot; and args.id) or &quot;&quot;
	local key = TreeBuilder.build_key(lang, title, args)
	
	local node = { lang = lang, title = title, id = current_id, args = args, children = {}, status = M.data.STATUS.OK }

	if type(args) ~= &quot;table&quot; or seen[key] then
		node.status = args or M.data.STATUS.MISSING
		-- Mark as duplicate if we've seen this node before
		if seen[key] then
			node.is_duplicate = true
			node.duplicate_key = key
			local original_node = seen[key]
			if type(original_node) == &quot;table&quot; and original_node.children and #original_node.children &gt; 0 then
				node.original_has_children = true
			end
		end
		return node
	end

	node.status = args.status or M.data.STATUS.OK

	seen[key] = node

	-- If stop_recursion is set, skip parsing children but check for visible children
	if stop_recursion then
		local keywords = M.data.keywords
		local has_visible_children = false
		for i = 2, #args do
			local param = args[i]
			if type(param) == &quot;string&quot; then
				local keyword_base = get_keyword_base(param)
				if keyword_base and keywords[keyword_base] then
					-- It's a keyword, check if visible in tree (invisible &quot;all&quot; or &quot;tree&quot; = hidden in tree)
					local keyword_info = keywords[keyword_base]
					local inv = keyword_info.invisible
					if not (inv == &quot;all&quot; or inv == true or inv == &quot;tree&quot;) then
						has_visible_children = true
						break
					end
				elseif param:sub(1, 1) ~= &quot;:&quot; then
					-- It's a term (not a keyword), so there are visible children
					has_visible_children = true
					break
				end
			end
		end
		node.has_visible_children = has_visible_children
		return node
	end

	-- Parse args into keyword containers
	local current_keyword = &quot;from&quot;
	local current_keyword_modifiers = {}
	local current_container = nil

	-- Helper to track keyword usage at top level
	local function track_keyword_usage(keyword, target_lang, source_lang)
		if not is_toplevel then return end

		if not __state.toplevel_keyword_stats[keyword] then
			__state.toplevel_keyword_stats[keyword] = {
				count = 0,
				target_langs = {},
				source_langs = {},
			}
		end

		local keyword_data = __state.toplevel_keyword_stats[keyword]
		keyword_data.count = keyword_data.count + 1

		local target_code = target_lang:getCode()
		keyword_data.target_langs[target_code] = (keyword_data.target_langs[target_code] or 0) + 1

		if source_lang then
			local source_code = source_lang:getCode()
			keyword_data.source_langs[source_code] = (keyword_data.source_langs[source_code] or 0) + 1
		end
	end

	local function ensure_container()
		if not current_container or current_container.keyword ~= current_keyword then
			current_container = {
				keyword = current_keyword,
				keyword_info = M.data.keywords[current_keyword],
				keyword_modifiers = current_keyword_modifiers,
				terms = {},
			}
			table.insert(node.children, current_container)
			-- Override keyword text/phrase for nominalization with &lt;g:code&gt;
			if current_keyword_modifiers.g and current_keyword == &quot;nominalization&quot; then
				local labels = get_nominalization_label_for_g(current_keyword_modifiers.g)
				if not labels then
					local codes = {}
					for c in pairs(M.data.nominalization_g_codes) do table.insert(codes, c) end
					table.sort(codes)
					error(&quot;Invalid &lt;g:&quot; .. tostring(current_keyword_modifiers.g) .. &quot;&gt;. Supported codes for nominalization: &quot; .. table.concat(codes, &quot;, &quot;))
				end
				current_container.keyword_info = {}
				for k, v in pairs(M.data.keywords[current_keyword]) do current_container.keyword_info[k] = v end
				current_container.keyword_info.text = labels.text
				current_container.keyword_info.phrase = labels.phrase
			end
		end
	end

	for i = 2, #args do
		local param = args[i]

		if is_keyword(param) then
			local keyword, modifiers = EtymonParser.parse_keyword_modifiers(param)
			current_keyword = keyword
			current_keyword_modifiers = modifiers
			current_container = nil -- Force new container for new keyword
		elseif type(param) == &quot;string&quot; and param:sub(1, 1) == &quot;:&quot; then
			error(&quot;Invalid keyword '&quot; .. param .. &quot;'. Did you mean a valid keyword like ':bor', ':inh', etc.?&quot;)
		elseif type(param) == &quot;string&quot; then
			local etymon_data = EtymonParser.parse_etymon(param, lang)

			if etymon_data then
				-- Track keyword usage at top level
				track_keyword_usage(current_keyword, lang, etymon_data.lang)

				local term_node = {}

				-- Handle suppress_term (-) and unknown_term (empty) directly
				if etymon_data.suppress_term or etymon_data.unknown_term then
					ensure_container()
					if etymon_data.ety then
						local inline_args = EtymonParser.parse_inline_ety(etymon_data.ety, etymon_data.lang)
						inline_args.id = etymon_data.id
						inline_args.status = M.data.STATUS.INLINE
						term_node = TreeBuilder.build(etymon_data.lang, nil, inline_args, seen, depth + 1)
					else
						term_node = {
							lang = etymon_data.lang,
							children = {},
							status = M.data.STATUS.OK,
						}
					end
					term_node.suppress_term = etymon_data.suppress_term
					term_node.unknown_term = etymon_data.unknown_term
					term_node.is_family = etymon_data.is_family
					term_node.is_uncertain = etymon_data.unc
					term_node.ref = etymon_data.ref
					term_node.t = etymon_data.t
					term_node.tr = etymon_data.tr
					term_node.ts = etymon_data.ts
					term_node.alt = etymon_data.alt
					term_node.g = etymon_data.g
					term_node.pos = etymon_data.pos
					term_node.ng = etymon_data.ng
					term_node.lit = etymon_data.lit
					term_node.q = etymon_data.q
					term_node.qq = etymon_data.qq
					term_node.l = etymon_data.l
					term_node.ll = etymon_data.ll
				else
					-- Regular term: fetch arguments from page
					local etymon_args, page_of, resolved_etymon_id, descendants_check = DataRetriever.get_etymon_args(etymon_data, is_toplevel)

					if etymon_data.id and etymon_args == M.data.STATUS.MISSING and not etymon_data.ety then
						local page = M.links.get_link_page(etymon_data.term, etymon_data.lang)
						local norm_lang = Util.get_norm_lang(etymon_data.lang)
						local base_key = norm_lang:getFullCode() .. &quot;:&quot; .. page
						local available_ids = __state.available_etymon_ids[base_key] or {}

						if #available_ids &gt; 0 then
							__state.has_mismatched_id = true
						end
					end

					-- Check for &lt;ety&gt; inline parameter doesn't override the scraped arguments, unless the latter are missing
					if etymon_data.ety then
						if etymon_args == M.data.STATUS.REDLINK or etymon_args == M.data.STATUS.MISSING then
							__state.current_page_has_inline_etymology = true
							if is_toplevel then
								__state.toplevel_has_inline_etymology = true
							end

							local inline_args = EtymonParser.parse_inline_ety(etymon_data.ety, etymon_data.lang)

							-- Track inline ety keywords too
							local inline_keyword = get_keyword(inline_args[2], true)
							if inline_keyword and #inline_args &gt;= 3 then
								local inline_etymon = EtymonParser.parse_etymon(inline_args[3], etymon_data.lang)
								if inline_etymon then
									track_keyword_usage(inline_keyword, etymon_data.lang, inline_etymon.lang)
								end
							end

							inline_args.id = etymon_data.id
							inline_args.status = M.data.STATUS.INLINE
							etymon_args = inline_args
							term_node.page_of = __state.cached_etymon_pages[key] -- term node is on the same page as the parent
						else
							-- Scraped arguments exist, &lt;ety&gt; is redundant and ignored
							__state.current_page_has_redundant_etymology = true
							if is_toplevel then
								__state.toplevel_redundant_etymology = true
							end
						end
					end

					-- Ensure container exists before checking keyword info
					ensure_container()
					
					-- Check if current keyword has no_child_categories - if so, stop recursion
					local keyword_info = current_container.keyword_info
					local should_stop_recursion = (stop_recursion or (keyword_info and keyword_info.no_child_categories))
					
					term_node = TreeBuilder.build(etymon_data.lang, etymon_data.term, etymon_args, seen, depth + 1, should_stop_recursion)
					term_node.target_key = Util.get_norm_lang(etymon_data.lang):getFullCode() ..
						&quot;:&quot; .. M.links.get_link_page(etymon_data.term, etymon_data.lang)
					term_node.id = etymon_data.id
					term_node.etymon_id = resolved_etymon_id  -- The actual etymon id when resolved via senseid
					term_node.t = etymon_data.t
					term_node.tr = etymon_data.tr
					term_node.ts = etymon_data.ts
					term_node.pos = etymon_data.pos
					term_node.alt = etymon_data.alt
					term_node.g = etymon_data.g
					term_node.ng = etymon_data.ng
					term_node.ref = etymon_data.ref
					term_node.is_uncertain = etymon_data.unc
					term_node.override = etymon_data.override
					term_node.page_of = page_of
					term_node.aftype = etymon_data.aftype
					term_node.postype = etymon_data.postype
					term_node.bor = etymon_data.bor
					term_node.lbor = etymon_data.lbor
					term_node.slbor = etymon_data.slbor
					term_node.lit = etymon_data.lit
					term_node.is_family = etymon_data.is_family
					term_node.q = etymon_data.q
					term_node.qq = etymon_data.qq
					term_node.l = etymon_data.l
					term_node.ll = etymon_data.ll
					term_node.missing_descendants_header, term_node.missing_descendants_entry =
						M.descendants.get_term_sync_flags(current_keyword, term_node.status, descendants_check)
				end

				table.insert(current_container.terms, term_node)
			end
		end
	end

	return node
end

-- Convert etymology tree to JSON-serializable table
local function tree_to_json(node)
	local obj = {
		term = node.title,
		lang = node.lang:getCode(),
		lang_name = node.lang:getCanonicalName(),
		id = (node.id and node.id ~= &quot;&quot;) and node.id or nil,
		status = node.status,
		is_uncertain = node.is_uncertain or nil,
		is_duplicate = node.is_duplicate or nil,
		gloss = node.t,
		transliteration = node.tr,
		transcription = node.ts,
		alt = node.alt,
		g = node.g,
		pos = node.pos,
		ng = node.ng,
		children = {},
	}

	for _, container in ipairs(node.children or {}) do
		local keyword_info = container.keyword_info
		if keyword_info then
			local container_obj = {
				keyword = container.keyword,
				keyword_label = keyword_info.text,
				keyword_abbrev = keyword_info.abbrev,
				is_group = keyword_info.is_group or nil,
				is_invisible = keyword_info.invisible or nil,
				is_uncertain = (container.keyword_modifiers and container.keyword_modifiers.unc) or nil,
				terms = {},
			}

			for _, term in ipairs(container.terms or {}) do
				table.insert(container_obj.terms, tree_to_json(term))
			end

			table.insert(obj.children, container_obj)
		end
	end

	return obj
end

local function track_ranges(base_key, value, ranges, lang_code)
	M.track(&quot;etymon/&quot; .. base_key .. &quot;/&quot; .. value)
	if lang_code then
		M.track(&quot;etymon/lang/&quot; .. lang_code .. &quot;/&quot; .. base_key .. &quot;/&quot; .. value)
	end

	for _, range in ipairs(ranges) do
		local matches = false
		if range.min and range.max then
			matches = value &gt;= range.min and value &lt;= range.max
		elseif range.min then
			matches = value &gt;= range.min
		elseif range.max then
			matches = value &lt;= range.max
		elseif range.exact then
			matches = value == range.exact
		end

		if matches then
			M.track(&quot;etymon/&quot; .. base_key .. &quot;/&quot; .. range.label)
			if lang_code then
				M.track(&quot;etymon/lang/&quot; .. lang_code .. &quot;/&quot; .. base_key .. &quot;/&quot; .. range.label)
			end
			break
		end
	end
end

local function track_title_pagename_mismatch_after_strip(lang)
	local lang_code = lang:getCode()
	M.track(&quot;etymon/title/pagename-mismatch-after-strip-diacritics&quot;)
	M.track(&quot;etymon/lang/&quot; .. lang_code .. &quot;/title/pagename-mismatch-after-strip-diacritics&quot;)
end

-- Build and return the etymology data tree for a given term.
function export.get_tree(lang, title, args, options)
	options = options or {}
	__state.entry_title = title
	__state.entry_lang_code = lang:getCode()

	if options.validate then
		EtymonParser.validate(lang, args, options.id, title, options.pos, false)
	end

	local lang_code = lang:getCode()

	local start_index = (args[1] == lang_code) and 2 or 1
	local tree_args = { [1] = lang_code, id = options.id or args.id }
	for i = start_index, #args do
		table.insert(tree_args, args[i])
	end

	__state.cached_etymon_args[lang_code .. &quot;:&quot; .. title .. &quot;:&quot; .. (tree_args.id or &quot;&quot;)] = tree_args

	local ety_data_tree = TreeBuilder.build(lang, title, tree_args)
	parse_tree_references(ety_data_tree)

	if options.json then
		return M.JSON.toJSON(tree_to_json(ety_data_tree))
	end

	return ety_data_tree
end

-- Given a language code, page name and optionally the id= parameter,
-- render the tree and only the etymology tree for the relevant page.
-- Fetches and parses the corresponding {{etymon}} from the requested page,
-- and any further pages needed to render the tree.
-- Parameters can be passed either through the #invoke or as
-- template parameters *through* an #invoke.
function export.render_tree_for_etymon_on_page(frame)
	local frame_args = frame.args
	local parent_args = frame:getParent().args
	local langcode = frame_args[1] or parent_args[1]
	local pagename = frame_args[2] or parent_args[2]
	local id = frame_args[&quot;id&quot;] or parent_args[&quot;id&quot;]
	local display_title = frame_args[&quot;title&quot;] or parent_args[&quot;title&quot;]

	local parsed_title = mw.title.new(pagename, 0)
	local title
	if parsed_title.namespace == 0 then
		title = M.pages.safe_page_name(parsed_title)
	elseif parsed_title.namespace == 118 then
		title = &quot;*&quot; .. M.pages.safe_page_name(parsed_title)
	else
		error(&quot;Unsupported namespace for render_tree_for_etymon_on_page: &quot; .. parsed_title.namespace)
	end

	local lang = Util.get_lang(langcode)
	-- Construct etymon_data for DataRetriever.get_args.
	local etymon_data = {
		lang = lang,
		term = title,
		id = id
	}
	local args, pagename = DataRetriever.get_etymon_args(etymon_data, true)
	if args == M.data.STATUS.MISSING then
		error(&quot;The etymon template was not found (language &quot; ..
			langcode ..
			&quot;, title '&quot; ..
			title ..
			&quot;'&quot; ..
			(id and &quot;, ID '&quot; .. id .. &quot;'&quot; or &quot;, no ID given&quot;) .. &quot;). Page contents may have changed in the interim.&quot;)
	end

	local tree_title = display_title or title
	if lang:stripDiacritics(M.links.remove_links(tree_title)) ~= lang:stripDiacritics(M.links.remove_links(title)) then
		track_title_pagename_mismatch_after_strip(lang)
	end

	local ety_data_tree = export.get_tree(lang, tree_title, args, {
		validate = true,
		id = id,
	})

	local output = {}
	table.insert(output, M.template_styles(&quot;Module:etymon/styles.css&quot;))
	table.insert(output, M.tree.render({
		data_tree = ety_data_tree,
		format_term_func = function(term, is_toplevel)
			return Util.format_term(term, is_toplevel, {
				gloss = &quot;suppress&quot;,
				pos = &quot;suppress&quot;,
				lit = &quot;suppress&quot;,
				tree_ql = &quot;suppress&quot;,
			})
		end,
	}))

	return table.concat(output)
end

function export.main(frame)
	local parent_args = frame:getParent().args
	local args = M.parameters.process(parent_args, M.parameters_data.etymon)
	local lang = args[1]
	local etymon_args = args[2]
	local id = args.id
	local title = args.title
	local text = args.text
	local tree = args.tree
	local etydate = args.etydate
	local rfe = args.rfe
	local page_data = Util.get_page_data()

	if not title then
		title = page_data.pagename
		if page_data.namespace == &quot;Reconstruction&quot; then title = &quot;*&quot; .. title end
	end

	local entry_pagename = page_data.pagename
	if page_data.namespace == &quot;Reconstruction&quot; then
		entry_pagename = &quot;*&quot; .. entry_pagename
	end
	if lang:stripDiacritics(M.links.remove_links(title)) ~= lang:stripDiacritics(M.links.remove_links(entry_pagename)) then
		track_title_pagename_mismatch_after_strip(lang)
	end

	local current_L2 = M.pages.get_current_L2()
	if current_L2 then
		local norm_lang = Util.get_norm_lang(lang)
		local norm_name = &quot;Bahasa &quot; .. norm_lang:getCanonicalName()
		if current_L2 ~= norm_name then
			local lang_desc = lang:getCode() .. &quot; (&quot; .. lang:getCanonicalName() .. &quot;)&quot;
			if norm_lang:getCode() ~= lang:getCode() then
				lang_desc = lang_desc .. &quot;, normalized to &quot; .. norm_lang:getCode() .. &quot; (&quot; .. norm_name .. &quot;)&quot;
			end
			error(&quot;Language '&quot; .. lang_desc .. &quot;' does not match the L2 header (&quot; .. current_L2 .. &quot;).&quot;)
		end
	end

	local ety_data_tree = export.get_tree(lang, title, etymon_args, {
		validate = true,
		pos = args.pos,
		id = id,
		json = args.json,
	})

	if args.json then
		return ety_data_tree
	end

	local output = {}

	local text_allowlist_mode = M.text_allowed.default_mode or &quot;off&quot;
	if text and text_allowlist_mode ~= &quot;off&quot; and not Util.is_text_param_allowed_for_lang(lang) then
		local msg = &quot;Etymology texts (parameter &lt;code&gt;text=&lt;/code&gt;) are not allowed for &quot; .. lang:getFullName() ..
			&quot;; see [[Template:etymon#Text allowlist|Template:etymon § Text allowlist]] for the list of languages that may use the &lt;code&gt;text=&lt;/code&gt; parameter.&quot;
		if text_allowlist_mode == &quot;error&quot; then
			error(msg)
		else
			Util.add_warning(msg, true)
		end
	end

	local lang_exc = Util.get_lang_exception(lang)
	if lang_exc and lang_exc.disallow then
		local disallow = lang_exc.disallow
		local error_text = &quot; for &quot; .. lang:getFullName()
		if disallow.ref then
			error_text = error_text .. &quot;; see &quot; .. disallow.ref
		else
			error_text = error_text .. &quot;.&quot;
		end
		if tree and disallow.tree then
			error(&quot;Etymology trees are not allowed&quot; .. error_text)
		end
		if text and disallow.text then
			error(&quot;Etymology texts are not allowed&quot; .. error_text)
		end
	end

	if etydate then
		local etydate_param_mods = {
			ref = { list = true, type = &quot;references&quot;, allow_holes = true },
			refn = { list = true, allow_holes = true },
			nocap = { type = &quot;boolean&quot; },
		}

		local function generate_etydate_obj(etydate_text)
			local etydate_specs = {}
			for spec in etydate_text:gmatch(&quot;[^,]+&quot;) do
				table.insert(etydate_specs, mw.text.trim(spec))
			end
			return { [1] = etydate_specs }
		end

		local parsed_etydate = M.parse_utilities.parse_inline_modifiers(etydate, { param_mods = etydate_param_mods, generate_obj = generate_etydate_obj })

		local etydate_args = {
			[1] = parsed_etydate[1],
			nocap = parsed_etydate.nocap or false,
		}

		ety_data_tree.etydate = M.etydate.format_etydate(etydate_args, { omit_refs = true })

		if parsed_etydate.ref and #parsed_etydate.ref &gt; 0 then
			ety_data_tree.etydate_refs = parsed_etydate.ref
		end
	end

	if tree then
		table.insert(output, M.template_styles(&quot;Module:etymon/styles.css&quot;))
		table.insert(output, M.tree.render({
			data_tree = ety_data_tree,
			format_term_func = function(term, is_toplevel)
				return Util.format_term(term, is_toplevel, {
					gloss = &quot;suppress&quot;,
					pos = &quot;suppress&quot;,
					lit = &quot;suppress&quot;,
					tree_ql = &quot;suppress&quot;,
				})
			end,
		}))
	end

	-- Check if there are any visible children in tree (invisible &quot;all&quot; or &quot;tree&quot; = hidden in tree)
	local has_visible_children = false
	for _, child in ipairs(ety_data_tree.children or {}) do
		local child_keyword_info = child.keyword_info
		local inv = child_keyword_info and child_keyword_info.invisible
		if not (inv == &quot;all&quot; or inv == true or inv == &quot;tree&quot;) then
			has_visible_children = true
			break
		end
	end

	local tree_disallowed = lang_exc and lang_exc.disallow and lang_exc.disallow.tree
	local ety_tree_json = M.JSON.toJSON(tree_to_json(ety_data_tree))
	local anchor = M.anchors.etymonid(lang, id, {
		no_tree = args.notree,
		title = title,
		empty_tree = (not has_visible_children) or tree_disallowed,
		ety_tree_json = ety_tree_json,
	})
	table.insert(output, anchor)

	if text then
		local max_depth, stop_at_blue_link, stop_at_lang, stop_at_lang_or_bluelink
		if text == &quot;++&quot; then
			max_depth, stop_at_blue_link = false, false
		elseif text == &quot;+&quot; then
			max_depth, stop_at_blue_link = 1, false
		elseif text == &quot;*&quot; then
			max_depth, stop_at_blue_link = false, true
		elseif text:match(&quot;^:[^*]+%*$&quot;) then
			-- Stop at a specific language OR first bluelink after it, e.g., &quot;:ota*&quot;
			-- If the target language is a redlink, continue to the first bluelink
			local lang_code = text:match(&quot;^:([^*]+)%*$&quot;)
			if lang_code and lang_code ~= &quot;&quot; then
				local lang_obj = Util.get_lang(lang_code, true)
				if lang_obj then
					stop_at_lang_or_bluelink = lang_code
				else
					Util.add_warning('Invalid language code &quot;' .. lang_code .. '&quot; in text parameter. Showing full chain instead.')
					max_depth, stop_at_blue_link = false, false
				end
			else
				Util.add_warning('Empty language code in text parameter. Showing full chain instead.')
				max_depth, stop_at_blue_link = false, false
			end
		elseif text:sub(1, 1) == &quot;:&quot; then
			-- Stop at a specific language, e.g., &quot;:ar&quot; stops at first Arabic term
			local lang_code = text:sub(2)
			if lang_code ~= &quot;&quot; then
				-- Validate the language code
				local lang_obj = Util.get_lang(lang_code, true)
				if lang_obj then
					stop_at_lang = lang_code
				else
					Util.add_warning('Invalid language code &quot;' .. lang_code .. '&quot; in text parameter. Showing full chain instead.')
					max_depth, stop_at_blue_link = false, false -- default to ++
				end
			else
				Util.add_warning('Empty language code in text parameter. Showing full chain instead.')
				max_depth, stop_at_blue_link = false, false -- default to ++
			end
		else
			local num = tonumber(text)
			if num and num &gt;= 1 then
				max_depth, stop_at_blue_link = num, false
			else
				error('Invalid text value &quot;' ..
					text .. '&quot;. Valid values are: &quot;++&quot; (full chain), &quot;+&quot; (first step only), &quot;*&quot; (until first blue link), a number (max steps), &quot;:lang&quot; (stop at language), or &quot;:lang*&quot; (stop at language or first bluelink if redlink)')
			end
		end
		table.insert(output, M.text.render({
			data_tree = ety_data_tree,
			format_term_func = Util.format_term,
			max_depth = max_depth,
			stop_at_blue_link = stop_at_blue_link,
			curr_page = page_data.pagename,
			nodot = args.nodot,
			stop_at_lang = stop_at_lang,
			stop_at_lang_or_bluelink = stop_at_lang_or_bluelink,
		}))
	end

	if rfe then
		local rfe_param_mods = {
			nocat = { type = &quot;boolean&quot; },
			sort = {},
			y = {},
			m = {},
			fragment = {},
			section = {},
			box = { type = &quot;boolean&quot; },
			noes = { type = &quot;boolean&quot; },
		}

		local function generate_rfe_obj(rfe_text)
			-- Check if it's a boolean true value
			if M.yesno(rfe_text, false) then
				return { is_boolean = true }
			else
				return { text = rfe_text }
			end
		end

		local rfe_with_defaults = Util.add_boolean_defaults(rfe, rfe_param_mods)
		local parsed_rfe = M.parse_utilities.parse_inline_modifiers(rfe_with_defaults, { 
			param_mods = rfe_param_mods, 
			generate_obj = generate_rfe_obj 
		})

		local rfe_args = {
			[1] = lang:getCode(),
			nocat = parsed_rfe.nocat,
			sort = parsed_rfe.sort,
			y = parsed_rfe.y,
			m = parsed_rfe.m,
			fragment = parsed_rfe.fragment,
			section = parsed_rfe.section,
			box = parsed_rfe.box,
			noes = parsed_rfe.noes,
		}

		if not parsed_rfe.is_boolean then
			rfe_args[2] = parsed_rfe.text
		end

		table.insert(output, frame:expandTemplate({
			title = &quot;rfe&quot;,
			args = rfe_args
		}))
	end

	if Util.is_content_page() and __state.max_depth_reached &gt; 0 then
		local lang_code = lang:getCode()

		local depth_ranges = {
			{ min = 50, label = &quot;extremely-deep&quot; },
			{ min = 20, label = &quot;20+&quot; },
			{ min = 10, max = 19,                label = &quot;10-19&quot; },
			{ min = 5,  max = 9,                 label = &quot;5-9&quot; },
			{ min = 3,  max = 4,                 label = &quot;3-4&quot; },
			{ max = 2,  label = &quot;1-2&quot; }
		}

		local node_ranges = {
			{ min = 100, label = &quot;extremely-large&quot; },
			{ min = 50,  label = &quot;50+&quot; },
			{ min = 20,  max = 49,                 label = &quot;20-49&quot; },
			{ min = 10,  max = 19,                 label = &quot;10-19&quot; },
			{ min = 5,   max = 9,                  label = &quot;5-9&quot; },
			{ max = 4,   label = &quot;1-4&quot; }
		}

		local language_ranges = {
			{ min = 10,  label = &quot;10+&quot; },
			{ min = 5,   max = 9,      label = &quot;5-9&quot; },
			{ min = 3,   max = 4,      label = &quot;3-4&quot; },
			{ exact = 2, label = &quot;2&quot; },
			{ exact = 1, label = &quot;1&quot; }
		}

		track_ranges(&quot;depth&quot;, __state.max_depth_reached, depth_ranges, lang_code)
		track_ranges(&quot;nodes&quot;, __state.total_nodes, node_ranges, lang_code)

		local unique_languages = 0
		for _ in pairs(__state.language_count) do
			unique_languages = unique_languages + 1
		end
		track_ranges(&quot;unique-languages&quot;, unique_languages, language_ranges, lang_code)

		if __state.total_nodes == __state.max_depth_reached + 1 then
			track_ranges(&quot;linear-depth&quot;, __state.max_depth_reached, depth_ranges, lang_code)
		end
	end

	local categories = {}
	if Util.is_content_page() then
		local should_suppress_categories = lang_exc and lang_exc.suppress_categories
		if not should_suppress_categories and not args.nocat then
			categories = M.categories.render({
				data_tree = ety_data_tree,
				page_lang = lang,
				available_etymon_ids = __state.available_etymon_ids,
				senseid_parent_etymon = __state.senseid_parent_etymon,
				get_norm_lang_func = Util.get_norm_lang,
				lang_exc = lang_exc,
			})
		end

		local target_lang_code = lang:getCode()
		for keyword, keyword_data in pairs(__state.toplevel_keyword_stats) do
			-- Track keyword globally
			M.track(&quot;etymon/keyword/&quot; .. keyword)

			-- Track keyword per target language
			M.track(&quot;etymon/keyword/&quot; .. keyword .. &quot;/target/&quot; .. target_lang_code)

			-- Track keyword per source language
			for source_code, count in pairs(keyword_data.source_langs) do
				M.track(&quot;etymon/keyword/&quot; .. keyword .. &quot;/source/&quot; .. source_code)

				-- Track keyword per target+source combination
				M.track(&quot;etymon/keyword/&quot; .. keyword .. &quot;/target/&quot; .. target_lang_code .. &quot;/source/&quot; .. source_code)
			end
		end

		if tree then
			table.insert(categories, &quot;Pages with etymology trees&quot;)
			table.insert(categories, lang:getCanonicalName() .. &quot; entries with etymology trees&quot;)
		end
		if text then table.insert(categories, lang:getCanonicalName() .. &quot; entries with etymology texts&quot;) end
		if args.exnihilo then table.insert(categories, lang:getCanonicalName() .. &quot; terms coined ex nihilo&quot;) end
		if __state.toplevel_has_inline_etymology then
			table.insert(categories, &quot;Pages with inline etymon for redlinks&quot;)
		end
		if __state.toplevel_redundant_etymology then
			table.insert(categories, &quot;Pages with redundant inline etymon&quot;)
		end
		if __state.toplevel_idless_etymon then
			table.insert(categories, &quot;Pages using etymon with no ID&quot;)
		end
		if __state.has_mismatched_id then
			table.insert(categories, lang:getCanonicalName() .. &quot; entries referencing etymons with mismatched IDs&quot;)
		end
		if __state.linked_page_multiple_etymons_idless then
			table.insert(categories,
				lang:getCanonicalName() .. &quot; entries referencing pages with multiple etymons missing IDs&quot;)
		end
	end

	if #categories &gt; 0 then
		table.insert(output, M.categories.format(categories, lang))
	end

	if __state.warnings then
		for i, warning in ipairs(__state.warnings) do
			table.insert(output, (i == 1 and &quot;\n&quot; or &quot;&quot;) .. warning .. &quot;\n&quot;)
		end
	end

	return table.concat(output)
end

return export</text>
      <sha1>ntgc8yk38onjlpngtccb4xjlsblhzh9</sha1>
    </revision>
    <revision>
      <id>342829</id>
      <parentid>342826</parentid>
      <timestamp>2026-05-16T13:59:42Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <origin>342829</origin>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="61603" sha1="tlojdwh1m67a5w9qz5fatk486sr5xh5" xml:space="preserve">--[=[

This module implements the {{etymon}} template for structured etymology data on Wiktionary.
It enables the creation of etymology trees and text by parsing etymon chains,
scraping linked pages for their own {{etymon}} data, and recursively building a tree
of derivational relationships.

Authors:
- Original implementation: [[User:Ioaxxere]]
- Full refactor (September 2025): [[User:Fenakhay]] ([[Special:Diff/86717746]])

Modules:
- [[Module:etymon]]: main module handling parsing, validation, tree building, and page scraping
- [[Module:etymon/data]]: keyword definitions, configuration, and status constants
- [[Module:etymon/tree]]: etymology tree rendering
- [[Module:etymon/text]]: etymology text generation
- [[Module:etymon/categories]]: category generation logic

]=]

local export = {}

local etymon_data_module = &quot;Module:etymon/data&quot;
local etymon_text_module = &quot;Module:etymon/text&quot;
local etymon_tree_module = &quot;Module:etymon/tree&quot;
local etymon_categories_module = &quot;Module:etymon/categories&quot;
local etymon_descendants_module = &quot;Module:etymon/descendants&quot;

local __state = {
	cached_etymon_args = {},
	cached_etymon_pages = {},
	cached_descendants_checks = {},
	senseid_parent_etymon = {},
	available_etymon_ids = {},
	single_etymons = {},
	entry_title = nil,
	entry_lang_code = nil,
	current_page_has_inline_etymology = false,
	current_page_has_redundant_etymology = false,
	used_idless_etymon = false,
	toplevel_has_inline_etymology = false,
	toplevel_redundant_etymology = false,
	toplevel_idless_etymon = false,
	has_mismatched_id = false,
	linked_page_multiple_etymons_idless = false,
	max_depth_reached = 0,
	total_nodes = 0,
	language_count = {},
	toplevel_keyword_stats = {},
	warnings = {},
}

local loader = require(&quot;Module:module loader&quot;)

local M = loader.init({
	require = {
		data = etymon_data_module,
		tree = etymon_tree_module,
		text = etymon_text_module,
		categories = etymon_categories_module,
		descendants = etymon_descendants_module,

		anchors = &quot;Module:anchors&quot;,
		etydate = &quot;Module:etydate&quot;,
		etymology = &quot;Module:etymology&quot;,
		families = &quot;Module:families&quot;,
		languages = &quot;Module:languages&quot;,
		languages_errorgetby = &quot;Module:languages/errorGetBy&quot;,
		links = &quot;Module:links&quot;,
		pages = &quot;Module:pages&quot;,
		parameters = &quot;Module:parameters&quot;,
		string_utilities = &quot;Module:string utilities&quot;,
		template_parser = &quot;Module:template parser&quot;,
		utilities = &quot;Module:utilities&quot;,
		debug = &quot;Module:debug&quot;,
		en_utilities = &quot;Module:en-utilities&quot;,
		parse_utilities = &quot;Module:parse utilities&quot;,
		references = &quot;Module:references&quot;,
		track = &quot;Module:debug/track&quot;,
		template_styles = &quot;Module:TemplateStyles&quot;,
		script_utilities = &quot;Module:script utilities&quot;,
		JSON = &quot;Module:JSON&quot;,
		yesno = &quot;Module:yesno&quot;,
	},
	loadData = {
		headword_data = &quot;Module:headword/data&quot;,
		parameters_data = &quot;Module:parameters/data&quot;,
		text_allowed = &quot;Module:etymon/data/text_allowed&quot;,
	},
})

local Util = {}

function Util.format_error(message, preview_only)
	if preview_only and not M.pages.is_preview() then
		return nil
	end
	return '&lt;span class=&quot;error&quot;&gt;' .. message .. '&lt;/span&gt;'
end

function Util.add_warning(message, preview_only)
	local formatted = Util.format_error(message, preview_only)
	if formatted then
		table.insert(__state.warnings, formatted)
	end
end

function Util.is_text_param_allowed_for_lang(lang)
	if not lang or type(lang) ~= &quot;table&quot; then
		return false
	end
	local types = lang.getTypes and lang:getTypes()
	if types and types.family then
		local code = lang.getCode and lang:getCode()
		return code and M.text_allowed.families[code] == true
	end
	local full_code = lang.getFullCode and lang:getFullCode()
	if full_code and M.text_allowed.langs[full_code] then
		return true
	end
	if lang.inFamily then
		for family_code in pairs(M.text_allowed.families) do
			if lang:inFamily(family_code) then
				return true
			end
		end
	end
	return false
end

function Util.get_lang(code, no_error)
	if no_error then
		return M.languages.getByCode(code, nil, true)
	end
	return M.languages.getByCode(code, nil, true) or M.languages_errorgetby.code(code, true, true)
end

function Util.get_family(code)
	return M.families.getByCode(code)
end

function Util.get_lang_exception(lang)
	-- Families have no language-specific exceptions
	if lang.getTypes and lang:getTypes().family then
		return nil
	end
	local code = lang:getCode()
	local lang_exceptions = M.data.config.lang_exceptions

	if lang_exceptions[code] then
		return lang_exceptions[code]
	end

	for norm_code, exc in pairs(lang_exceptions) do
		if exc.normalize_to and code == exc.normalize_to then
			return exc
		end
		if exc.normalize_from_families then
			local should_normalize = false
			for _, family in ipairs(exc.normalize_from_families) do
				if lang:inFamily(family) then
					should_normalize = true
					break
				end
			end

			if should_normalize and exc.normalize_exclude_families then
				for _, family in ipairs(exc.normalize_exclude_families) do
					if lang:inFamily(family) then
						should_normalize = false
						break
					end
				end
			end

			if should_normalize then
				local ret = {}
				for k, v in pairs(exc) do
					ret[k] = v
				end
				ret.suppress_tr = nil
				return ret
			end
		end
	end

	return nil
end

function Util.get_norm_lang(lang)
	local exc = Util.get_lang_exception(lang)
	if exc and exc.normalize_to then
		return M.languages.getByCode(exc.normalize_to)
	end
	return lang
end

-- Add default values for boolean modifiers (e.g., &lt;unc&gt; becomes &lt;unc:1&gt;)
-- This is needed because Module:parse utilities expects boolean modifiers to have explicit values
function Util.add_boolean_defaults(str, param_mods)
	local result = str
	for name, spec in pairs(param_mods) do
		if spec.type == &quot;boolean&quot; then
			-- Replace &lt;name&gt; with &lt;name:1&gt; (but not &lt;name:...&gt; which already has a value)
			result = result:gsub(&quot;&lt;&quot; .. name .. &quot;&gt;&quot;, &quot;&lt;&quot; .. name .. &quot;:1&gt;&quot;)
		end
	end
	return result
end

-- Centralized term formatting: handles suppress_term, unknown_term, and regular terms
function Util.format_term(term, is_toplevel, opts)
	opts = opts or {}

	-- suppress_term (-) returns nil
	if term.suppress_term then
		return nil
	end

	local lang = term.lang
	local exc = Util.get_lang_exception(lang)

	if is_toplevel then
		local display_text = term.alt or term.title or &quot;&quot;
		local sc = term.sc or lang:findBestScript(display_text)
		local bold_text = tostring(mw.html.create(&quot;strong&quot;)
			:addClass(&quot;selflink&quot;)
			:wikitext(display_text))
		return M.script_utilities.tag_text(bold_text, lang, sc, &quot;term&quot;)
	end

	local link_params = { lang = lang }

	link_params.term = not term.unknown_term and term.title or nil
	link_params.alt = term.alt
	link_params.id = (not term.unknown_term and term.id and term.id ~= &quot;&quot;) and term.id or nil
	if not (exc and exc.suppress_tr) then
		link_params.tr = term.tr
		link_params.ts = term.ts
	else
		link_params.suppress_tr = true
	end
	link_params.lit = (opts.lit ~= &quot;suppress&quot;) and term.lit or nil
	if opts.gloss ~= &quot;suppress&quot; then
		link_params.gloss = term.t
	end
	if term.g and term.g ~= &quot;&quot; then
		local genders = M.string_utilities.split(term.g, &quot;,&quot;)
		for i = 1, #genders do
			genders[i] = M.string_utilities.trim(genders[i])
		end
		link_params.genders = genders
	end
	if opts.pos ~= &quot;suppress&quot; then
		link_params.pos = term.pos
		link_params.ng = term.ng
	end
	if exc and exc.suppress_tr then
		link_params.lit = nil
	end

	local show_qualifiers
	if opts.tree_ql ~= &quot;suppress&quot; then
		if term.q then
			link_params.q = term.q
		end
		if term.qq then
			link_params.qq = term.qq
		end
		if term.l then
			link_params.l = term.l
		end
		if term.ll then
			link_params.ll = term.ll
		end
		show_qualifiers = term.q or term.qq or term.l or term.ll
	end

	return M.links.full_link(link_params, &quot;term&quot;, nil, show_qualifiers and true or nil)
end

local __is_content_page_cached
function Util.is_content_page()
	if __is_content_page_cached == nil then
		__is_content_page_cached = M.pages.is_content_page(mw.title.getCurrentTitle())
	end
	return __is_content_page_cached
end

local __page_data_cached
function Util.get_page_data()
	if not __page_data_cached then
		__page_data_cached = M.headword_data.page
	end
	return __page_data_cached
end

-- Extract base keyword from param (without modifiers)
local function get_keyword_base(param)
	if type(param) ~= &quot;string&quot; then return nil end
	local base = param:match(&quot;^:?([^&lt;]+)&quot;) or param:gsub(&quot;^:&quot;, &quot;&quot;)
	return base
end

local function is_keyword(param, allow_colon_less)
	if type(param) ~= &quot;string&quot; then return false end
	local keywords = M.data.keywords
	if param:sub(1, 1) == &quot;:&quot; then
		local base = get_keyword_base(param)
		return keywords[base] ~= nil
	end
	if allow_colon_less then
		local base = get_keyword_base(param)
		return keywords[base] ~= nil
	end
	return false
end

local function get_keyword(param, allow_colon_less)
	if type(param) ~= &quot;string&quot; then return nil end
	local keywords = M.data.keywords
	if param:sub(1, 1) == &quot;:&quot; then
		return get_keyword_base(param)
	end
	if allow_colon_less then
		local base = get_keyword_base(param)
		if keywords[base] then
			return base
		end
	end
	return nil
end

local function normalize_keyword(keyword)
	if keyword:sub(1, 1) == &quot;:&quot; then
		return keyword
	end
	return &quot;:&quot; .. keyword
end

-- Resolve keyword (possibly an alias) to its canonical form. Used only at input boundaries
local function get_canonical_keyword(keyword)
	if not keyword then return keyword end
	return M.data.keyword_canonical[keyword] or keyword
end

-- Build text/phrase for nominalization with &lt;g:code&gt; (uses data module for codes only).
local function get_nominalization_label_for_g(code)
	if not code or code == &quot;&quot; then return nil end
	local codes = M.data.nominalization_g_codes
	local adj = codes[code]
	if not adj and #code == 2 then
		local gender_adj = codes[code:sub(1, 1)]
		local number_adj = codes[code:sub(2, 2)]
		if gender_adj and number_adj then
			adj = gender_adj .. &quot; &quot; .. number_adj
		end
	end
	if not adj then return nil end
	local text = adj:gsub(&quot;^%l&quot;, function(c) return string.upper(c) end) .. &quot; [[Appendix:Glossary#nominalization|nominalization]] of&quot;
	local phrase = M.en_utilities.add_indefinite_article(adj .. &quot; [[Appendix:Glossary#nominalization|nominalization]] of&quot;, false)
	return { text = text, phrase = phrase }
end

local EtymonParser = {}

-- Keyword modifier definitions
EtymonParser.keyword_param_mods = {
	unc = { type = &quot;boolean&quot; },
	ref = {},
	text = { restrict = { keywords = { &quot;from&quot;, &quot;derived&quot; } } },
	lit = { restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot;, &quot;univerbation&quot; } } },
	conj = {}, -- conjunction for alternatives: &quot;and&quot;, &quot;or&quot;, &quot;and/or&quot;, etc.
	g = { restrict = { keywords = { &quot;nominalization&quot; } } },
}

-- Term modifier definitions
EtymonParser.etymon_param_mods = {
	id = {},
	t = {},
	tr = {},
	ts = {},
	q = {},
	qq = {},
	l = {},
	ll = {},
	pos = {},
	ng = {},
	alt = {},
	g = {},
	ety = {},
	lit = {},
	unc = { type = &quot;boolean&quot; },
	ref = {},
	aftype = { restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot;, &quot;afeq&quot; } } },
	postype = {},
	bor = { type = &quot;boolean&quot;, restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot; } } },
	slbor = { type = &quot;boolean&quot;, restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot; } } },
	lbor = { type = &quot;boolean&quot;, restrict = { keywords = { &quot;affix&quot;, &quot;surf&quot; } } },
}

local function get_clean_param_mods(param_mods)
	local clean = {}
	for mod_name, mod_def in pairs(param_mods) do
		clean[mod_name] = {}
		for key, value in pairs(mod_def) do
			if key ~= &quot;restrict&quot; then
				clean[mod_name][key] = value
			end
		end
	end
	return clean
end

function EtymonParser.check_modifier_restrictions(modifiers, current_keyword, param_mods)
	for mod_name, mod_value in pairs(modifiers) do
		-- Only check restrictions if the modifier has a non-false/nil value
		if mod_value then
			local mod_def = param_mods[mod_name]
			if mod_def and mod_def.restrict and mod_def.restrict.keywords then
				local allowed_keywords = mod_def.restrict.keywords
				local is_allowed = false
				for _, allowed_keyword in ipairs(allowed_keywords) do
					if current_keyword == allowed_keyword then
						is_allowed = true
						break
					end
				end
				if not is_allowed then
					local keyword_list = {}
					for _, kw in ipairs(allowed_keywords) do
						table.insert(keyword_list, &quot;:&quot; .. kw)
					end
					local keyword_str = table.concat(keyword_list, #keyword_list == 2 and &quot; or &quot; or &quot;, &quot;)
					if #keyword_list &gt; 2 then
						-- Replace last comma with &quot;or&quot;
						keyword_str = keyword_str:gsub(&quot;, ([^,]+)$&quot;, &quot; or %1&quot;)
					end
					local mod_display = mod_value == true and &quot;&lt;&quot; .. mod_name .. &quot;&gt;&quot; or &quot;&lt;&quot; .. mod_name .. &quot;:&quot; .. tostring(mod_value) .. &quot;&gt;&quot;
					error(&quot;The modifier `&quot; .. mod_display .. &quot;` is only allowed for the keyword&quot; .. (#keyword_list &gt; 1 and &quot;s &quot; or &quot; &quot;) .. keyword_str .. &quot;.&quot;)
				end
			end
		end
	end
end

-- Parse keyword with modifiers (e.g., &quot;:bor&lt;unc&gt;&quot; or &quot;:bor&lt;ref:{{R:example}}&gt;&quot;)
function EtymonParser.parse_keyword_modifiers(param)
	if type(param) ~= &quot;string&quot; then return nil, {} end

	local base_keyword = get_keyword_base(param)
	if not base_keyword then return nil, {} end

	local canonical_keyword = get_canonical_keyword(base_keyword)

	-- Check if there are any modifiers
	if not param:find(&quot;&lt;&quot;, 1, true) then
		return canonical_keyword, {}
	end

	-- Parse modifiers using the same mechanism as etymon parsing
	local rest_with_defaults = Util.add_boolean_defaults(param, EtymonParser.keyword_param_mods)

	local function generate_obj(ignored)
		return {}
	end

	local parsed = M.parse_utilities.parse_inline_modifiers(rest_with_defaults:gsub(&quot;^:?[^&lt;]+&quot;, &quot;&quot;),
		{ param_mods = get_clean_param_mods(EtymonParser.keyword_param_mods), generate_obj = generate_obj })

	local modifiers = {
		unc = parsed.unc or false,
		ref = parsed.ref,
		text = parsed.text,
		lit = parsed.lit,
		conj = parsed.conj,
		g = parsed.g,
	}

	-- Validate modifiers against restrictions
	EtymonParser.check_modifier_restrictions(modifiers, canonical_keyword, EtymonParser.keyword_param_mods)

	return canonical_keyword, modifiers
end

function EtymonParser.parse_balanced_segments(str)
	local segments = {}
	local current = &quot;&quot;
	local depth = 0
	local i = 1

	while i &lt;= #str do
		local char = str:sub(i, i)

		if char == &quot;&lt;&quot; then
			if depth == 0 and current ~= &quot;&quot; then
				table.insert(segments, current)
				current = &quot;&quot;
			end
			depth = depth + 1
			current = current .. char
		elseif char == &quot;&gt;&quot; then
			current = current .. char
			depth = depth - 1
			if depth == 0 then
				table.insert(segments, current)
				current = &quot;&quot;
			elseif depth &lt; 0 then
				error(&quot;Unbalanced brackets in etymon: unexpected '&gt;'&quot;)
			end
		else
			current = current .. char
		end

		i = i + 1
	end

	if depth ~= 0 then
		error(&quot;Unbalanced brackets in etymon: missing '&gt;'&quot;)
	end

	if current ~= &quot;&quot; then
		table.insert(segments, current)
	end

	return segments
end

function EtymonParser.parse_inline_ety(ety_string, context_lang)
	local segments = EtymonParser.parse_balanced_segments(ety_string)

	if #segments == 0 then
		error(&quot;Empty inline etymology&quot;)
	end

	local keyword = M.string_utilities.trim(segments[1])

	if not is_keyword(keyword, true) then
		error(&quot;Invalid keyword '&quot; .. keyword .. &quot;' in inline etymology &lt;ety:&quot; .. keyword .. &quot;...&gt;&quot;)
	end

	local args = { context_lang:getCode(), normalize_keyword(get_canonical_keyword(keyword)) }

	for i = 2, #segments do
		local segment = segments[i]
		if segment:sub(1, 1) == &quot;&lt;&quot; and segment:sub(-1) == &quot;&gt;&quot; then
			local inner = segment:sub(2, -2)
			if inner ~= &quot;&quot; then
				table.insert(args, inner)
			end
		elseif is_keyword(segment, true) then
			-- Handle keywords that appear between bracketed segments
			table.insert(args, normalize_keyword(get_canonical_keyword(get_keyword(segment, true))))
		end
	end

	return args
end

function EtymonParser.parse_etymon(param, context_lang)
	if is_keyword(param) then
		return nil
	end

	if type(param) ~= &quot;string&quot; then
		return nil
	end

	local lang, rest
	local is_family = false

	local before_bracket = param:match(&quot;^([^&lt;]*)&quot;) or param
	local lang_code, rest_match = before_bracket:match(&quot;^([a-zA-Z][a-zA-Z0-9._-]*):(.*)$&quot;)

	if lang_code then
		local potential_lang = Util.get_lang(lang_code, true)
		if potential_lang then
			lang = potential_lang
			rest = param:sub(#lang_code + 2)
		else
			local potential_family = Util.get_family(lang_code)
			if potential_family then
				lang = potential_family
				rest = param:sub(#lang_code + 2)
				is_family = true
			else
				lang = context_lang
				rest = param
			end
		end
	else
		lang = context_lang
		rest = param
	end

	if rest == &quot;&quot; then
		M.track(&quot;etymon/term/empty&quot;)
	elseif rest == &quot;?&quot; then
		M.track(&quot;etymon/term/question-mark&quot;)
	elseif rest == &quot;-&quot; then
		M.track(&quot;etymon/term/hyphen&quot;)
	end

	if rest == &quot;&quot; then
		return {
			lang = lang,
			term = nil,
			unknown_term = true,
			is_family = is_family,
		}
	end

	if rest == &quot;-&quot; then
		return {
			lang = lang,
			term = nil,
			suppress_term = true,
			is_family = is_family,
		}
	end

	if not rest:find(&quot;&lt;&quot;, 1, true) then
		return {
			lang = lang,
			term = M.string_utilities.trim(rest),
			is_family = is_family,
		}
	end

	local term_text = rest:match(&quot;^([^&lt;]*)&quot;) or &quot;&quot;
	local is_unknown = (term_text == &quot;&quot;)
	local is_suppress = (term_text == &quot;-&quot;)

	local function generate_obj(ignored_term)
		return { term = (is_unknown or is_suppress) and nil or M.string_utilities.trim(term_text) }
	end

	local rest_with_defaults = Util.add_boolean_defaults(rest, EtymonParser.etymon_param_mods)

	local parsed_obj = M.parse_utilities.parse_inline_modifiers(rest_with_defaults,
		{ param_mods = get_clean_param_mods(EtymonParser.etymon_param_mods), generate_obj = generate_obj })

	if parsed_obj.id and parsed_obj.id:match(&quot;^!&quot;) then
		parsed_obj.id = parsed_obj.id:sub(2)
		parsed_obj.override = true
	end

	parsed_obj.lang = lang
	parsed_obj.is_family = is_family
	if is_unknown then
		parsed_obj.unknown_term = true
	elseif is_suppress then
		parsed_obj.suppress_term = true
	end

	return parsed_obj
end

function EtymonParser.validate(lang, args, id, title, pos, starts_with_lang_code)
	-- id is now optional, so only validate if provided
	if id then
		if mw.ustring.len(id) &lt; 2 then
			error(&quot;The `id` parameter must have at least two characters.&quot;)
		end
		if id == title or id == Util.get_page_data().pagename then
			error(&quot;The `id` parameter must not be the same as the page title.&quot;)
		end
	end

	local valid_pos = { prefix = true, suffix = true, interfix = true, infix = true, root = true, word = true }
	if pos and not valid_pos[pos] then
		error(&quot;Unknown value provided for `pos`. Valid values: &quot; .. table.concat(require(&quot;Module:table&quot;).keysToList(valid_pos), &quot;, &quot;) .. &quot;.&quot;)
	end

	local current_keyword = &quot;from&quot;
	local etymons_in_group = {}
	local keywords = M.data.keywords

	local function checkGroup()
		if keywords[current_keyword] and keywords[current_keyword].is_group and current_keyword ~= &quot;affix&quot; and current_keyword ~= &quot;surf&quot; and current_keyword ~= &quot;afeq&quot; and current_keyword ~= &quot;univerbation&quot; and #etymons_in_group &lt;= 1 then
			error(&quot;Detected `:&quot; .. current_keyword .. &quot;` group with fewer than two etymons.&quot;)
		end
		etymons_in_group = {}
	end

	local start_index = starts_with_lang_code and 2 or 1

	for i = start_index, #args do
		local param = args[i]

		if type(param) ~= &quot;string&quot; then
		elseif param:sub(1, 1) == &quot;:&quot; and not is_keyword(param) then
			error(&quot;Invalid keyword '&quot; .. param .. &quot;'. Did you mean a valid keyword like ':bor', ':inh', etc.?&quot;)
		elseif is_keyword(param) then
			checkGroup()
			current_keyword = get_canonical_keyword(get_keyword(param))
		else
			local etymon_data = EtymonParser.parse_etymon(param, lang)
			if etymon_data then
				table.insert(etymons_in_group, param)
				local param_lang = etymon_data.lang

				if etymon_data.is_family and current_keyword == &quot;inherited&quot; then
					error(&quot;`:inh` does not support family codes; use a specific language.&quot;)
				end
				if etymon_data.is_family and not etymon_data.suppress_term then
					error(&quot;Family codes require suppressed term (use family:-).&quot;)
				end
				if current_keyword == &quot;from&quot; and param_lang:getFullCode() ~= lang:getFullCode() then
					error(&quot;`:from` is for same-language derivation, but language does not match. &quot; ..
						&quot;Expected '&quot; .. lang:getFullCode() .. &quot;', got '&quot; .. param_lang:getFullCode() .. &quot;'.&quot;)
				elseif current_keyword == &quot;inherited&quot; then
					M.etymology.check_ancestor(lang, param_lang)
				end

				-- Check modifier restrictions
				EtymonParser.check_modifier_restrictions(etymon_data, current_keyword, EtymonParser.etymon_param_mods)

				-- postype must be &quot;root&quot; or &quot;word&quot;
				local VALID_POSTYPES = { root = true, word = true }
				if etymon_data.postype and not VALID_POSTYPES[etymon_data.postype] then
					error(&quot;Invalid &lt;postype:&quot; .. etymon_data.postype .. &quot;&gt;; must be \&quot;root\&quot; or \&quot;word\&quot;.&quot;)
				end

				if etymon_data.ety then
					local inline_args = EtymonParser.parse_inline_ety(etymon_data.ety, etymon_data.lang)
					EtymonParser.validate(etymon_data.lang, inline_args, nil, nil, nil, true)
				end
			else
				table.insert(etymons_in_group, param)
			end
		end
	end

	checkGroup()
end

local DataRetriever = {}

-- Given an etymon data, scrape its page and cache the result in the global state object.
function DataRetriever.cache_page_etymons(etymon_page, etymon_title, key, etymon_lang, etymon_id, redirected_from, descendants_is_toplevel)
	local content = etymon_title:getContent()
	if not content then
		__state.cached_etymon_args[key] = M.data.STATUS.REDLINK
		return
	end

	-- Check if the linked page is a redirect. If it is, the template parsing
	-- code below will be effectively skipped, and `scrape_page` will be called
	-- again on the redirect target (see the bottom of this function)
	local lang_section_for_descendants = nil
	local redirect_target = etymon_title.redirect_target
	if not redirect_target then
		content = M.pages.get_section(content, etymon_lang:getFullName(), 2)
		if not content then
			__state.cached_etymon_args[key] = M.data.STATUS.MISSING
			return
		end
		lang_section_for_descendants = content
	end

	local etymon_lang_code = etymon_lang:getFullCode()
	local lang_page_key = etymon_lang_code .. &quot;:&quot; .. etymon_page
	local found_templates_for_lang = {}
	local found_ids = {}
	local get_node_class = M.template_parser.class_else_type

	-- Look for all {{etymon}} templates within the page content using the template parser
	-- This way the same page is never parsed more than once

	-- Build a map from senseids to their parent etymonids.
	local active_etymon_args = nil

	for node in M.template_parser.parse(content):iterate_nodes() do
		local node_class = get_node_class(node)

		if node_class == &quot;heading&quot; then
			-- A new L2 or etymology section acts as a barrier: an {{etymon}} usage
			-- used previously cannot be the parent of any subsequent senseids.
			-- Note that we don't have to check for L2s due to the usage of `M.pages.get_section` above.
			if node:get_name():find(&quot;^Etymology&quot;) then
				active_etymon_args = nil
			end
		elseif node_class == &quot;template&quot; then
			local template_name = node:get_name()

			if template_name == &quot;etymon&quot; then
				local template_args = node:get_arguments()

				-- Check if this etymon is for our language
				if template_args[1] == etymon_lang_code then
					table.insert(found_templates_for_lang, template_args)

					if template_args.id then
						local etymon_key = lang_page_key .. &quot;:&quot; .. template_args.id
						__state.cached_etymon_args[etymon_key] = template_args
						__state.cached_etymon_pages[etymon_key] = tostring(etymon_page)
						table.insert(found_ids, template_args.id)
						active_etymon_args = template_args
					else
						-- Store idless etymon with default key
						local etymon_key = lang_page_key .. &quot;:*&quot;
						__state.cached_etymon_args[etymon_key] = template_args
						__state.cached_etymon_pages[etymon_key] = tostring(etymon_page)
						table.insert(found_ids, &quot;*&quot;)
						active_etymon_args = template_args
					end
				end
			elseif active_etymon_args and template_name == &quot;senseid&quot; then
				local template_args = node:get_arguments()

				-- This should always be true for proper usages of {{senseid}}.
				if template_args[1] == etymon_lang_code and template_args[2] then
					local sense_id_key = lang_page_key .. &quot;:&quot; .. template_args[2]
					__state.senseid_parent_etymon[sense_id_key] = active_etymon_args
					__state.cached_etymon_pages[sense_id_key] = tostring(etymon_page)
				end
			end
		end
	end

	if descendants_is_toplevel and lang_section_for_descendants and #found_templates_for_lang &gt; 0 then
		M.descendants.cache_page_checks({
			lang_section = lang_section_for_descendants,
			etymon_lang_code = etymon_lang_code,
			found_templates_for_lang = found_templates_for_lang,
			entry_title = __state.entry_title,
			entry_lang_code = __state.entry_lang_code,
			entry_lang = __state.entry_lang_code and Util.get_lang(__state.entry_lang_code, true) or nil,
			cached_descendants_checks = __state.cached_descendants_checks,
			lang_page_key = lang_page_key,
			redirected_from = redirected_from,
		})
	end

	local id_data_list = {}
	for _, args in ipairs(found_templates_for_lang) do
		local id = args.id or &quot;*&quot;
		table.insert(id_data_list, { id = id, pos = args.pos })
	end
	__state.available_etymon_ids[lang_page_key] = id_data_list

	if #found_templates_for_lang == 1 then
		__state.single_etymons[lang_page_key] = found_templates_for_lang[1]
	end

	if redirected_from and __state.available_etymon_ids[lang_page_key] then
		__state.available_etymon_ids[redirected_from] = __state.available_etymon_ids[redirected_from] or {}
		for _, id_data in ipairs(__state.available_etymon_ids[lang_page_key]) do
			table.insert(__state.available_etymon_ids[redirected_from], id_data)
		end
	end

	if __state.cached_etymon_args[key] ~= nil or __state.senseid_parent_etymon[key] ~= nil then
		-- All done!
		return
	elseif redirect_target and not redirected_from then
		-- Try scraping the redirect.
		etymon_page = redirect_target.prefixedText
		DataRetriever.cache_page_etymons(etymon_page, redirect_target, lang_page_key .. &quot;:&quot; .. etymon_id, etymon_lang, etymon_id, lang_page_key, descendants_is_toplevel)
		__state.cached_etymon_args[key] = __state.cached_etymon_args[etymon_lang_code .. &quot;:&quot; .. etymon_page .. &quot;:&quot; .. etymon_id]
	else
		__state.cached_etymon_args[key] = M.data.STATUS.MISSING
	end
end

-- Given an etymon object, scrape its page (if necessary) and return its own etymon arguments as well as the page name.
function DataRetriever.get_etymon_args(etymon_data, is_toplevel)
	local page = M.links.get_link_page(etymon_data.term, etymon_data.lang)
	local norm_lang = Util.get_norm_lang(etymon_data.lang)
	local base_key = norm_lang:getFullCode() .. &quot;:&quot; .. page

	if etymon_data.id then
		local key = base_key .. &quot;:&quot; .. etymon_data.id

		local cached_args = __state.cached_etymon_args[key] or __state.senseid_parent_etymon[key]
		if cached_args == nil then
			local title = mw.title.new(page)
			if not title then error('Invalid page title &quot;' .. page .. '&quot; encountered.') end
			DataRetriever.cache_page_etymons(page, title, key, norm_lang, etymon_data.id, nil, is_toplevel)
		end
		cached_args = __state.cached_etymon_args[key] or __state.senseid_parent_etymon[key] -- refresh

		-- Get etymon_id from parent if this was resolved via senseid
		local parent_etymon = __state.senseid_parent_etymon[key]
		local resolved_etymon_id = parent_etymon and parent_etymon.id
		local descendants_check = M.descendants.get_lookup_check({
			cached_descendants_checks = __state.cached_descendants_checks,
			is_toplevel = is_toplevel,
			base_key = base_key,
			lookup = {
				explicit_id = etymon_data.id,
				parent_etymon = parent_etymon,
			},
		})
		if is_toplevel and descendants_check == nil then
			local title = mw.title.new(page)
			if title then
				DataRetriever.cache_page_etymons(page, title, key, norm_lang, etymon_data.id, nil, true)
				descendants_check = M.descendants.get_lookup_check({
					cached_descendants_checks = __state.cached_descendants_checks,
					is_toplevel = true,
					base_key = base_key,
					lookup = {
						explicit_id = etymon_data.id,
						parent_etymon = parent_etymon,
					},
				})
			end
		end
		return cached_args, __state.cached_etymon_pages[key], resolved_etymon_id, descendants_check
	else
		__state.used_idless_etymon = true
		if is_toplevel then
			__state.toplevel_idless_etymon = true
		end

		if __state.available_etymon_ids[base_key] == nil then
			local title = mw.title.new(page)
			if not title then error('Invalid page title &quot;' .. page .. '&quot; encountered.') end
			DataRetriever.cache_page_etymons(page, title, base_key .. &quot;:*&quot;, norm_lang, &quot;*&quot;, nil, is_toplevel)
		end

		local ids = __state.available_etymon_ids[base_key] or {}
		local count = #ids

		-- Try to filter by postype if available and we have multiple candidates
		if count &gt; 1 and etymon_data.postype then
			local matching_ids = {}
			for _, id_data in ipairs(ids) do
				if id_data.pos == etymon_data.postype then
					table.insert(matching_ids, id_data)
				end
			end
			
			if #matching_ids == 1 then
				local matched_id = matching_ids[1].id
				local matched_key = base_key .. &quot;:&quot; .. matched_id
				local descendants_check = M.descendants.get_lookup_check({
					cached_descendants_checks = __state.cached_descendants_checks,
					is_toplevel = is_toplevel,
					base_key = base_key,
					lookup = { id = matched_id },
				})
				if is_toplevel and descendants_check == nil then
					local title = mw.title.new(page)
					if title then
						DataRetriever.cache_page_etymons(page, title, base_key .. &quot;:*&quot;, norm_lang, &quot;*&quot;, nil, true)
						descendants_check = M.descendants.get_lookup_check({
							cached_descendants_checks = __state.cached_descendants_checks,
							is_toplevel = true,
							base_key = base_key,
							lookup = { id = matched_id },
						})
					end
				end
				return __state.cached_etymon_args[matched_key], __state.cached_etymon_pages[matched_key], nil, descendants_check
			end
		end

		if count == 1 then
			local only_id_data = ids[1]
			local only_id = (type(only_id_data) == &quot;table&quot; and only_id_data.id) or only_id_data or &quot;*&quot;
			local descendants_check = M.descendants.get_lookup_check({
				cached_descendants_checks = __state.cached_descendants_checks,
				is_toplevel = is_toplevel,
				base_key = base_key,
				lookup = { id_data = only_id_data },
			})
			if is_toplevel and descendants_check == nil then
				local title = mw.title.new(page)
				if title then
					DataRetriever.cache_page_etymons(page, title, base_key .. &quot;:*&quot;, norm_lang, &quot;*&quot;, nil, true)
					descendants_check = M.descendants.get_lookup_check({
						cached_descendants_checks = __state.cached_descendants_checks,
						is_toplevel = true,
						base_key = base_key,
						lookup = { id_data = only_id_data },
					})
				end
			end
			return __state.single_etymons[base_key], __state.cached_etymon_pages[base_key .. &quot;:&quot; .. only_id], nil, descendants_check
		elseif count &gt; 1 then
			local page_link = M.links.full_link({
				term = page,
				lang = norm_lang,
				no_generate_forms = true,
			}, &quot;term&quot;)

			local function format_id_hint(id_data, idx)
				local id = type(id_data) == &quot;table&quot; and id_data.id or id_data
				local pos = type(id_data) == &quot;table&quot; and id_data.pos
				if id and id ~= &quot;&quot; and id ~= &quot;*&quot; then
					return '&quot;' .. id .. '&quot;'
				end
				if pos and pos ~= &quot;&quot; then
					return &quot;unnamed (|pos=&quot; .. pos .. &quot;|)&quot;
				end
				return &quot;etymon #&quot; .. idx .. &quot; (no |id= on page)&quot;
			end

			local id_list = {}
			local all_idless = true
			local target_has_idless = false
			for i, id_data in ipairs(ids) do
				local id = type(id_data) == &quot;table&quot; and id_data.id or id_data
				if id and id ~= &quot;&quot; and id ~= &quot;*&quot; then
					all_idless = false
				else
					target_has_idless = true
				end
				table.insert(id_list, format_id_hint(id_data, i))
			end

			if is_toplevel and target_has_idless then
				__state.linked_page_multiple_etymons_idless = true
			end

			local any_pos = false
			for _, id_data in ipairs(ids) do
				local pos = type(id_data) == &quot;table&quot; and id_data.pos
				if pos and pos ~= &quot;&quot; then
					any_pos = true
					break
				end
			end

			local suggestion_text
			local lead = &quot;Etymology link to &quot; .. page_link .. &quot; is ambiguous (&quot; .. count .. &quot; {{etymon}} templates for &quot;
				.. norm_lang:getCanonicalName() .. &quot;).&quot;
			if all_idless then
				if any_pos then
					suggestion_text = &quot; None set `|id=` yet; add a unique `|id=` to each on &quot; .. page_link
						.. &quot;, then `&lt;id:identifier&gt;` after the term here. Section order / hints: &quot;
						.. mw.text.listToText(id_list) .. &quot;.&quot;
				else
					suggestion_text = &quot; None set `|id=` yet; add a unique `|id=` to each {{etymon}} in that section from top to bottom, then `&lt;id:identifier&gt;` after the term here (same value as `|id=`).&quot;
				end
			else
				suggestion_text = &quot; Specify which one with `&lt;id:identifier&gt;` after the term. Options: &quot; .. mw.text.listToText(id_list) .. &quot;.&quot;
			end

			Util.add_warning(lead .. suggestion_text, true)

			return M.data.STATUS.AMBIGUOUS, nil, nil, nil
		else
			return M.data.STATUS.MISSING, nil, nil, nil
		end
	end
end

local TreeBuilder = {}

local function parse_etymon_references(refs_text)
	if not refs_text or refs_text == &quot;&quot; then
		return &quot;&quot;
	end
	return M.references.parse_references(refs_text)
end

local function parse_tree_references(node)
	if node.ref then
		node.parsed_ref = parse_etymon_references(node.ref)
	end

	if node.children then
		for _, container in ipairs(node.children) do
			if container.terms then
				for _, term in ipairs(container.terms) do
					parse_tree_references(term)
				end
			end
		end
	end
end

-- Build a unique key for deduplication in the seen table
function TreeBuilder.build_key(lang, title, args)
	local norm_lang_code = Util.get_norm_lang(lang):getFullCode()
	local is_table = type(args) == &quot;table&quot;
	local id = (is_table and args.id) or &quot;&quot;
	
	if title then
		return norm_lang_code .. &quot;:&quot; .. M.links.get_link_page(title, lang) .. &quot;:&quot; .. id
	end
	
	if is_table and args.status == M.data.STATUS.INLINE then
		local content_parts = {}
		for i = 1, #args do
			content_parts[i] = tostring(args[i])
		end
		return norm_lang_code .. &quot;:*:&quot; .. id .. &quot;\0&quot; .. table.concat(content_parts, &quot;\0&quot;)
	end
	
	return norm_lang_code .. &quot;:*:&quot; .. id
end

function TreeBuilder.build(lang, title, args, seen, depth, stop_recursion)
	seen = seen or {}
	depth = depth or 0
	local is_toplevel = (depth == 0)

	if depth &gt; __state.max_depth_reached then
		__state.max_depth_reached = depth
	end

	__state.total_nodes = __state.total_nodes + 1

	local lang_code = lang:getCode()
	__state.language_count[lang_code] = (__state.language_count[lang_code] or 0) + 1

	local current_id = (type(args) == &quot;table&quot; and args.id) or &quot;&quot;
	local key = TreeBuilder.build_key(lang, title, args)
	
	local node = { lang = lang, title = title, id = current_id, args = args, children = {}, status = M.data.STATUS.OK }

	if type(args) ~= &quot;table&quot; or seen[key] then
		node.status = args or M.data.STATUS.MISSING
		-- Mark as duplicate if we've seen this node before
		if seen[key] then
			node.is_duplicate = true
			node.duplicate_key = key
			local original_node = seen[key]
			if type(original_node) == &quot;table&quot; and original_node.children and #original_node.children &gt; 0 then
				node.original_has_children = true
			end
		end
		return node
	end

	node.status = args.status or M.data.STATUS.OK

	seen[key] = node

	-- If stop_recursion is set, skip parsing children but check for visible children
	if stop_recursion then
		local keywords = M.data.keywords
		local has_visible_children = false
		for i = 2, #args do
			local param = args[i]
			if type(param) == &quot;string&quot; then
				local keyword_base = get_keyword_base(param)
				if keyword_base and keywords[keyword_base] then
					-- It's a keyword, check if visible in tree (invisible &quot;all&quot; or &quot;tree&quot; = hidden in tree)
					local keyword_info = keywords[keyword_base]
					local inv = keyword_info.invisible
					if not (inv == &quot;all&quot; or inv == true or inv == &quot;tree&quot;) then
						has_visible_children = true
						break
					end
				elseif param:sub(1, 1) ~= &quot;:&quot; then
					-- It's a term (not a keyword), so there are visible children
					has_visible_children = true
					break
				end
			end
		end
		node.has_visible_children = has_visible_children
		return node
	end

	-- Parse args into keyword containers
	local current_keyword = &quot;from&quot;
	local current_keyword_modifiers = {}
	local current_container = nil

	-- Helper to track keyword usage at top level
	local function track_keyword_usage(keyword, target_lang, source_lang)
		if not is_toplevel then return end

		if not __state.toplevel_keyword_stats[keyword] then
			__state.toplevel_keyword_stats[keyword] = {
				count = 0,
				target_langs = {},
				source_langs = {},
			}
		end

		local keyword_data = __state.toplevel_keyword_stats[keyword]
		keyword_data.count = keyword_data.count + 1

		local target_code = target_lang:getCode()
		keyword_data.target_langs[target_code] = (keyword_data.target_langs[target_code] or 0) + 1

		if source_lang then
			local source_code = source_lang:getCode()
			keyword_data.source_langs[source_code] = (keyword_data.source_langs[source_code] or 0) + 1
		end
	end

	local function ensure_container()
		if not current_container or current_container.keyword ~= current_keyword then
			current_container = {
				keyword = current_keyword,
				keyword_info = M.data.keywords[current_keyword],
				keyword_modifiers = current_keyword_modifiers,
				terms = {},
			}
			table.insert(node.children, current_container)
			-- Override keyword text/phrase for nominalization with &lt;g:code&gt;
			if current_keyword_modifiers.g and current_keyword == &quot;nominalization&quot; then
				local labels = get_nominalization_label_for_g(current_keyword_modifiers.g)
				if not labels then
					local codes = {}
					for c in pairs(M.data.nominalization_g_codes) do table.insert(codes, c) end
					table.sort(codes)
					error(&quot;Invalid &lt;g:&quot; .. tostring(current_keyword_modifiers.g) .. &quot;&gt;. Supported codes for nominalization: &quot; .. table.concat(codes, &quot;, &quot;))
				end
				current_container.keyword_info = {}
				for k, v in pairs(M.data.keywords[current_keyword]) do current_container.keyword_info[k] = v end
				current_container.keyword_info.text = labels.text
				current_container.keyword_info.phrase = labels.phrase
			end
		end
	end

	for i = 2, #args do
		local param = args[i]

		if is_keyword(param) then
			local keyword, modifiers = EtymonParser.parse_keyword_modifiers(param)
			current_keyword = keyword
			current_keyword_modifiers = modifiers
			current_container = nil -- Force new container for new keyword
		elseif type(param) == &quot;string&quot; and param:sub(1, 1) == &quot;:&quot; then
			error(&quot;Invalid keyword '&quot; .. param .. &quot;'. Did you mean a valid keyword like ':bor', ':inh', etc.?&quot;)
		elseif type(param) == &quot;string&quot; then
			local etymon_data = EtymonParser.parse_etymon(param, lang)

			if etymon_data then
				-- Track keyword usage at top level
				track_keyword_usage(current_keyword, lang, etymon_data.lang)

				local term_node = {}

				-- Handle suppress_term (-) and unknown_term (empty) directly
				if etymon_data.suppress_term or etymon_data.unknown_term then
					ensure_container()
					if etymon_data.ety then
						local inline_args = EtymonParser.parse_inline_ety(etymon_data.ety, etymon_data.lang)
						inline_args.id = etymon_data.id
						inline_args.status = M.data.STATUS.INLINE
						term_node = TreeBuilder.build(etymon_data.lang, nil, inline_args, seen, depth + 1)
					else
						term_node = {
							lang = etymon_data.lang,
							children = {},
							status = M.data.STATUS.OK,
						}
					end
					term_node.suppress_term = etymon_data.suppress_term
					term_node.unknown_term = etymon_data.unknown_term
					term_node.is_family = etymon_data.is_family
					term_node.is_uncertain = etymon_data.unc
					term_node.ref = etymon_data.ref
					term_node.t = etymon_data.t
					term_node.tr = etymon_data.tr
					term_node.ts = etymon_data.ts
					term_node.alt = etymon_data.alt
					term_node.g = etymon_data.g
					term_node.pos = etymon_data.pos
					term_node.ng = etymon_data.ng
					term_node.lit = etymon_data.lit
					term_node.q = etymon_data.q
					term_node.qq = etymon_data.qq
					term_node.l = etymon_data.l
					term_node.ll = etymon_data.ll
				else
					-- Regular term: fetch arguments from page
					local etymon_args, page_of, resolved_etymon_id, descendants_check = DataRetriever.get_etymon_args(etymon_data, is_toplevel)

					if etymon_data.id and etymon_args == M.data.STATUS.MISSING and not etymon_data.ety then
						local page = M.links.get_link_page(etymon_data.term, etymon_data.lang)
						local norm_lang = Util.get_norm_lang(etymon_data.lang)
						local base_key = norm_lang:getFullCode() .. &quot;:&quot; .. page
						local available_ids = __state.available_etymon_ids[base_key] or {}

						if #available_ids &gt; 0 then
							__state.has_mismatched_id = true
						end
					end

					-- Check for &lt;ety&gt; inline parameter doesn't override the scraped arguments, unless the latter are missing
					if etymon_data.ety then
						if etymon_args == M.data.STATUS.REDLINK or etymon_args == M.data.STATUS.MISSING then
							__state.current_page_has_inline_etymology = true
							if is_toplevel then
								__state.toplevel_has_inline_etymology = true
							end

							local inline_args = EtymonParser.parse_inline_ety(etymon_data.ety, etymon_data.lang)

							-- Track inline ety keywords too
							local inline_keyword = get_keyword(inline_args[2], true)
							if inline_keyword and #inline_args &gt;= 3 then
								local inline_etymon = EtymonParser.parse_etymon(inline_args[3], etymon_data.lang)
								if inline_etymon then
									track_keyword_usage(inline_keyword, etymon_data.lang, inline_etymon.lang)
								end
							end

							inline_args.id = etymon_data.id
							inline_args.status = M.data.STATUS.INLINE
							etymon_args = inline_args
							term_node.page_of = __state.cached_etymon_pages[key] -- term node is on the same page as the parent
						else
							-- Scraped arguments exist, &lt;ety&gt; is redundant and ignored
							__state.current_page_has_redundant_etymology = true
							if is_toplevel then
								__state.toplevel_redundant_etymology = true
							end
						end
					end

					-- Ensure container exists before checking keyword info
					ensure_container()
					
					-- Check if current keyword has no_child_categories - if so, stop recursion
					local keyword_info = current_container.keyword_info
					local should_stop_recursion = (stop_recursion or (keyword_info and keyword_info.no_child_categories))
					
					term_node = TreeBuilder.build(etymon_data.lang, etymon_data.term, etymon_args, seen, depth + 1, should_stop_recursion)
					term_node.target_key = Util.get_norm_lang(etymon_data.lang):getFullCode() ..
						&quot;:&quot; .. M.links.get_link_page(etymon_data.term, etymon_data.lang)
					term_node.id = etymon_data.id
					term_node.etymon_id = resolved_etymon_id  -- The actual etymon id when resolved via senseid
					term_node.t = etymon_data.t
					term_node.tr = etymon_data.tr
					term_node.ts = etymon_data.ts
					term_node.pos = etymon_data.pos
					term_node.alt = etymon_data.alt
					term_node.g = etymon_data.g
					term_node.ng = etymon_data.ng
					term_node.ref = etymon_data.ref
					term_node.is_uncertain = etymon_data.unc
					term_node.override = etymon_data.override
					term_node.page_of = page_of
					term_node.aftype = etymon_data.aftype
					term_node.postype = etymon_data.postype
					term_node.bor = etymon_data.bor
					term_node.lbor = etymon_data.lbor
					term_node.slbor = etymon_data.slbor
					term_node.lit = etymon_data.lit
					term_node.is_family = etymon_data.is_family
					term_node.q = etymon_data.q
					term_node.qq = etymon_data.qq
					term_node.l = etymon_data.l
					term_node.ll = etymon_data.ll
					term_node.missing_descendants_header, term_node.missing_descendants_entry =
						M.descendants.get_term_sync_flags(current_keyword, term_node.status, descendants_check)
				end

				table.insert(current_container.terms, term_node)
			end
		end
	end

	return node
end

-- Convert etymology tree to JSON-serializable table
local function tree_to_json(node)
	local obj = {
		term = node.title,
		lang = node.lang:getCode(),
		lang_name = node.lang:getCanonicalName(),
		id = (node.id and node.id ~= &quot;&quot;) and node.id or nil,
		status = node.status,
		is_uncertain = node.is_uncertain or nil,
		is_duplicate = node.is_duplicate or nil,
		gloss = node.t,
		transliteration = node.tr,
		transcription = node.ts,
		alt = node.alt,
		g = node.g,
		pos = node.pos,
		ng = node.ng,
		children = {},
	}

	for _, container in ipairs(node.children or {}) do
		local keyword_info = container.keyword_info
		if keyword_info then
			local container_obj = {
				keyword = container.keyword,
				keyword_label = keyword_info.text,
				keyword_abbrev = keyword_info.abbrev,
				is_group = keyword_info.is_group or nil,
				is_invisible = keyword_info.invisible or nil,
				is_uncertain = (container.keyword_modifiers and container.keyword_modifiers.unc) or nil,
				terms = {},
			}

			for _, term in ipairs(container.terms or {}) do
				table.insert(container_obj.terms, tree_to_json(term))
			end

			table.insert(obj.children, container_obj)
		end
	end

	return obj
end

local function track_ranges(base_key, value, ranges, lang_code)
	M.track(&quot;etymon/&quot; .. base_key .. &quot;/&quot; .. value)
	if lang_code then
		M.track(&quot;etymon/lang/&quot; .. lang_code .. &quot;/&quot; .. base_key .. &quot;/&quot; .. value)
	end

	for _, range in ipairs(ranges) do
		local matches = false
		if range.min and range.max then
			matches = value &gt;= range.min and value &lt;= range.max
		elseif range.min then
			matches = value &gt;= range.min
		elseif range.max then
			matches = value &lt;= range.max
		elseif range.exact then
			matches = value == range.exact
		end

		if matches then
			M.track(&quot;etymon/&quot; .. base_key .. &quot;/&quot; .. range.label)
			if lang_code then
				M.track(&quot;etymon/lang/&quot; .. lang_code .. &quot;/&quot; .. base_key .. &quot;/&quot; .. range.label)
			end
			break
		end
	end
end

local function track_title_pagename_mismatch_after_strip(lang)
	local lang_code = lang:getCode()
	M.track(&quot;etymon/title/pagename-mismatch-after-strip-diacritics&quot;)
	M.track(&quot;etymon/lang/&quot; .. lang_code .. &quot;/title/pagename-mismatch-after-strip-diacritics&quot;)
end

-- Build and return the etymology data tree for a given term.
function export.get_tree(lang, title, args, options)
	options = options or {}
	__state.entry_title = title
	__state.entry_lang_code = lang:getCode()

	if options.validate then
		EtymonParser.validate(lang, args, options.id, title, options.pos, false)
	end

	local lang_code = lang:getCode()

	local start_index = (args[1] == lang_code) and 2 or 1
	local tree_args = { [1] = lang_code, id = options.id or args.id }
	for i = start_index, #args do
		table.insert(tree_args, args[i])
	end

	__state.cached_etymon_args[lang_code .. &quot;:&quot; .. title .. &quot;:&quot; .. (tree_args.id or &quot;&quot;)] = tree_args

	local ety_data_tree = TreeBuilder.build(lang, title, tree_args)
	parse_tree_references(ety_data_tree)

	if options.json then
		return M.JSON.toJSON(tree_to_json(ety_data_tree))
	end

	return ety_data_tree
end

-- Given a language code, page name and optionally the id= parameter,
-- render the tree and only the etymology tree for the relevant page.
-- Fetches and parses the corresponding {{etymon}} from the requested page,
-- and any further pages needed to render the tree.
-- Parameters can be passed either through the #invoke or as
-- template parameters *through* an #invoke.
function export.render_tree_for_etymon_on_page(frame)
	local frame_args = frame.args
	local parent_args = frame:getParent().args
	local langcode = frame_args[1] or parent_args[1]
	local pagename = frame_args[2] or parent_args[2]
	local id = frame_args[&quot;id&quot;] or parent_args[&quot;id&quot;]
	local display_title = frame_args[&quot;title&quot;] or parent_args[&quot;title&quot;]

	local parsed_title = mw.title.new(pagename, 0)
	local title
	if parsed_title.namespace == 0 then
		title = M.pages.safe_page_name(parsed_title)
	elseif parsed_title.namespace == 118 then
		title = &quot;*&quot; .. M.pages.safe_page_name(parsed_title)
	else
		error(&quot;Unsupported namespace for render_tree_for_etymon_on_page: &quot; .. parsed_title.namespace)
	end

	local lang = Util.get_lang(langcode)
	-- Construct etymon_data for DataRetriever.get_args.
	local etymon_data = {
		lang = lang,
		term = title,
		id = id
	}
	local args, pagename = DataRetriever.get_etymon_args(etymon_data, true)
	if args == M.data.STATUS.MISSING then
		error(&quot;The etymon template was not found (language &quot; ..
			langcode ..
			&quot;, title '&quot; ..
			title ..
			&quot;'&quot; ..
			(id and &quot;, ID '&quot; .. id .. &quot;'&quot; or &quot;, no ID given&quot;) .. &quot;). Page contents may have changed in the interim.&quot;)
	end

	local tree_title = display_title or title
	if lang:stripDiacritics(M.links.remove_links(tree_title)) ~= lang:stripDiacritics(M.links.remove_links(title)) then
		track_title_pagename_mismatch_after_strip(lang)
	end

	local ety_data_tree = export.get_tree(lang, tree_title, args, {
		validate = true,
		id = id,
	})

	local output = {}
	table.insert(output, M.template_styles(&quot;Module:etymon/styles.css&quot;))
	table.insert(output, M.tree.render({
		data_tree = ety_data_tree,
		format_term_func = function(term, is_toplevel)
			return Util.format_term(term, is_toplevel, {
				gloss = &quot;suppress&quot;,
				pos = &quot;suppress&quot;,
				lit = &quot;suppress&quot;,
				tree_ql = &quot;suppress&quot;,
			})
		end,
	}))

	return table.concat(output)
end

function export.main(frame)
	local parent_args = frame:getParent().args
	local args = M.parameters.process(parent_args, M.parameters_data.etymon)
	local lang = args[1]
	local etymon_args = args[2]
	local id = args.id
	local title = args.title
	local text = args.text
	local tree = args.tree
	local etydate = args.etydate
	local rfe = args.rfe
	local page_data = Util.get_page_data()

	if not title then
		title = page_data.pagename
		if page_data.namespace == &quot;Reconstruction&quot; then title = &quot;*&quot; .. title end
	end

	local entry_pagename = page_data.pagename
	if page_data.namespace == &quot;Reconstruction&quot; then
		entry_pagename = &quot;*&quot; .. entry_pagename
	end
	if lang:stripDiacritics(M.links.remove_links(title)) ~= lang:stripDiacritics(M.links.remove_links(entry_pagename)) then
		track_title_pagename_mismatch_after_strip(lang)
	end

	local current_L2 = M.pages.get_current_L2()
	if current_L2 then
		local norm_lang = Util.get_norm_lang(lang)
		local norm_name = &quot;Bahasa &quot; .. norm_lang:getCanonicalName()
		if current_L2 ~= norm_name then
			local lang_desc = lang:getCode() .. &quot; (&quot; .. lang:getCanonicalName() .. &quot;)&quot;
			if norm_lang:getCode() ~= lang:getCode() then
				lang_desc = lang_desc .. &quot;, normalized to &quot; .. norm_lang:getCode() .. &quot; (&quot; .. norm_name .. &quot;)&quot;
			end
			error(&quot;Language '&quot; .. lang_desc .. &quot;' does not match the L2 header (&quot; .. current_L2 .. &quot;).&quot;)
		end
	end

	local ety_data_tree = export.get_tree(lang, title, etymon_args, {
		validate = true,
		pos = args.pos,
		id = id,
		json = args.json,
	})

	if args.json then
		return ety_data_tree
	end

	local output = {}

	local text_allowlist_mode = M.text_allowed.default_mode or &quot;off&quot;
	if text and text_allowlist_mode ~= &quot;off&quot; and not Util.is_text_param_allowed_for_lang(lang) then
		local msg = &quot;Etymology texts (parameter &lt;code&gt;text=&lt;/code&gt;) are not allowed for &quot; .. lang:getFullName() ..
			&quot;; see [[Template:etymon#Text allowlist|Template:etymon § Text allowlist]] for the list of languages that may use the &lt;code&gt;text=&lt;/code&gt; parameter.&quot;
		if text_allowlist_mode == &quot;error&quot; then
			error(msg)
		else
			Util.add_warning(msg, true)
		end
	end

	local lang_exc = Util.get_lang_exception(lang)
	if lang_exc and lang_exc.disallow then
		local disallow = lang_exc.disallow
		local error_text = &quot; for &quot; .. lang:getFullName()
		if disallow.ref then
			error_text = error_text .. &quot;; see &quot; .. disallow.ref
		else
			error_text = error_text .. &quot;.&quot;
		end
		if tree and disallow.tree then
			error(&quot;Etymology trees are not allowed&quot; .. error_text)
		end
		if text and disallow.text then
			error(&quot;Etymology texts are not allowed&quot; .. error_text)
		end
	end

	if etydate then
		local etydate_param_mods = {
			ref = { list = true, type = &quot;references&quot;, allow_holes = true },
			refn = { list = true, allow_holes = true },
			nocap = { type = &quot;boolean&quot; },
		}

		local function generate_etydate_obj(etydate_text)
			local etydate_specs = {}
			for spec in etydate_text:gmatch(&quot;[^,]+&quot;) do
				table.insert(etydate_specs, mw.text.trim(spec))
			end
			return { [1] = etydate_specs }
		end

		local parsed_etydate = M.parse_utilities.parse_inline_modifiers(etydate, { param_mods = etydate_param_mods, generate_obj = generate_etydate_obj })

		local etydate_args = {
			[1] = parsed_etydate[1],
			nocap = parsed_etydate.nocap or false,
		}

		ety_data_tree.etydate = M.etydate.format_etydate(etydate_args, { omit_refs = true })

		if parsed_etydate.ref and #parsed_etydate.ref &gt; 0 then
			ety_data_tree.etydate_refs = parsed_etydate.ref
		end
	end

	if tree then
		table.insert(output, M.template_styles(&quot;Module:etymon/styles.css&quot;))
		table.insert(output, M.tree.render({
			data_tree = ety_data_tree,
			format_term_func = function(term, is_toplevel)
				return Util.format_term(term, is_toplevel, {
					gloss = &quot;suppress&quot;,
					pos = &quot;suppress&quot;,
					lit = &quot;suppress&quot;,
					tree_ql = &quot;suppress&quot;,
				})
			end,
		}))
	end

	-- Check if there are any visible children in tree (invisible &quot;all&quot; or &quot;tree&quot; = hidden in tree)
	local has_visible_children = false
	for _, child in ipairs(ety_data_tree.children or {}) do
		local child_keyword_info = child.keyword_info
		local inv = child_keyword_info and child_keyword_info.invisible
		if not (inv == &quot;all&quot; or inv == true or inv == &quot;tree&quot;) then
			has_visible_children = true
			break
		end
	end

	local tree_disallowed = lang_exc and lang_exc.disallow and lang_exc.disallow.tree
	local ety_tree_json = M.JSON.toJSON(tree_to_json(ety_data_tree))
	local anchor = M.anchors.etymonid(lang, id, {
		no_tree = args.notree,
		title = title,
		empty_tree = (not has_visible_children) or tree_disallowed,
		ety_tree_json = ety_tree_json,
	})
	table.insert(output, anchor)

	if text then
		local max_depth, stop_at_blue_link, stop_at_lang, stop_at_lang_or_bluelink
		if text == &quot;++&quot; then
			max_depth, stop_at_blue_link = false, false
		elseif text == &quot;+&quot; then
			max_depth, stop_at_blue_link = 1, false
		elseif text == &quot;*&quot; then
			max_depth, stop_at_blue_link = false, true
		elseif text:match(&quot;^:[^*]+%*$&quot;) then
			-- Stop at a specific language OR first bluelink after it, e.g., &quot;:ota*&quot;
			-- If the target language is a redlink, continue to the first bluelink
			local lang_code = text:match(&quot;^:([^*]+)%*$&quot;)
			if lang_code and lang_code ~= &quot;&quot; then
				local lang_obj = Util.get_lang(lang_code, true)
				if lang_obj then
					stop_at_lang_or_bluelink = lang_code
				else
					Util.add_warning('Invalid language code &quot;' .. lang_code .. '&quot; in text parameter. Showing full chain instead.')
					max_depth, stop_at_blue_link = false, false
				end
			else
				Util.add_warning('Empty language code in text parameter. Showing full chain instead.')
				max_depth, stop_at_blue_link = false, false
			end
		elseif text:sub(1, 1) == &quot;:&quot; then
			-- Stop at a specific language, e.g., &quot;:ar&quot; stops at first Arabic term
			local lang_code = text:sub(2)
			if lang_code ~= &quot;&quot; then
				-- Validate the language code
				local lang_obj = Util.get_lang(lang_code, true)
				if lang_obj then
					stop_at_lang = lang_code
				else
					Util.add_warning('Invalid language code &quot;' .. lang_code .. '&quot; in text parameter. Showing full chain instead.')
					max_depth, stop_at_blue_link = false, false -- default to ++
				end
			else
				Util.add_warning('Empty language code in text parameter. Showing full chain instead.')
				max_depth, stop_at_blue_link = false, false -- default to ++
			end
		else
			local num = tonumber(text)
			if num and num &gt;= 1 then
				max_depth, stop_at_blue_link = num, false
			else
				error('Invalid text value &quot;' ..
					text .. '&quot;. Valid values are: &quot;++&quot; (full chain), &quot;+&quot; (first step only), &quot;*&quot; (until first blue link), a number (max steps), &quot;:lang&quot; (stop at language), or &quot;:lang*&quot; (stop at language or first bluelink if redlink)')
			end
		end
		table.insert(output, M.text.render({
			data_tree = ety_data_tree,
			format_term_func = Util.format_term,
			max_depth = max_depth,
			stop_at_blue_link = stop_at_blue_link,
			curr_page = page_data.pagename,
			nodot = args.nodot,
			stop_at_lang = stop_at_lang,
			stop_at_lang_or_bluelink = stop_at_lang_or_bluelink,
		}))
	end

	if rfe then
		local rfe_param_mods = {
			nocat = { type = &quot;boolean&quot; },
			sort = {},
			y = {},
			m = {},
			fragment = {},
			section = {},
			box = { type = &quot;boolean&quot; },
			noes = { type = &quot;boolean&quot; },
		}

		local function generate_rfe_obj(rfe_text)
			-- Check if it's a boolean true value
			if M.yesno(rfe_text, false) then
				return { is_boolean = true }
			else
				return { text = rfe_text }
			end
		end

		local rfe_with_defaults = Util.add_boolean_defaults(rfe, rfe_param_mods)
		local parsed_rfe = M.parse_utilities.parse_inline_modifiers(rfe_with_defaults, { 
			param_mods = rfe_param_mods, 
			generate_obj = generate_rfe_obj 
		})

		local rfe_args = {
			[1] = lang:getCode(),
			nocat = parsed_rfe.nocat,
			sort = parsed_rfe.sort,
			y = parsed_rfe.y,
			m = parsed_rfe.m,
			fragment = parsed_rfe.fragment,
			section = parsed_rfe.section,
			box = parsed_rfe.box,
			noes = parsed_rfe.noes,
		}

		if not parsed_rfe.is_boolean then
			rfe_args[2] = parsed_rfe.text
		end

		table.insert(output, frame:expandTemplate({
			title = &quot;rfe&quot;,
			args = rfe_args
		}))
	end

	if Util.is_content_page() and __state.max_depth_reached &gt; 0 then
		local lang_code = lang:getCode()

		local depth_ranges = {
			{ min = 50, label = &quot;extremely-deep&quot; },
			{ min = 20, label = &quot;20+&quot; },
			{ min = 10, max = 19,                label = &quot;10-19&quot; },
			{ min = 5,  max = 9,                 label = &quot;5-9&quot; },
			{ min = 3,  max = 4,                 label = &quot;3-4&quot; },
			{ max = 2,  label = &quot;1-2&quot; }
		}

		local node_ranges = {
			{ min = 100, label = &quot;extremely-large&quot; },
			{ min = 50,  label = &quot;50+&quot; },
			{ min = 20,  max = 49,                 label = &quot;20-49&quot; },
			{ min = 10,  max = 19,                 label = &quot;10-19&quot; },
			{ min = 5,   max = 9,                  label = &quot;5-9&quot; },
			{ max = 4,   label = &quot;1-4&quot; }
		}

		local language_ranges = {
			{ min = 10,  label = &quot;10+&quot; },
			{ min = 5,   max = 9,      label = &quot;5-9&quot; },
			{ min = 3,   max = 4,      label = &quot;3-4&quot; },
			{ exact = 2, label = &quot;2&quot; },
			{ exact = 1, label = &quot;1&quot; }
		}

		track_ranges(&quot;depth&quot;, __state.max_depth_reached, depth_ranges, lang_code)
		track_ranges(&quot;nodes&quot;, __state.total_nodes, node_ranges, lang_code)

		local unique_languages = 0
		for _ in pairs(__state.language_count) do
			unique_languages = unique_languages + 1
		end
		track_ranges(&quot;unique-languages&quot;, unique_languages, language_ranges, lang_code)

		if __state.total_nodes == __state.max_depth_reached + 1 then
			track_ranges(&quot;linear-depth&quot;, __state.max_depth_reached, depth_ranges, lang_code)
		end
	end

	local categories = {}
	if Util.is_content_page() then
		local should_suppress_categories = lang_exc and lang_exc.suppress_categories
		if not should_suppress_categories and not args.nocat then
			categories = M.categories.render({
				data_tree = ety_data_tree,
				page_lang = lang,
				available_etymon_ids = __state.available_etymon_ids,
				senseid_parent_etymon = __state.senseid_parent_etymon,
				get_norm_lang_func = Util.get_norm_lang,
				lang_exc = lang_exc,
			})
		end

		local target_lang_code = lang:getCode()
		for keyword, keyword_data in pairs(__state.toplevel_keyword_stats) do
			-- Track keyword globally
			M.track(&quot;etymon/keyword/&quot; .. keyword)

			-- Track keyword per target language
			M.track(&quot;etymon/keyword/&quot; .. keyword .. &quot;/target/&quot; .. target_lang_code)

			-- Track keyword per source language
			for source_code, count in pairs(keyword_data.source_langs) do
				M.track(&quot;etymon/keyword/&quot; .. keyword .. &quot;/source/&quot; .. source_code)

				-- Track keyword per target+source combination
				M.track(&quot;etymon/keyword/&quot; .. keyword .. &quot;/target/&quot; .. target_lang_code .. &quot;/source/&quot; .. source_code)
			end
		end

		if tree then
			table.insert(categories, &quot;Laman dengan pokok etimologi&quot;)
			table.insert(categories, lang:getCanonicalName() .. &quot; entries with etymology trees&quot;)
		end
		if text then table.insert(categories, lang:getCanonicalName() .. &quot; entries with etymology texts&quot;) end
		if args.exnihilo then table.insert(categories, lang:getCanonicalName() .. &quot; terms coined ex nihilo&quot;) end
		if __state.toplevel_has_inline_etymology then
			table.insert(categories, &quot;Laman dengan etimon dalam baris untuk pautan merah&quot;)
		end
		if __state.toplevel_redundant_etymology then
			table.insert(categories, &quot;Laman dengan etimon dalam baris lewah&quot;)
		end
		if __state.toplevel_idless_etymon then
			table.insert(categories, &quot;Laman menggunakan etimon tanpa ID&quot;)
		end
		if __state.has_mismatched_id then
			table.insert(categories, lang:getCanonicalName() .. &quot; entries referencing etymons with mismatched IDs&quot;)
		end
		if __state.linked_page_multiple_etymons_idless then
			table.insert(categories,
				lang:getCanonicalName() .. &quot; entries referencing pages with multiple etymons missing IDs&quot;)
		end
	end

	if #categories &gt; 0 then
		table.insert(output, M.categories.format(categories, lang))
	end

	if __state.warnings then
		for i, warning in ipairs(__state.warnings) do
			table.insert(output, (i == 1 and &quot;\n&quot; or &quot;&quot;) .. warning .. &quot;\n&quot;)
		end
	end

	return table.concat(output)
end

return export</text>
      <sha1>tlojdwh1m67a5w9qz5fatk486sr5xh5</sha1>
    </revision>
  </page>
  <page>
    <title>Modul:category tree/topic/Music</title>
    <ns>828</ns>
    <id>74318</id>
    <revision>
      <id>342797</id>
      <parentid>223226</parentid>
      <timestamp>2026-05-16T12:13:25Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <comment>Mengemas kini mengikut padanan Wikikamus bahasa Inggeris (semakan [[en:Special:Diff/86803496|86803496]])</comment>
      <origin>342797</origin>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="3231" sha1="g227nyhq2uje33iwqtvx2kdq3ko1ggr" xml:space="preserve">local labels = {}

------------------------------------ music base labels ------------------------------------

labels[&quot;muzik&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;seni&quot;, &quot;bunyi&quot;},
}

labels[&quot;menyanyi&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;muzik&quot;, &quot;bercakap&quot;},
}

------------------------------------ music theory ------------------------------------

labels[&quot;suara dan daftar muzik&quot;] = {
	type = &quot;jenis&quot;,
	description = &quot;default&quot;,
	parents = {&quot;muzik&quot;, &quot;menyanyi&quot;},
}

labels[&quot;meter muzik&quot;] = {
	type = &quot;jenis&quot;,
	description = &quot;default&quot;,
	parents = {&quot;muzik&quot;},
}

labels[&quot;not muzik&quot;] = {
	type = &quot;jenis&quot;,
	description = &quot;default&quot;,
	parents = {&quot;muzik&quot;},
}

------------------------------------ musicians ------------------------------------

labels[&quot;pemuzik&quot;] = {
	type = &quot;jenis&quot;,
	description = &quot;default&quot;,
	parents = {&quot;pekerjaan&quot;, &quot;muzik&quot;},
}

labels[&quot;Justin Bieber&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;=Penyanyi Kanada {{w|Justin Bieber}}&quot;,
	parents = {&quot;individu&quot;, &quot;muzik&quot;},
}

labels[&quot;Taylor Swift&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;=Penyanyi-penulis lagu Amerika {{w|Taylor Swift}}&quot;,
	parents = {&quot;individu&quot;, &quot;muzik&quot;},
}

------------------------------------ musical genres ------------------------------------

labels[&quot;genre muzik&quot;] = {
	type = &quot;jenis&quot;,
	description = &quot;default&quot;,
	parents = {&quot;muzik&quot;, &quot;genre&quot;},
}

labels[&quot;muzik blues&quot;] = {
	type = &quot;berkenaan&quot;,
	wikidata = 9759,
	description = &quot;default&quot;,
	parents = {&quot;genre muzik&quot;},
}

labels[&quot;jazz&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;genre muzik&quot;},
}

labels[&quot;opera&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;teater&quot;, &quot;genre muzik&quot;},
}

------------------------------------ musical instruments ------------------------------------

labels[&quot;alat muzik&quot;] = {
	type = &quot;set&quot;,
	description = &quot;default&quot;,
	parents = {&quot;muzik&quot;},
}

labels[&quot;alat tiup logam&quot;] = {
	type = &quot;jenis&quot;,
	description = &quot;default&quot;,
	parents = {&quot;alat tiup&quot;},
}

labels[&quot;gong&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;alat perkusi&quot;},
}

labels[&quot;alat organ&quot;] = {
	type = &quot;jenis&quot;,
	description = &quot;default&quot;,
	parents = {&quot;alat tiup&quot;},
}

labels[&quot;alat perkusi&quot;] = {
	type = &quot;set&quot;,
	description = &quot;default&quot;,
	parents = {&quot;alat muzik&quot;},
}

labels[&quot;sintesis suara nyanyian&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;alat muzik&quot;, &quot;menyanyi&quot;},
}

labels[&quot;alat muzik bertali&quot;] = {
	type = &quot;set&quot;,
	description = &quot;Nama-nama [[alat muzik bertali]] dalam bahasa {{{langname}}}.&quot;,
	parents = {&quot;alat muzik&quot;},
}

labels[&quot;alat tiup&quot;] = {
	type = &quot;jenis&quot;,
	description = &quot;default&quot;,
	parents = {&quot;alat muzik&quot;},
}

labels[&quot;alat tiup kayu&quot;] = {
	type = &quot;jenis&quot;,
	description = &quot;default&quot;,
	parents = {&quot;alat tiup&quot;},
}

------------------------------------ music misc ------------------------------------

labels[&quot;pembuatan alat muzik bertali&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default&quot;,
	parents = {&quot;muzik&quot;, &quot;kraf&quot;},
}

labels[&quot;industri muzik&quot;] = {
	type = &quot;berkenaan&quot;,
	description = &quot;default with the&quot;,
	parents = {&quot;industri&quot;, &quot;muzik&quot;},
}

labels[&quot;lagu kebangsaan&quot;] = {
	type = &quot;nama&quot;,
	description = &quot;default&quot;,
	parents = {&quot;karya seni&quot;, &quot;muzik&quot;},
}

return labels</text>
      <sha1>g227nyhq2uje33iwqtvx2kdq3ko1ggr</sha1>
    </revision>
  </page>
  <page>
    <title>Modul:etymon/tree</title>
    <ns>828</ns>
    <id>82357</id>
    <revision>
      <id>342818</id>
      <parentid>234441</parentid>
      <timestamp>2026-05-16T13:39:35Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <comment>Mengemas kini mengikut padanan Wikikamus bahasa Inggeris (semakan [[en:Special:Diff/89866649|89866649]]), terjemahan belum selesai</comment>
      <origin>342818</origin>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="11220" sha1="ok2w6x96bozaxhyj2cy4qex9anfbtx5" xml:space="preserve">local export = {}

local html_create = mw.html.create
local max = math.max

local function create_vertical_connector()
	return html_create('span'):addClass('etytree-connector-vertical')
end

local function create_abbr(text, title, glossary)
	local abbr = html_create('abbr')
		:attr('title', title)
		:wikitext(text)

	if glossary then
		abbr = '[[Appendix:Glossary#' .. glossary .. '|' .. tostring(abbr) .. ']]'
	end

	return html_create('span'):addClass('etytree-label'):node(abbr)
end

local function create_uncertainty_marker()
	return html_create('abbr')
		:addClass('etytree-unc')
		:attr('title', 'uncertain')
		:wikitext('?')
end

local function create_label_container()
	return html_create('span'):addClass('etytree-label-container')
end

local function invisible_in_tree(inv)
	return inv == &quot;all&quot; or inv == true or inv == &quot;tree&quot;
end

local function render_label(term_block, keyword_info, keyword_modifiers, is_uncertain, is_group_child, term_labels)
	-- Skip label when invisible in tree
	local has_label = keyword_info and keyword_info.abbrev and not is_group_child and not invisible_in_tree(keyword_info.invisible)

	-- For group children, keyword uncertainty is shown on the group label, not on individual terms
	local keyword_uncertain = keyword_modifiers and keyword_modifiers.unc and not is_group_child
	local show_term_uncertainty = is_uncertain
	
	-- Check if we have term-specific labels
	local has_term_labels = term_labels and #term_labels &gt; 0

	if not has_label and not show_term_uncertainty and not keyword_uncertain and not has_term_labels then
		return
	end

	local label_span = create_label_container()

	if has_label then
		local glossary_title = keyword_info.glossary
			and keyword_info.glossary:gsub(&quot;_&quot;, &quot; &quot;)
			or keyword_info.abbrev

		label_span:node(create_abbr(
			keyword_info.abbrev,
			glossary_title,
			keyword_info.glossary
		))

		-- Show uncertainty marker if term or keyword is uncertain
		if show_term_uncertainty or keyword_uncertain then
			label_span:node(create_uncertainty_marker())
		end
	else
		-- No label, but term or keyword is uncertain
		if show_term_uncertainty or keyword_uncertain then
			label_span:node(create_uncertainty_marker())
		end
	end

	-- Add term-specific labels
	if has_term_labels then
		for _, label_info in ipairs(term_labels) do
			label_span:node(create_abbr(label_info.abbrev, label_info.title, label_info.glossary))
		end
	end

	term_block:node(label_span)
end

local function render_term_block(node_data, format_term_func, is_toplevel)
	local link_content = html_create()
	link_content
		:tag('span')
		:addClass('etyl')
		:wikitext(node_data.lang:getCanonicalName())
		:done()

	local term_text = format_term_func(node_data, is_toplevel)

	if term_text then
		link_content
			:wikitext(' ')
			:tag('span')
			:addClass('etytree-term')
			:wikitext(term_text)
			:done()
	end

	local block = html_create('div'):addClass('etytree-block'):node(link_content)

	-- Add duplicate styling if this is a duplicate node
	if node_data.is_duplicate then
		block:addClass('etytree-duplicate')
	end

	return block
end

local function create_dotted_connector()
	return html_create('span'):addClass('etytree-connector-dotted')
end

-- Create an L-shaped connector for nodes with hidden ancestry (duplicate or no_child_categories)
local function create_duplicate_connector()
	local container = html_create('div'):addClass('etytree-duplicate-connector')

	local inner_wrapper = container:tag('div')
	inner_wrapper:tag('span'):addClass('etytree-dup-right')
	inner_wrapper:tag('span'):addClass('etytree-dup-horiz')
	inner_wrapper:tag('span'):addClass('etytree-dup-left')
	inner_wrapper:tag('span'):addClass('etytree-dup-arrow'):wikitext('▲')

	return container
end

local function render_group_label(connecting_line, keyword_info, keyword_modifiers)
	local has_abbrev = keyword_info and keyword_info.abbrev
	local keyword_uncertain = keyword_modifiers and keyword_modifiers.unc

	-- Nothing to show if no abbrev and no uncertainty
	if not has_abbrev and not keyword_uncertain then
		return
	end

	local label_span = connecting_line:tag('span'):addClass('etytree-group-label')

	if has_abbrev then
		local glossary_title = keyword_info.glossary
			and keyword_info.glossary:gsub(&quot;_&quot;, &quot; &quot;)
			or keyword_info.abbrev
		label_span:node(create_abbr(keyword_info.abbrev, glossary_title, nil))
	end

	-- Add uncertainty marker if keyword has &lt;unc&gt; modifier
	if keyword_uncertain then
		label_span:node(create_uncertainty_marker())
	end
end

local function add_branch_connector(column, index, total)
	if index == 1 then
		column:tag('span'):addClass('etytree-branch-left')
	elseif index == total then
		column:tag('span'):addClass('etytree-branch-right')
	else
		column:tag('span'):addClass('etytree-connector-vertical-short')
		column:tag('span'):addClass('etytree-branch-mid')
	end
end

function export.render(opts)
	opts = opts or {}
	local data_tree = opts.data_tree
	local format_term_func = opts.format_term_func

	-- Forward declaration
	local render_term

	-- Render a container (keyword + its terms)
	local function render_container(container, is_toplevel)
		local keyword_info = container.keyword_info
		local keyword_modifiers = container.keyword_modifiers or {}
		local is_group = keyword_info and keyword_info.is_group
		local terms = container.terms or {}

		-- Skip container entirely only when invisible = &quot;all&quot; (or true)
		if keyword_info and invisible_in_tree(keyword_info.invisible) then
			return nil, 0, 0
		end

		if #terms == 0 then
			return nil, 0, 0
		end

		-- For no_child_categories keywords (calque, semantic loan, etc.), don't render term's children
		local skip_child_rendering = keyword_info and keyword_info.no_child_categories

		-- Render each term in the container
		local rendered_terms = {}
		local container_height = 0
		local container_width = 0

		for _, term in ipairs(terms) do
			-- Collect term-specific labels
			local term_labels = {}
			if term.bor then
				table.insert(term_labels, { abbrev = &quot;bor.&quot;, title = &quot;borrowed&quot;, glossary = &quot;loanword&quot; })
			end
			if term.slbor then
				table.insert(term_labels, { abbrev = &quot;slbor.&quot;, title = &quot;semi-learned borrowing&quot;, glossary = &quot;semi-learned_borrowing&quot; })
			end
			if term.lbor then
				table.insert(term_labels, { abbrev = &quot;lbor.&quot;, title = &quot;learned borrowing&quot;, glossary = &quot;learned_borrowing&quot; })
			end
			
			local term_tree, term_height, term_width = render_term(term, keyword_info, keyword_modifiers, is_group, false, skip_child_rendering, term_labels)
			table.insert(rendered_terms, {
				tree = term_tree,
				height = term_height,
				width = term_width,
				is_uncertain = term.is_uncertain,
			})
			container_height = max(container_height, term_height)
			container_width = container_width + term_width
		end

		local rendered_html
		local has_connector = false

		if #rendered_terms == 1 then
			-- Single term: just return it directly
			rendered_html = rendered_terms[1].tree
			container_height = rendered_terms[1].height
			container_width = rendered_terms[1].width
		else
			-- Multiple terms: group them together
			local subtree_container = html_create('div'):addClass('etytree-branch-group')

			for i, term_data in ipairs(rendered_terms) do
				local column = html_create('div'):addClass('etytree-branch')
				column:node(term_data.tree)
				add_branch_connector(column, i, #rendered_terms)
				subtree_container:node(column)
			end

			local connecting_line = create_vertical_connector()

			-- Add group label for group keywords
			if is_group and not invisible_in_tree(keyword_info.invisible) then
				render_group_label(connecting_line, keyword_info, keyword_modifiers)
			end

			rendered_html = html_create()
				:node(subtree_container)
				:node(connecting_line)
			has_connector = true
		end


		return rendered_html, container_height, container_width, has_connector
	end

	-- Render a term node
	render_term = function(term_node, keyword_info, keyword_modifiers, is_group_child, is_toplevel_term, skip_child_rendering, term_labels)
		local tree_width, tree_height = 0, 0
		local subtrees = {}

		-- Process term's children (which are containers)
		local has_hidden_children = false
		if not term_node.is_duplicate and not skip_child_rendering then
			for _, container in ipairs(term_node.children or {}) do
				local subtree, sub_height, sub_width, subtree_has_connector = render_container(container, is_toplevel_term)
				if subtree then
					table.insert(subtrees, {
						tree = subtree,
						height = sub_height,
						width = sub_width,
						has_connector = subtree_has_connector,
					})
					tree_height = max(tree_height, sub_height)
					tree_width = tree_width + sub_width
				end
			end
		elseif skip_child_rendering then
			-- Check if there are any visible children
			-- When stop_recursion is true, children aren't parsed, but has_visible_children flag is set
			if term_node.has_visible_children then
				has_hidden_children = true
			elseif term_node.children and #term_node.children &gt; 0 then
				-- Fallback: check parsed children for visibility
				for _, container in ipairs(term_node.children) do
					local child_keyword_info = container.keyword_info
					if not (child_keyword_info and (child_keyword_info.invisible == &quot;all&quot; or child_keyword_info.invisible == true)) then
						has_hidden_children = true
						break
					end
				end
			end
		end

		local is_toplevel_node = (keyword_info == nil)
		local term_block = render_term_block(term_node, format_term_func, is_toplevel_node)
		render_label(term_block, keyword_info, keyword_modifiers, term_node.is_uncertain, is_group_child, term_labels or {})

		local term_html = html_create()

		if #subtrees == 0 then
			local show_connector = (term_node.is_duplicate and term_node.original_has_children) or has_hidden_children
			if show_connector then
				term_html:node(create_duplicate_connector())
			end
			term_html:node(term_block)
			tree_width = tree_width + 1
		elseif #subtrees == 1 then
			term_html:node(subtrees[1].tree)
			if not subtrees[1].has_connector then
				term_html:node(create_vertical_connector())
			end
			term_html:node(term_block)
		else
			-- Multiple containers: need to merge them
			local subtree_container = html_create('div'):addClass('etytree-branch-group')

			for i, subtree_data in ipairs(subtrees) do
				local column = html_create('div'):addClass('etytree-branch')
				column:node(subtree_data.tree)
				add_branch_connector(column, i, #subtrees)
				subtree_container:node(column)
			end

			local connecting_line = create_vertical_connector()

			term_html
				:node(subtree_container)
				:node(connecting_line)
				:node(term_block)
		end

		return term_html, tree_height + 1, tree_width
	end

	local final_tree, final_height, final_width = render_term(data_tree, nil, nil, false, true)

	local container = html_create('div')
		:addClass('etytree-body')
		:node(final_tree)

	return tostring(html_create('div')
		:addClass('etytree NavFrame')
		:attr('data-etytree-height', final_height)
		:attr('data-etytree-width', final_width)
		:tag('div')
		:addClass('NavHead')
		:tag('div')
		:wikitext('Etymology tree')
		:done()
		:done()
		:tag('div')
		:addClass('NavContent')
		:node(container)
		:done())
end

return export</text>
      <sha1>ok2w6x96bozaxhyj2cy4qex9anfbtx5</sha1>
    </revision>
  </page>
  <page>
    <title>Modul:etymon/categories</title>
    <ns>828</ns>
    <id>82358</id>
    <revision>
      <id>342820</id>
      <parentid>258374</parentid>
      <timestamp>2026-05-16T13:43:11Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <comment>Mengemas kini mengikut padanan Wikisumber bahasa Inggeris (semakan [[en:Special:Diff/90755775|90755775]]), terjemahan belum selesai</comment>
      <origin>342820</origin>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="20215" sha1="qaazt3r5h8qyyj6gn4rl4zbmoaycwgt" xml:space="preserve">local export = {}

local M = require(&quot;Module:module loader&quot;).init({
	require = {
		etymology = &quot;Module:etymology&quot;,
		affix = &quot;Module:affix&quot;,
		etymology_specialized = &quot;Module:etymology/specialized&quot;,
		utilities = &quot;Module:utilities&quot;,
	},
	loadData = {
		data = &quot;Module:etymon/data&quot;,
	},
})

-- Evaluate whether a keyword is transitive for a given term
local function is_transitive(transitive_mode, page_lang, term_lang)
	if transitive_mode == M.data.TRANSITIVE.ALWAYS then
		return true
	elseif transitive_mode == M.data.TRANSITIVE.NEVER then
		return false
	elseif transitive_mode == M.data.TRANSITIVE.CROSS_LANG then
		return page_lang:getCode() ~= term_lang:getCode()
	elseif transitive_mode == M.data.TRANSITIVE.CROSS_LANG_NO_INTERNAL_SOURCE then
		return page_lang:getCode() ~= term_lang:getCode()
	end
	error(&quot;Unknown transitive mode: &quot; .. tostring(transitive_mode))
end

-- Get keyword config with language-specific overrides
local function get_keyword_config(keyword, lang_exc)
	local base_config = M.data.keywords[keyword]
	if not base_config then
		return nil -- Invalid keyword
	end

	local overrides = lang_exc and lang_exc.keyword_overrides and lang_exc.keyword_overrides[keyword]

	if not overrides then
		return base_config
	end

	-- Merge overrides into base config
	local merged = {}
	for k, v in pairs(base_config) do
		merged[k] = v
	end
	for k, v in pairs(overrides) do
		merged[k] = v
	end
	return merged
end

function export.get_cat_name(source)
	local _, cat_name = M.etymology.get_display_and_cat_name(source, true)
	return cat_name
end

-- Normalize affix type aliases
local aftype_aliases = {
	[&quot;pre&quot;] = &quot;prefix&quot;,
	[&quot;suf&quot;] = &quot;suffix&quot;,
	[&quot;in&quot;] = &quot;infix&quot;,
	[&quot;inter&quot;] = &quot;interfix&quot;,
	[&quot;circum&quot;] = &quot;circumfix&quot;,
	[&quot;naf&quot;] = &quot;non-affix&quot;,
	[&quot;root&quot;] = &quot;non-affix&quot;,
}

local function add_category(categories, cat_name, sort_key, sort_base)
	if categories[cat_name] == nil then
		categories[cat_name] = {
			sort_key = sort_key,
			sort_base = sort_base,
		}
		return
	end

	local existing = categories[cat_name]
	if existing.sort_key == nil and sort_key ~= nil then
		existing.sort_key = sort_key
	end
	if existing.sort_base == nil and sort_base ~= nil then
		existing.sort_base = sort_base
	end
end

-- Collect affix categories from top-level group containers
local function collect_affix_categories(node, page_lang, available_etymon_ids, senseid_parent_etymon, lang_exc)
	local parts = {}
	local part_index = 1

	for _, container in ipairs(node.children or {}) do
		local config = container.keyword_info
		if config and config.affix_categories then
			for _, term in ipairs(container.terms or {}) do
				if not term.unknown_term then
					local part_data = {
						term = term.title,
						tr = term.tr,
						ts = term.ts,
						alt = term.alt,
						itemno = part_index,
						orig_index = part_index
					}

					-- Determine affix type: explicit aftype &gt; pos=root &gt; auto-detect
					local aftype = term.aftype
					if aftype then
						aftype = aftype_aliases[aftype] or aftype
						part_data.type = aftype
					elseif term.args and term.args.pos and term.args.pos == &quot;root&quot; then
						part_data.type = &quot;non-affix&quot;
					end

					if term.lang:getCode() ~= page_lang:getCode() then
						part_data.lang = term.lang
					end

					local target_ids = available_etymon_ids[term.target_key]
					local has_multiple_ids = target_ids and #target_ids &gt; 1
					local id_exists_in_disambiguation = false
					local matched_id = nil

					-- Count available senseids for the target page
					local senseid_count = 0
					local target_prefix = term.target_key .. &quot;:&quot;
					if senseid_parent_etymon then
						for key, _ in pairs(senseid_parent_etymon) do
							if key:sub(1, #target_prefix) == target_prefix then
								senseid_count = senseid_count + 1
							end
						end
					end
					local has_multiple_senseids = senseid_count &gt; 1

					if term.id then
						-- Check if user provided a valid senseid
						local senseid_key = term.target_key .. &quot;:&quot; .. term.id
						if senseid_parent_etymon and senseid_parent_etymon[senseid_key] then
							if has_multiple_senseids then
								-- Ambiguous senseid: use senseid
								matched_id = term.id
								id_exists_in_disambiguation = true
							elseif has_multiple_ids then
								-- Unique senseid but ambiguous etymon: use etymon ID
								matched_id = term.etymon_id or term.id
								id_exists_in_disambiguation = true
							end
						else
							-- Check if user provided a valid etymon ID
							if has_multiple_ids and target_ids then
								for _, id_data in ipairs(target_ids) do
									local stored_id = type(id_data) == &quot;table&quot; and id_data.id or id_data
									if stored_id == term.id then
										-- Ambiguous etymon: use etymon ID
										id_exists_in_disambiguation = true
										matched_id = term.id
										break
									end
								end
							end
							
							-- Fallback: check resolved etymon_id (e.g. from previous steps)
							if not id_exists_in_disambiguation and has_multiple_ids and term.etymon_id and target_ids then
								for _, id_data in ipairs(target_ids) do
									local stored_id = type(id_data) == &quot;table&quot; and id_data.id or id_data
									if stored_id == term.etymon_id then
										id_exists_in_disambiguation = true
										matched_id = term.etymon_id
										break
									end
								end
							end
						end
					end

					-- Use the matched ID if found
					if term.override or id_exists_in_disambiguation then
						part_data.id = matched_id or term.id
					end

					table.insert(parts, part_data)
					part_index = part_index + 1
				end
			end
		end
	end

	if #parts == 0 then return {} end

	local affix_data = {
		lang = page_lang,
		parts = parts,
		pos = &quot;term&quot;,
		sort_key = nil,
	}
	
	if #parts == 1 then
		affix_data.allow_no_affixes_or_compounds = true
	end

	local affix_categories = M.affix.get_affix_categories_only(affix_data)

	local result = {}
	for _, cat in ipairs(affix_categories) do
		if type(cat) == &quot;table&quot; then
			table.insert(result, { cat = cat.cat, sort_key = cat.sort_key, sort_base = cat.sort_base })
		else
			table.insert(result, { cat = cat })
		end
	end

	return result
end

-- Add borrowing-related categories (top-level only)
local function collect_borrowing_categories(categories, page_lang, term, config)
	if config.borrowing_type == &quot;borrowed&quot; then
		local temp_categories = {}
		M.etymology.insert_borrowed_cat(temp_categories, page_lang, term.lang)
		for _, cat in ipairs(temp_categories) do
			add_category(categories, cat)
		end
	end

	if config.specialized_borrowing then
		local result = M.etymology_specialized.specialized_borrowing {
			bortype = config.specialized_borrowing,
			lang = page_lang,
			sources = { term.lang },
			terms = { { lang = term.lang, term = &quot;-&quot; } },
			notext = true,
			nocat = false,
		}

		for cat_name in result:gmatch(&quot;%[%[Category:([^%]]+)%]%]&quot;) do
			add_category(categories, cat_name)
		end
	end
end

-- Add source-based derivation categories (top-level only)
local function collect_source_derivation_categories(categories, page_lang, term, config)
	if not config.source_category_type then
		return
	end

	local temp_categories = {}

	M.etymology.insert_source_cat_get_display {
		lang = page_lang,
		source = term.lang,
		categories = temp_categories,
		borrowing_type = config.source_category_type,
		nocat = false,
	}

	for _, cat in ipairs(temp_categories) do
		add_category(categories, cat)
	end
end

-- Add source language categories
local function collect_source_categories(categories, page_lang, term, chain, get_norm_lang_func)
	if page_lang:getCode() == get_norm_lang_func(term.lang):getCode() then
		return
	end

	local temp_categories = {}
	M.etymology.insert_source_cat_get_display {
		lang = page_lang,
		source = term.lang,
		categories = temp_categories,
		nocat = false,
	}

	for _, cat in ipairs(temp_categories) do
		add_category(categories, cat)
	end

	if chain.inherited then
		temp_categories = {}
		M.etymology.insert_source_cat_get_display {
			lang = page_lang,
			source = term.lang,
			categories = temp_categories,
			borrowing_type = &quot;terms inherited&quot;,
			nocat = false,
		}

		for _, cat in ipairs(temp_categories) do
			add_category(categories, cat)
		end
	end
end

-- Add root/word categories
local function collect_pos_categories(categories, page_lang, root_title, term, available_etymon_ids, chain,
									  get_norm_lang_func, lang_exc, keyword)
	local pos_types = { root = &quot;root&quot;, word = &quot;word&quot; }

	-- Determine pos: from term's postype, keyword's pos_override, or args.pos
	local pos
	local config = get_keyword_config(keyword, lang_exc)
	if term.postype then
		-- Term-level postype modifier takes highest priority
		pos = term.postype
	elseif config and config.pos_override then
		pos = config.pos_override
	elseif type(term.args) == &quot;table&quot; and term.args.pos then
		pos = term.args.pos
	end

	local pos_type = pos_types[pos]

	if not pos_type or term.unknown_term then
		return
	end

	-- Skip root/word categories for descendants of affix groups
	-- if pos_type then
	-- 	return
	-- end

	local same_language = get_norm_lang_func(page_lang):getFullCode() == get_norm_lang_func(term.lang):getFullCode()

	-- Skip self-references
	if same_language and root_title == term.title then
		return
	end

	-- Use makeEntryName to strip diacritics for category names
	local entry_name = term.lang:makeEntryName(term.title)

	local lang_name = page_lang:getCanonicalName()
	local cat_name

	if chain.passed_through then
		local etymon_lang_name = export.get_cat_name(term.lang)
		cat_name = lang_name .. &quot; terms derived from the &quot; .. etymon_lang_name .. &quot; &quot; .. pos_type .. &quot; &quot; .. entry_name
	else
		cat_name = lang_name .. &quot; terms belonging to the &quot; .. pos_type .. &quot; &quot; .. entry_name
	end

	-- Add ID disambiguation if needed (for roots/words: use etymon_id if resolved via senseid, otherwise use id)
	local target_ids = available_etymon_ids[term.target_key]
	local effective_id = term.etymon_id or term.id  -- etymon_id if senseid, otherwise id is already an etymon id
	if target_ids and effective_id then
		local same_pos_count = 0
		for _, id_data in ipairs(target_ids) do
			if type(id_data) == &quot;table&quot; and id_data.pos == pos then
				same_pos_count = same_pos_count + 1
			end
		end
		if same_pos_count &gt; 1 then
			cat_name = cat_name .. &quot; (&quot; .. effective_id .. &quot;)&quot;
		end
	end

	add_category(categories, cat_name)
end

-- Compute chain state for a term based on parent chain and keyword config
-- Hyphen patterns for affix detection (regular hyphen + script-specific)
local AFFIX_HYPHEN_PATTERN = &quot;[%-%־ـ᠊]&quot; -- regular hyphen, Hebrew maqqef, Arabic tatweel, Mongolian hyphen

-- Check if a term is an actual affix (not a non-affix member of an affix group)
local function is_actual_affix(term)
	-- Check explicit aftype modifier
	if term.aftype then
		local normalized = aftype_aliases[term.aftype] or term.aftype
		return normalized ~= &quot;non-affix&quot;
	end
	-- Check if pos=root (treated as non-affix)
	if term.args and term.args.pos and term.args.pos == &quot;root&quot; then
		return false
	end
	-- Auto-detect by hyphen: prefix ends with -, suffix starts with -, etc.
	if term.title then
		local title = term.title
		-- Strip leading * for reconstructed terms before checking hyphens
		title = title:gsub(&quot;^%*&quot;, &quot;&quot;)
		-- Check for hyphens at start or end (handles script-specific hyphens too)
		if title:match(&quot;^&quot; .. AFFIX_HYPHEN_PATTERN) or title:match(AFFIX_HYPHEN_PATTERN .. &quot;$&quot;) then
			return true
		end
	end
	-- Default: not an affix
	return false
end

local function compute_category_chain(parent_chain, config, page_lang, term_lang, get_norm_lang_func, parent_term_lang, term)
	-- Track if we're inside an actual affix (for suppressing root categories on descendants)
	-- Only set if the term is an actual affix (prefix, suffix, etc.), not a non-affix member
	local inside_affix = parent_chain.inside_affix
	if config.affix_categories and term and is_actual_affix(term) then
		inside_affix = true
	end

	-- If no_child_categories is set, disable everything
	if config.no_child_categories then
		return {
			passed_through = parent_chain.passed_through or page_lang:getCode() ~= get_norm_lang_func(term_lang):getCode(),
			inherited = false,
			source = false,
			pos = false,
			recurse = false,
			inside_affix = inside_affix,
		}
	end

	local term_is_transitive = is_transitive(config.transitive, page_lang, term_lang)
	local new_source = parent_chain.source and term_is_transitive
	
	-- For CROSS_LANG_NO_INTERNAL_SOURCE: track internal derivation language context
	-- Check if this term is internal relative to parent term's language (if parent_term_lang provided)
	-- or relative to page language (if no parent_term_lang)
	local internal_lang = parent_chain.internal_lang
	local is_internal_in_context = false
	if config.transitive == M.data.TRANSITIVE.CROSS_LANG_NO_INTERNAL_SOURCE then
		local check_lang = parent_term_lang or page_lang
		local term_lang_code = get_norm_lang_func(term_lang):getCode()
		local check_lang_code = get_norm_lang_func(check_lang):getCode()
		
		if internal_lang then
			-- Already in an internal derivation context: check if this term is also internal
			is_internal_in_context = term_lang_code == internal_lang
		else
			-- Check if this term is internal relative to parent term (or page if no parent)
			is_internal_in_context = term_lang_code == check_lang_code
		end
	end
	
	-- Source chain behavior for CROSS_LANG_NO_INTERNAL_SOURCE
	if config.transitive == M.data.TRANSITIVE.CROSS_LANG_NO_INTERNAL_SOURCE then
		if is_internal_in_context then
			-- Internal derivation
			new_source = false
			internal_lang = get_norm_lang_func(term_lang):getCode()
		else
			-- Cross-language
			new_source = parent_chain.source and term_is_transitive
			internal_lang = nil
		end
	end
	
	local new_pos = parent_chain.pos

	return {
		passed_through = parent_chain.passed_through or page_lang:getCode() ~= get_norm_lang_func(term_lang):getCode(),
		inherited = parent_chain.inherited and config.inherited_chain,
		source = new_source,
		pos = new_pos,
		internal_lang = internal_lang,
		recurse = new_source or new_pos,
		inside_affix = inside_affix,
	}
end

function export.render(opts)
	opts = opts or {}
	local data_tree = opts.data_tree
	local page_lang = opts.page_lang
	local available_etymon_ids = opts.available_etymon_ids
	local senseid_parent_etymon = opts.senseid_parent_etymon
	local get_norm_lang_func = opts.get_norm_lang_func
	local lang_exc = opts.lang_exc

	local categories = {}
	local seen = {}
	local lang_name = page_lang:getCanonicalName()
	local root_title = data_tree.title

	-- Collect the tree recursively
	local function collect(node, parent_chain, is_toplevel)
		-- Avoid processing same node twice
		if not node.unknown_term and node.title then
			local key = node.lang:getFullCode() .. &quot;:&quot; .. (node.title or &quot;&quot;) .. &quot;:&quot; .. (node.id or &quot;&quot;)
			if seen[key] then return end
			seen[key] = true
		end

		-- Collect affix categories at top level only
		if is_toplevel then
			local affix_cats = collect_affix_categories(node, page_lang, available_etymon_ids, senseid_parent_etymon, lang_exc)
			for _, cat in ipairs(affix_cats) do
				add_category(categories, lang_name .. &quot; &quot; .. cat.cat, cat.sort_key, cat.sort_base)
			end
		end

		-- Process each container
		for _, container in ipairs(node.children or {}) do
			local keyword = container.keyword
			local config = get_keyword_config(keyword, lang_exc)

			-- Skip invalid keywords
			if config then
				-- Process each term in the container
				for _, term in ipairs(container.terms or {}) do
					local term_chain = compute_category_chain(parent_chain, config, page_lang, term.lang, get_norm_lang_func, node.lang, term)
					local no_child_categories = config.no_child_categories == true
					local term_is_transitive = is_transitive(config.transitive, page_lang, term.lang)

					-- Top-level only processing
					if is_toplevel then
						-- Missing/ambiguous etymon tracking
						if not term.unknown_term and (term.status == M.data.STATUS.MISSING or term.status == M.data.STATUS.REDLINK) then
							add_category(categories, lang_name .. &quot; entries referencing missing etymons&quot;)
						end
						if not term.unknown_term and term.status == M.data.STATUS.AMBIGUOUS then
							add_category(categories, lang_name .. &quot; entries referencing ambiguous etymons&quot;)
						end
						if term.missing_descendants_header then
							add_category(categories, lang_name .. &quot; entries referencing etymons without Descendants sections&quot;)
						end
						if term.missing_descendants_entry then
							add_category(categories, lang_name .. &quot; entries referencing etymons without this term in Descendants sections&quot;)
						end

						-- Top-level category (e.g., &quot;undefined derivations&quot;)
						if config.toplevel_category then
							add_category(categories, lang_name .. &quot; &quot; .. config.toplevel_category)
						end

						-- Borrowing categories (bor, lbor, slbor, ubor, obor)
						if config.borrowing_type or config.specialized_borrowing then
							collect_borrowing_categories(categories, page_lang, term, config)
						end

						-- Borrowing categories from &lt;bor&gt;, &lt;lbor&gt;, or &lt;slbor&gt; modifiers on :af/:surf terms
						if keyword == &quot;affix&quot; or keyword == &quot;surf&quot; then
							if term.bor then
								local bor_config = { borrowing_type = &quot;borrowed&quot; }
								collect_borrowing_categories(categories, page_lang, term, bor_config)
							elseif term.lbor then
								local bor_config = { specialized_borrowing = &quot;learned&quot; }
								collect_borrowing_categories(categories, page_lang, term, bor_config)
							elseif term.slbor then
								local bor_config = { specialized_borrowing = &quot;semi-learned&quot; }
								collect_borrowing_categories(categories, page_lang, term, bor_config)
							end
						end

						-- Source-based derivation categories (sl, calque, pcal)
						if config.source_category_type then
							collect_source_derivation_categories(categories, page_lang, term, config)
						end

						-- Skip all child categorisation if no_child_categories is set
						if not no_child_categories then
							-- Source categories only if transitive
							if term_is_transitive then
								collect_source_categories(categories, page_lang, term, term_chain, get_norm_lang_func)
							end

							-- Pos categories always (unless no_child_categories)
							collect_pos_categories(categories, page_lang, root_title, term, available_etymon_ids, term_chain,
								get_norm_lang_func, lang_exc, keyword)
						end
					else
						-- Below top level, respect the parent chain
						if parent_chain.source then
							collect_source_categories(categories, page_lang, term, term_chain, get_norm_lang_func)
						end

						if parent_chain.pos then
							collect_pos_categories(categories, page_lang, root_title, term, available_etymon_ids, term_chain,
								get_norm_lang_func, lang_exc, keyword)
						end
					end

					-- Recurse into term's children if needed and status allows
					if term_chain.recurse and (term.status == M.data.STATUS.OK or term.status == M.data.STATUS.INLINE) then
						collect(term, term_chain, false)
					end
				end
			end
		end
	end

	-- Initial chain state
	local initial_chain = {
		passed_through = false,
		inherited = true,
		source = true,
		pos = true,
		internal_lang = nil,
		recurse = true,
		inside_affix = false,
	}

	collect(data_tree, initial_chain, true)

	local cat_list = {}
	for cat_name, sort_data in pairs(categories) do
		if sort_data.sort_key ~= nil or sort_data.sort_base ~= nil then
			table.insert(cat_list, {
				name = cat_name,
				sort_key = sort_data.sort_key,
				sort_base = sort_data.sort_base,
			})
		else
			table.insert(cat_list, cat_name)
		end
	end
	return cat_list
end

function export.format(entries, lang)
	if type(entries) ~= &quot;table&quot; or #entries == 0 then
		return &quot;&quot;
	end

	local parts = {}
	for _, category in ipairs(entries) do
		if type(category) == &quot;table&quot; and type(category.name) == &quot;string&quot; then
			table.insert(parts, M.utilities.format_categories({ category.name }, lang, category.sort_key, category.sort_base))
		elseif type(category) == &quot;string&quot; then
			table.insert(parts, M.utilities.format_categories({ category }, lang))
		end
	end

	return table.concat(parts)
end

return export</text>
      <sha1>qaazt3r5h8qyyj6gn4rl4zbmoaycwgt</sha1>
    </revision>
    <revision>
      <id>342830</id>
      <parentid>342820</parentid>
      <timestamp>2026-05-16T14:01:15Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <origin>342830</origin>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="20221" sha1="g2ljrv19nstuu4cg2oqpsykek0ecpsc" xml:space="preserve">local export = {}

local M = require(&quot;Module:module loader&quot;).init({
	require = {
		etymology = &quot;Module:etymology&quot;,
		affix = &quot;Module:affix&quot;,
		etymology_specialized = &quot;Module:etymology/specialized&quot;,
		utilities = &quot;Module:utilities&quot;,
	},
	loadData = {
		data = &quot;Module:etymon/data&quot;,
	},
})

-- Evaluate whether a keyword is transitive for a given term
local function is_transitive(transitive_mode, page_lang, term_lang)
	if transitive_mode == M.data.TRANSITIVE.ALWAYS then
		return true
	elseif transitive_mode == M.data.TRANSITIVE.NEVER then
		return false
	elseif transitive_mode == M.data.TRANSITIVE.CROSS_LANG then
		return page_lang:getCode() ~= term_lang:getCode()
	elseif transitive_mode == M.data.TRANSITIVE.CROSS_LANG_NO_INTERNAL_SOURCE then
		return page_lang:getCode() ~= term_lang:getCode()
	end
	error(&quot;Unknown transitive mode: &quot; .. tostring(transitive_mode))
end

-- Get keyword config with language-specific overrides
local function get_keyword_config(keyword, lang_exc)
	local base_config = M.data.keywords[keyword]
	if not base_config then
		return nil -- Invalid keyword
	end

	local overrides = lang_exc and lang_exc.keyword_overrides and lang_exc.keyword_overrides[keyword]

	if not overrides then
		return base_config
	end

	-- Merge overrides into base config
	local merged = {}
	for k, v in pairs(base_config) do
		merged[k] = v
	end
	for k, v in pairs(overrides) do
		merged[k] = v
	end
	return merged
end

function export.get_cat_name(source)
	local _, cat_name = M.etymology.get_display_and_cat_name(source, true)
	return cat_name
end

-- Normalize affix type aliases
local aftype_aliases = {
	[&quot;pre&quot;] = &quot;prefix&quot;,
	[&quot;suf&quot;] = &quot;suffix&quot;,
	[&quot;in&quot;] = &quot;infix&quot;,
	[&quot;inter&quot;] = &quot;interfix&quot;,
	[&quot;circum&quot;] = &quot;circumfix&quot;,
	[&quot;naf&quot;] = &quot;non-affix&quot;,
	[&quot;root&quot;] = &quot;non-affix&quot;,
}

local function add_category(categories, cat_name, sort_key, sort_base)
	if categories[cat_name] == nil then
		categories[cat_name] = {
			sort_key = sort_key,
			sort_base = sort_base,
		}
		return
	end

	local existing = categories[cat_name]
	if existing.sort_key == nil and sort_key ~= nil then
		existing.sort_key = sort_key
	end
	if existing.sort_base == nil and sort_base ~= nil then
		existing.sort_base = sort_base
	end
end

-- Collect affix categories from top-level group containers
local function collect_affix_categories(node, page_lang, available_etymon_ids, senseid_parent_etymon, lang_exc)
	local parts = {}
	local part_index = 1

	for _, container in ipairs(node.children or {}) do
		local config = container.keyword_info
		if config and config.affix_categories then
			for _, term in ipairs(container.terms or {}) do
				if not term.unknown_term then
					local part_data = {
						term = term.title,
						tr = term.tr,
						ts = term.ts,
						alt = term.alt,
						itemno = part_index,
						orig_index = part_index
					}

					-- Determine affix type: explicit aftype &gt; pos=root &gt; auto-detect
					local aftype = term.aftype
					if aftype then
						aftype = aftype_aliases[aftype] or aftype
						part_data.type = aftype
					elseif term.args and term.args.pos and term.args.pos == &quot;root&quot; then
						part_data.type = &quot;non-affix&quot;
					end

					if term.lang:getCode() ~= page_lang:getCode() then
						part_data.lang = term.lang
					end

					local target_ids = available_etymon_ids[term.target_key]
					local has_multiple_ids = target_ids and #target_ids &gt; 1
					local id_exists_in_disambiguation = false
					local matched_id = nil

					-- Count available senseids for the target page
					local senseid_count = 0
					local target_prefix = term.target_key .. &quot;:&quot;
					if senseid_parent_etymon then
						for key, _ in pairs(senseid_parent_etymon) do
							if key:sub(1, #target_prefix) == target_prefix then
								senseid_count = senseid_count + 1
							end
						end
					end
					local has_multiple_senseids = senseid_count &gt; 1

					if term.id then
						-- Check if user provided a valid senseid
						local senseid_key = term.target_key .. &quot;:&quot; .. term.id
						if senseid_parent_etymon and senseid_parent_etymon[senseid_key] then
							if has_multiple_senseids then
								-- Ambiguous senseid: use senseid
								matched_id = term.id
								id_exists_in_disambiguation = true
							elseif has_multiple_ids then
								-- Unique senseid but ambiguous etymon: use etymon ID
								matched_id = term.etymon_id or term.id
								id_exists_in_disambiguation = true
							end
						else
							-- Check if user provided a valid etymon ID
							if has_multiple_ids and target_ids then
								for _, id_data in ipairs(target_ids) do
									local stored_id = type(id_data) == &quot;table&quot; and id_data.id or id_data
									if stored_id == term.id then
										-- Ambiguous etymon: use etymon ID
										id_exists_in_disambiguation = true
										matched_id = term.id
										break
									end
								end
							end
							
							-- Fallback: check resolved etymon_id (e.g. from previous steps)
							if not id_exists_in_disambiguation and has_multiple_ids and term.etymon_id and target_ids then
								for _, id_data in ipairs(target_ids) do
									local stored_id = type(id_data) == &quot;table&quot; and id_data.id or id_data
									if stored_id == term.etymon_id then
										id_exists_in_disambiguation = true
										matched_id = term.etymon_id
										break
									end
								end
							end
						end
					end

					-- Use the matched ID if found
					if term.override or id_exists_in_disambiguation then
						part_data.id = matched_id or term.id
					end

					table.insert(parts, part_data)
					part_index = part_index + 1
				end
			end
		end
	end

	if #parts == 0 then return {} end

	local affix_data = {
		lang = page_lang,
		parts = parts,
		pos = &quot;term&quot;,
		sort_key = nil,
	}
	
	if #parts == 1 then
		affix_data.allow_no_affixes_or_compounds = true
	end

	local affix_categories = M.affix.get_affix_categories_only(affix_data)

	local result = {}
	for _, cat in ipairs(affix_categories) do
		if type(cat) == &quot;table&quot; then
			table.insert(result, { cat = cat.cat, sort_key = cat.sort_key, sort_base = cat.sort_base })
		else
			table.insert(result, { cat = cat })
		end
	end

	return result
end

-- Add borrowing-related categories (top-level only)
local function collect_borrowing_categories(categories, page_lang, term, config)
	if config.borrowing_type == &quot;borrowed&quot; then
		local temp_categories = {}
		M.etymology.insert_borrowed_cat(temp_categories, page_lang, term.lang)
		for _, cat in ipairs(temp_categories) do
			add_category(categories, cat)
		end
	end

	if config.specialized_borrowing then
		local result = M.etymology_specialized.specialized_borrowing {
			bortype = config.specialized_borrowing,
			lang = page_lang,
			sources = { term.lang },
			terms = { { lang = term.lang, term = &quot;-&quot; } },
			notext = true,
			nocat = false,
		}

		for cat_name in result:gmatch(&quot;%[%[Category:([^%]]+)%]%]&quot;) do
			add_category(categories, cat_name)
		end
	end
end

-- Add source-based derivation categories (top-level only)
local function collect_source_derivation_categories(categories, page_lang, term, config)
	if not config.source_category_type then
		return
	end

	local temp_categories = {}

	M.etymology.insert_source_cat_get_display {
		lang = page_lang,
		source = term.lang,
		categories = temp_categories,
		borrowing_type = config.source_category_type,
		nocat = false,
	}

	for _, cat in ipairs(temp_categories) do
		add_category(categories, cat)
	end
end

-- Add source language categories
local function collect_source_categories(categories, page_lang, term, chain, get_norm_lang_func)
	if page_lang:getCode() == get_norm_lang_func(term.lang):getCode() then
		return
	end

	local temp_categories = {}
	M.etymology.insert_source_cat_get_display {
		lang = page_lang,
		source = term.lang,
		categories = temp_categories,
		nocat = false,
	}

	for _, cat in ipairs(temp_categories) do
		add_category(categories, cat)
	end

	if chain.inherited then
		temp_categories = {}
		M.etymology.insert_source_cat_get_display {
			lang = page_lang,
			source = term.lang,
			categories = temp_categories,
			borrowing_type = &quot;dipinjam&quot;,
			nocat = false,
		}

		for _, cat in ipairs(temp_categories) do
			add_category(categories, cat)
		end
	end
end

-- Add root/word categories
local function collect_pos_categories(categories, page_lang, root_title, term, available_etymon_ids, chain,
									  get_norm_lang_func, lang_exc, keyword)
	local pos_types = { root = &quot;root&quot;, word = &quot;word&quot; }

	-- Determine pos: from term's postype, keyword's pos_override, or args.pos
	local pos
	local config = get_keyword_config(keyword, lang_exc)
	if term.postype then
		-- Term-level postype modifier takes highest priority
		pos = term.postype
	elseif config and config.pos_override then
		pos = config.pos_override
	elseif type(term.args) == &quot;table&quot; and term.args.pos then
		pos = term.args.pos
	end

	local pos_type = pos_types[pos]

	if not pos_type or term.unknown_term then
		return
	end

	-- Skip root/word categories for descendants of affix groups
	-- if pos_type then
	-- 	return
	-- end

	local same_language = get_norm_lang_func(page_lang):getFullCode() == get_norm_lang_func(term.lang):getFullCode()

	-- Skip self-references
	if same_language and root_title == term.title then
		return
	end

	-- Use makeEntryName to strip diacritics for category names
	local entry_name = term.lang:makeEntryName(term.title)

	local lang_name = page_lang:getCanonicalName()
	local cat_name

	if chain.passed_through then
		local etymon_lang_name = export.get_cat_name(term.lang)
		cat_name = &quot;Perkataan &quot; .. lang_name .. &quot; diterbitkan daripada &quot; .. etymon_lang_name .. &quot; &quot; .. pos_type .. &quot; &quot; .. entry_name
	else
		cat_name = &quot;Perkataan &quot; .. lang_name .. &quot; milik &quot; .. pos_type .. &quot; &quot; .. entry_name
	end

	-- Add ID disambiguation if needed (for roots/words: use etymon_id if resolved via senseid, otherwise use id)
	local target_ids = available_etymon_ids[term.target_key]
	local effective_id = term.etymon_id or term.id  -- etymon_id if senseid, otherwise id is already an etymon id
	if target_ids and effective_id then
		local same_pos_count = 0
		for _, id_data in ipairs(target_ids) do
			if type(id_data) == &quot;table&quot; and id_data.pos == pos then
				same_pos_count = same_pos_count + 1
			end
		end
		if same_pos_count &gt; 1 then
			cat_name = cat_name .. &quot; (&quot; .. effective_id .. &quot;)&quot;
		end
	end

	add_category(categories, cat_name)
end

-- Compute chain state for a term based on parent chain and keyword config
-- Hyphen patterns for affix detection (regular hyphen + script-specific)
local AFFIX_HYPHEN_PATTERN = &quot;[%-%־ـ᠊]&quot; -- regular hyphen, Hebrew maqqef, Arabic tatweel, Mongolian hyphen

-- Check if a term is an actual affix (not a non-affix member of an affix group)
local function is_actual_affix(term)
	-- Check explicit aftype modifier
	if term.aftype then
		local normalized = aftype_aliases[term.aftype] or term.aftype
		return normalized ~= &quot;non-affix&quot;
	end
	-- Check if pos=root (treated as non-affix)
	if term.args and term.args.pos and term.args.pos == &quot;root&quot; then
		return false
	end
	-- Auto-detect by hyphen: prefix ends with -, suffix starts with -, etc.
	if term.title then
		local title = term.title
		-- Strip leading * for reconstructed terms before checking hyphens
		title = title:gsub(&quot;^%*&quot;, &quot;&quot;)
		-- Check for hyphens at start or end (handles script-specific hyphens too)
		if title:match(&quot;^&quot; .. AFFIX_HYPHEN_PATTERN) or title:match(AFFIX_HYPHEN_PATTERN .. &quot;$&quot;) then
			return true
		end
	end
	-- Default: not an affix
	return false
end

local function compute_category_chain(parent_chain, config, page_lang, term_lang, get_norm_lang_func, parent_term_lang, term)
	-- Track if we're inside an actual affix (for suppressing root categories on descendants)
	-- Only set if the term is an actual affix (prefix, suffix, etc.), not a non-affix member
	local inside_affix = parent_chain.inside_affix
	if config.affix_categories and term and is_actual_affix(term) then
		inside_affix = true
	end

	-- If no_child_categories is set, disable everything
	if config.no_child_categories then
		return {
			passed_through = parent_chain.passed_through or page_lang:getCode() ~= get_norm_lang_func(term_lang):getCode(),
			inherited = false,
			source = false,
			pos = false,
			recurse = false,
			inside_affix = inside_affix,
		}
	end

	local term_is_transitive = is_transitive(config.transitive, page_lang, term_lang)
	local new_source = parent_chain.source and term_is_transitive
	
	-- For CROSS_LANG_NO_INTERNAL_SOURCE: track internal derivation language context
	-- Check if this term is internal relative to parent term's language (if parent_term_lang provided)
	-- or relative to page language (if no parent_term_lang)
	local internal_lang = parent_chain.internal_lang
	local is_internal_in_context = false
	if config.transitive == M.data.TRANSITIVE.CROSS_LANG_NO_INTERNAL_SOURCE then
		local check_lang = parent_term_lang or page_lang
		local term_lang_code = get_norm_lang_func(term_lang):getCode()
		local check_lang_code = get_norm_lang_func(check_lang):getCode()
		
		if internal_lang then
			-- Already in an internal derivation context: check if this term is also internal
			is_internal_in_context = term_lang_code == internal_lang
		else
			-- Check if this term is internal relative to parent term (or page if no parent)
			is_internal_in_context = term_lang_code == check_lang_code
		end
	end
	
	-- Source chain behavior for CROSS_LANG_NO_INTERNAL_SOURCE
	if config.transitive == M.data.TRANSITIVE.CROSS_LANG_NO_INTERNAL_SOURCE then
		if is_internal_in_context then
			-- Internal derivation
			new_source = false
			internal_lang = get_norm_lang_func(term_lang):getCode()
		else
			-- Cross-language
			new_source = parent_chain.source and term_is_transitive
			internal_lang = nil
		end
	end
	
	local new_pos = parent_chain.pos

	return {
		passed_through = parent_chain.passed_through or page_lang:getCode() ~= get_norm_lang_func(term_lang):getCode(),
		inherited = parent_chain.inherited and config.inherited_chain,
		source = new_source,
		pos = new_pos,
		internal_lang = internal_lang,
		recurse = new_source or new_pos,
		inside_affix = inside_affix,
	}
end

function export.render(opts)
	opts = opts or {}
	local data_tree = opts.data_tree
	local page_lang = opts.page_lang
	local available_etymon_ids = opts.available_etymon_ids
	local senseid_parent_etymon = opts.senseid_parent_etymon
	local get_norm_lang_func = opts.get_norm_lang_func
	local lang_exc = opts.lang_exc

	local categories = {}
	local seen = {}
	local lang_name = page_lang:getCanonicalName()
	local root_title = data_tree.title

	-- Collect the tree recursively
	local function collect(node, parent_chain, is_toplevel)
		-- Avoid processing same node twice
		if not node.unknown_term and node.title then
			local key = node.lang:getFullCode() .. &quot;:&quot; .. (node.title or &quot;&quot;) .. &quot;:&quot; .. (node.id or &quot;&quot;)
			if seen[key] then return end
			seen[key] = true
		end

		-- Collect affix categories at top level only
		if is_toplevel then
			local affix_cats = collect_affix_categories(node, page_lang, available_etymon_ids, senseid_parent_etymon, lang_exc)
			for _, cat in ipairs(affix_cats) do
				add_category(categories, lang_name .. &quot; &quot; .. cat.cat, cat.sort_key, cat.sort_base)
			end
		end

		-- Process each container
		for _, container in ipairs(node.children or {}) do
			local keyword = container.keyword
			local config = get_keyword_config(keyword, lang_exc)

			-- Skip invalid keywords
			if config then
				-- Process each term in the container
				for _, term in ipairs(container.terms or {}) do
					local term_chain = compute_category_chain(parent_chain, config, page_lang, term.lang, get_norm_lang_func, node.lang, term)
					local no_child_categories = config.no_child_categories == true
					local term_is_transitive = is_transitive(config.transitive, page_lang, term.lang)

					-- Top-level only processing
					if is_toplevel then
						-- Missing/ambiguous etymon tracking
						if not term.unknown_term and (term.status == M.data.STATUS.MISSING or term.status == M.data.STATUS.REDLINK) then
							add_category(categories, lang_name .. &quot; entries referencing missing etymons&quot;)
						end
						if not term.unknown_term and term.status == M.data.STATUS.AMBIGUOUS then
							add_category(categories, lang_name .. &quot; entries referencing ambiguous etymons&quot;)
						end
						if term.missing_descendants_header then
							add_category(categories, lang_name .. &quot; entries referencing etymons without Descendants sections&quot;)
						end
						if term.missing_descendants_entry then
							add_category(categories, lang_name .. &quot; entries referencing etymons without this term in Descendants sections&quot;)
						end

						-- Top-level category (e.g., &quot;undefined derivations&quot;)
						if config.toplevel_category then
							add_category(categories, lang_name .. &quot; &quot; .. config.toplevel_category)
						end

						-- Borrowing categories (bor, lbor, slbor, ubor, obor)
						if config.borrowing_type or config.specialized_borrowing then
							collect_borrowing_categories(categories, page_lang, term, config)
						end

						-- Borrowing categories from &lt;bor&gt;, &lt;lbor&gt;, or &lt;slbor&gt; modifiers on :af/:surf terms
						if keyword == &quot;affix&quot; or keyword == &quot;surf&quot; then
							if term.bor then
								local bor_config = { borrowing_type = &quot;borrowed&quot; }
								collect_borrowing_categories(categories, page_lang, term, bor_config)
							elseif term.lbor then
								local bor_config = { specialized_borrowing = &quot;learned&quot; }
								collect_borrowing_categories(categories, page_lang, term, bor_config)
							elseif term.slbor then
								local bor_config = { specialized_borrowing = &quot;semi-learned&quot; }
								collect_borrowing_categories(categories, page_lang, term, bor_config)
							end
						end

						-- Source-based derivation categories (sl, calque, pcal)
						if config.source_category_type then
							collect_source_derivation_categories(categories, page_lang, term, config)
						end

						-- Skip all child categorisation if no_child_categories is set
						if not no_child_categories then
							-- Source categories only if transitive
							if term_is_transitive then
								collect_source_categories(categories, page_lang, term, term_chain, get_norm_lang_func)
							end

							-- Pos categories always (unless no_child_categories)
							collect_pos_categories(categories, page_lang, root_title, term, available_etymon_ids, term_chain,
								get_norm_lang_func, lang_exc, keyword)
						end
					else
						-- Below top level, respect the parent chain
						if parent_chain.source then
							collect_source_categories(categories, page_lang, term, term_chain, get_norm_lang_func)
						end

						if parent_chain.pos then
							collect_pos_categories(categories, page_lang, root_title, term, available_etymon_ids, term_chain,
								get_norm_lang_func, lang_exc, keyword)
						end
					end

					-- Recurse into term's children if needed and status allows
					if term_chain.recurse and (term.status == M.data.STATUS.OK or term.status == M.data.STATUS.INLINE) then
						collect(term, term_chain, false)
					end
				end
			end
		end
	end

	-- Initial chain state
	local initial_chain = {
		passed_through = false,
		inherited = true,
		source = true,
		pos = true,
		internal_lang = nil,
		recurse = true,
		inside_affix = false,
	}

	collect(data_tree, initial_chain, true)

	local cat_list = {}
	for cat_name, sort_data in pairs(categories) do
		if sort_data.sort_key ~= nil or sort_data.sort_base ~= nil then
			table.insert(cat_list, {
				name = cat_name,
				sort_key = sort_data.sort_key,
				sort_base = sort_data.sort_base,
			})
		else
			table.insert(cat_list, cat_name)
		end
	end
	return cat_list
end

function export.format(entries, lang)
	if type(entries) ~= &quot;table&quot; or #entries == 0 then
		return &quot;&quot;
	end

	local parts = {}
	for _, category in ipairs(entries) do
		if type(category) == &quot;table&quot; and type(category.name) == &quot;string&quot; then
			table.insert(parts, M.utilities.format_categories({ category.name }, lang, category.sort_key, category.sort_base))
		elseif type(category) == &quot;string&quot; then
			table.insert(parts, M.utilities.format_categories({ category }, lang))
		end
	end

	return table.concat(parts)
end

return export</text>
      <sha1>g2ljrv19nstuu4cg2oqpsykek0ecpsc</sha1>
    </revision>
  </page>
  <page>
    <title>Modul:etymon/text</title>
    <ns>828</ns>
    <id>82359</id>
    <revision>
      <id>342819</id>
      <parentid>234443</parentid>
      <timestamp>2026-05-16T13:40:41Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <comment>Mengemas kini mengikut padanan Wikikamus bahasa Inggeris (semakan [[en:Special:Diff/90369741|90369741]]), terjemahan belum selesai</comment>
      <origin>342819</origin>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="16672" sha1="apkzd2ykoxaur8xi7e7q6ckn0p4heg1" xml:space="preserve">local export = {}

local loader = require(&quot;Module:module loader&quot;)

local M = loader.init({
	require = {
		en_utilities = &quot;Module:en-utilities&quot;,
		references = &quot;Module:references&quot;,
	},
	loadData = {
		data = &quot;Module:etymon/data&quot;,
	},
})

function export.render(opts)
	opts = opts or {}
	local data_tree = opts.data_tree
	local format_term_func = opts.format_term_func
	local max_depth = opts.max_depth
	local stop_at_blue_link = opts.stop_at_blue_link
	local curr_page = opts.curr_page
	local nodot = opts.nodot
	local stop_at_lang = opts.stop_at_lang
	local stop_at_lang_or_bluelink = opts.stop_at_lang_or_bluelink

	local children = data_tree.children
	if not children or #children == 0 then
		return &quot;&quot;
	end

	local top_l2 = data_tree.lang:getFullCode() .. &quot;:&quot; .. curr_page

	-- Get refs for a term
	local function get_term_refs(term, term_lang, depth)
		local term_l2 = term_lang:getFullCode() .. &quot;:&quot; .. curr_page
		if term.parsed_ref and (depth == 1 or term_l2 == top_l2) then
			return M.references.format_references(term.parsed_ref)
		end
		return &quot;&quot;
	end

	-- Build a text part for a single term
	local function build_term_part(term, current_lang, depth)
		local text = &quot;&quot;
		local new_lang = current_lang
		local lang_changed = term.lang:getCanonicalName() ~= current_lang:getCanonicalName()

		-- Use centralized format_term (handles suppress_term, unknown_term, and regular terms)
		local term_text = format_term_func(term)

		if lang_changed then
			new_lang = term.lang
			if term_text then
				text = term.lang:makeWikipediaLink() .. &quot; &quot; .. term_text
			elseif term.is_family then
				text = M.en_utilities.add_indefinite_article(term.lang:makeWikipediaLink() .. &quot; language&quot;, false)
			else
				-- suppress_term with language change: show only language
				text = term.lang:makeWikipediaLink()
			end
		else
			text = term_text or &quot;&quot;
		end

		return {
			type = &quot;term&quot;,
			text = text,
			refs = get_term_refs(term, new_lang, depth),
			lang = new_lang,
			is_uncertain = term.is_uncertain or false,
		}
	end

	-- Build text parts for a container
	local function build_container_part(container, node, depth, allow_continuation, fallback_to_bluelink)
		local keyword_info = container.keyword_info
		local keyword_modifiers = container.keyword_modifiers or {}
		local terms = container.terms or {}

		if not keyword_info or #terms == 0 then
			return nil
		end
		-- Skip building text part when invisible in text (&quot;all&quot;, &quot;text&quot;, or true)
		local inv = keyword_info.invisible
		if inv == &quot;all&quot; or inv == true or inv == &quot;text&quot; then
			return nil
		end

		local is_group = keyword_info.is_group
		local keyword_uncertain = keyword_modifiers.unc or false

		-- Determine text and phrase (allowing for overrides)
		local intro_text = keyword_info.text
		local phrase = keyword_info.phrase

		if keyword_modifiers.text then
			-- User-provided override: assumed to be lowercase
			phrase = keyword_modifiers.text
			-- Auto-capitalize for intro text (e.g., &quot;derived from&quot; -&gt; &quot;Derived from&quot;)
			intro_text = mw.ustring.upper(phrase:sub(1, 1)) .. phrase:sub(2)
		end

		-- Get keyword references
		local keyword_refs = &quot;&quot;
		if keyword_modifiers.ref then
			local parsed_keyword_refs = M.references.parse_references(keyword_modifiers.ref)
			if parsed_keyword_refs and parsed_keyword_refs ~= &quot;&quot; then
				keyword_refs = M.references.format_references(parsed_keyword_refs)
			end
		end

		-- Build term parts
		local term_parts = {}
		local current_lang = node.lang

		for _, term in ipairs(terms) do
			local term_part = build_term_part(term, current_lang, depth)
			if term_part.text ~= &quot;&quot; then
				table.insert(term_parts, term_part)
				current_lang = term_part.lang
			end
		end

		-- Check uncertainty distribution
		local uncertain_count = 0
		for _, term_part in ipairs(term_parts) do
			if term_part.is_uncertain then
				uncertain_count = uncertain_count + 1
			end
		end

		-- If keyword itself is uncertain, treat all terms as uncertain
		local all_uncertain = keyword_uncertain or (uncertain_count == #term_parts and #term_parts &gt; 0)
		local has_mixed_uncertainty = not keyword_uncertain and uncertain_count &gt; 0 and uncertain_count &lt; #term_parts

		-- Check if there are more steps (only if continuation is allowed)
		local has_more_steps = false
		local next_node = nil
		local first_term = terms[1]

		-- Check if we should stop at this language
		local reached_stop_lang = false
		if stop_at_lang then
			for _, term in ipairs(terms) do
				if term.lang and term.lang:getCode() == stop_at_lang then
					reached_stop_lang = true
					break
				end
			end
		elseif stop_at_lang_or_bluelink then
			-- Check if we should stop at this language, or at the first bluelink if it's a redlink
			for _, term in ipairs(terms) do
				if term.lang and term.lang:getCode() == stop_at_lang_or_bluelink then
					if first_term.status == M.data.STATUS.OK then
						reached_stop_lang = true
					else
						fallback_to_bluelink = true
					end
					break
				end
			end
			if fallback_to_bluelink and first_term.status == M.data.STATUS.OK then
				reached_stop_lang = true
			end
		end

		if allow_continuation and not is_group and #terms == 1 and not reached_stop_lang then
			local first_term_children = first_term.children
			if first_term_children and #first_term_children &gt; 0 and (not max_depth or depth &lt; max_depth) then
				local next_container = first_term_children[1]
				local next_keyword_info = next_container and next_container.keyword_info
				if not (next_keyword_info and next_keyword_info.invisible) then
					if stop_at_blue_link then
						if first_term.status ~= M.data.STATUS.OK then
							has_more_steps = true
							next_node = first_term
						end
					else
						has_more_steps = true
						next_node = first_term
					end
				end
			end
		end

		return {
			type = &quot;container&quot;,
			intro_text = intro_text,
			phrase = phrase,
			is_uncertain = all_uncertain,
			has_mixed_uncertainty = has_mixed_uncertainty,
			term_parts = term_parts,
			is_group = is_group,
			has_more_steps = has_more_steps,
			next_node = next_node,
			new_sentence = keyword_info.new_sentence or false,
			separate_clause = keyword_info.separate_clause or false,
			conj = keyword_modifiers.conj, -- custom conjunction: &quot;and&quot;, &quot;or&quot;, &quot;and/or&quot;, etc.
			lit = keyword_modifiers.lit,
			keyword_refs = keyword_refs,
			fallback_to_bluelink = fallback_to_bluelink,
		}
	end

	-- Build the full tree of text parts
	local function build_text_tree(node, depth, allow_continuation, fallback_to_bluelink)
		local containers = node.children
		if not containers or #containers == 0 then
			return nil
		end

		local container_parts = {}

		-- Count containers that get a text part (invisible in text = &quot;all&quot;, &quot;text&quot;, or true)
		local visible_container_count = 0
		for _, container in ipairs(containers) do
			local keyword_info = container.keyword_info
			local inv = keyword_info and keyword_info.invisible
			if not (inv == &quot;all&quot; or inv == true or inv == &quot;text&quot;) then
				visible_container_count = visible_container_count + 1
			end
		end

		-- If there are multiple visible containers at this level, don't allow continuation for any
		local has_multiple_containers = visible_container_count &gt; 1
		local should_allow_continuation = allow_continuation and not has_multiple_containers

		for _, container in ipairs(containers) do
			local part = build_container_part(container, node, depth, should_allow_continuation, fallback_to_bluelink)
			if part then
				-- Recursively build children if there are more steps
				if part.has_more_steps and part.next_node then
					part.continuation = build_text_tree(part.next_node, depth + 1, true, part.fallback_to_bluelink)
				end
				table.insert(container_parts, part)
			end
		end

		if #container_parts == 0 then
			return nil
		end

		return {
			type = &quot;tree&quot;,
			container_parts = container_parts,
			depth = depth,
		}
	end

	-- Check if tree has mixed joining types
	local function check_complexity(tree)
		if not tree then return nil end

		local parts = tree.container_parts
		if #parts &lt;= 1 then
			-- Single container
			if parts[1] and parts[1].continuation then
				return check_complexity(parts[1].continuation)
			end
			return nil
		end

		-- Multiple containers
		local has_or_join = false
		local has_new_sentence = false
		local has_separate_clause = false

		for i = 2, #parts do
			local part = parts[i]
			-- Ignore etydate parts for complexity checks
			if part.type ~= &quot;etydate&quot; then
				if part.new_sentence then
					has_new_sentence = true
				elseif part.separate_clause then
					has_separate_clause = true
				else
					has_or_join = true
				end
			end
		end

		local join_type_count = 0
		if has_or_join then join_type_count = join_type_count + 1 end
		if has_new_sentence then join_type_count = join_type_count + 1 end
		if has_separate_clause then join_type_count = join_type_count + 1 end

		if join_type_count &gt; 1 then
			error(
				&quot;Cannot generate etymology text: mixed joining styles (e.g., alternatives joined with 'or' cannot be combined with calques or influences in the same list).&quot;)
		end

		return nil
	end

	-- Analyze tree and assign punctuation
	local function analyze_punctuation(tree, is_toplevel)
		if not tree then return end

		local parts = tree.container_parts
		local num_parts = #parts

		for i, part in ipairs(parts) do
			local is_first = (i == 1)
			local is_last = (i == num_parts)
			local next_part = parts[i + 1]

			-- Analyze term punctuation within container
			-- Terms use Oxford comma style: &quot;A, B, or C&quot;
			-- Custom conjunction can be specified via conj modifier (e.g., &quot;and/or&quot;, &quot;and&quot;)
			local num_terms = #part.term_parts
			local term_conj = part.conj or &quot;or&quot; -- default to &quot;or&quot;
			for j, term_part in ipairs(part.term_parts) do
				local is_last_term = (j == num_terms)

				if part.is_group then
					-- Group: terms joined with &quot; + &quot;
					term_part.joiner = is_last_term and &quot;&quot; or &quot; + &quot;
				elseif num_terms &gt; 1 then
					-- Multiple terms not in a group: Oxford comma style
					if is_last_term then
						term_part.joiner = &quot;&quot;
					elseif j == num_terms - 1 then
						-- Second to last term
						if num_terms == 2 then
							term_part.joiner = &quot; &quot; .. term_conj .. &quot; &quot;
						else
							term_part.joiner = &quot;, &quot; .. term_conj .. &quot; &quot;
						end
					else
						term_part.joiner = &quot;, &quot;
					end
				else
					-- Single term
					term_part.joiner = &quot;&quot;
				end
			end

			-- Determine container punctuation based on what comes next
			if part.continuation then
				-- Has continuation
				part.punctuation = &quot;,&quot;
				-- Recursively analyze continuation
				analyze_punctuation(part.continuation, false)
			elseif is_last then
				-- Last container
				part.punctuation = (is_toplevel and nodot) and &quot;&quot; or &quot;.&quot;
			elseif next_part and next_part.new_sentence then
				-- Next container starts a new sentence
				part.punctuation = &quot;.&quot;
			elseif next_part and next_part.separate_clause then
				-- Next container is a separate clause
				part.punctuation = &quot;,&quot;
			else
				-- Not last, next is joined with &quot;or&quot;
				-- Containers use repeated &quot;or&quot; style: &quot;A, or B, or C&quot;
				part.punctuation = &quot;,&quot;
			end

			-- Determine joiner to next part
			-- Containers use repeated &quot;or&quot; style: &quot;, or&quot; between each
			-- Custom conjunction can be specified via conj modifier
			local container_conj = part.conj or &quot;or&quot; -- default to &quot;or&quot;
			if not is_last then
				if next_part and next_part.new_sentence then
					-- New sentence
					part.joiner = &quot; &quot;
				elseif next_part and next_part.separate_clause then
					-- Separate clause
					part.joiner = &quot; &quot;
				else
					-- Same sentence: use custom conjunction or default &quot;or&quot;
					part.joiner = &quot; &quot; .. container_conj .. &quot; &quot;
				end
			else
				part.joiner = &quot;&quot;
			end

			-- Determine intro formatting
			-- Capitalize if first at top level, OR if this container starts a new sentence
			if (is_first and is_toplevel) or part.new_sentence then
				part.intro_capitalized = true
				part.use_full_intro = true
			else
				part.intro_capitalized = false
				part.use_full_intro = false
			end
		end
	end

	-- Assemble text from analyzed tree
	local function assemble_text(tree)
		if not tree then return &quot;&quot; end

		local result = &quot;&quot;

		for i, part in ipairs(tree.container_parts) do
			if part.type == &quot;etydate&quot; then
				result = result .. part.etydate_text
				if part.punctuation and part.punctuation ~= &quot;&quot; then
					result = result .. part.punctuation
				end
				if part.etydate_refs and next(part.etydate_refs) then
					result = result .. M.references.format_references(part.etydate_refs)
				end
				if part.joiner and part.joiner ~= &quot;&quot; then
					result = result .. part.joiner
				end
			else
				-- Build intro
				local intro
				if part.use_full_intro then
					if part.is_uncertain then
						intro = &quot;Possibly &quot; .. part.phrase
					else
						intro = part.intro_text
					end
			else
				if part.is_uncertain then
					intro = &quot;possibly &quot; .. part.phrase
				else
					intro = part.phrase
				end
			end

			result = result .. intro

			-- Build terms
			if #part.term_parts &gt; 0 then
				result = result .. &quot; &quot;

				for j, term_part in ipairs(part.term_parts) do
					-- Add &quot;possibly&quot; prefix for uncertain terms when there's mixed uncertainty
					if part.has_mixed_uncertainty and term_part.is_uncertain then
						result = result .. &quot;possibly &quot;
					end

					result = result .. term_part.text

					-- Add joiner between terms
					if term_part.joiner ~= &quot;&quot; then
						-- Check if joiner contains comma (punctuation)
						local comma_pos = term_part.joiner:find(&quot;,&quot;)
						if comma_pos then
							-- Add up to and including comma
							result = result .. term_part.joiner:sub(1, comma_pos)
							-- Add refs after comma
							if term_part.refs ~= &quot;&quot; then
								result = result .. term_part.refs
							end
							-- Add rest of joiner
							result = result .. term_part.joiner:sub(comma_pos + 1)
						else
							-- No comma, add refs before joiner
							if term_part.refs ~= &quot;&quot; then
								result = result .. term_part.refs
							end
							result = result .. term_part.joiner
						end
					end
				end

				-- For the last term, add punctuation then refs
				local last_term = part.term_parts[#part.term_parts]
				if last_term and last_term.joiner == &quot;&quot; then
					if part.punctuation ~= &quot;&quot; then
						-- If we have literal text, punctuation goes AFTER it
						if part.lit then
							-- Add refs first (attached to term)
							if last_term.refs ~= &quot;&quot; then
								result = result .. last_term.refs
							end
							-- Add keyword refs
							if part.keyword_refs and part.keyword_refs ~= &quot;&quot; then
								result = result .. part.keyword_refs
							end
							-- Add literal text
							result = result .. &quot;, literally “&quot; .. part.lit .. &quot;”&quot;
							-- Add punctuation
							result = result .. part.punctuation
						else
							-- Normal behavior: punctuation then refs
							result = result .. part.punctuation
							if last_term.refs ~= &quot;&quot; then
								result = result .. last_term.refs
							end
							-- Add keyword refs after term refs
							if part.keyword_refs and part.keyword_refs ~= &quot;&quot; then
								result = result .. part.keyword_refs
							end
						end
					else
						-- No punctuation
						if last_term.refs ~= &quot;&quot; then
							result = result .. last_term.refs
						end
						-- Add keyword refs
						if part.keyword_refs and part.keyword_refs ~= &quot;&quot; then
							result = result .. part.keyword_refs
						end
						-- Add literal text if present (even without punctuation)
						if part.lit then
							result = result .. &quot;, literally “&quot; .. part.lit .. &quot;”&quot;
						end
					end
				end
			else
				-- No terms, just add punctuation and keyword refs
				if part.punctuation ~= &quot;&quot; then
					result = result .. part.punctuation
				end
				-- Add keyword refs even when there are no terms
				if part.keyword_refs and part.keyword_refs ~= &quot;&quot; then
					result = result .. part.keyword_refs
				end
			end

			-- Add continuation
			if part.continuation then
				result = result .. &quot; &quot; .. assemble_text(part.continuation)
			end

			-- Add joiner to next container
			if part.joiner ~= &quot;&quot; then
				result = result .. part.joiner
			end
		end
	end

		return result
	end

	local text_tree = build_text_tree(data_tree, 1, true, false)
	if not text_tree then
		return &quot;&quot;
	end

	-- Add etydate container
	if data_tree.etydate and data_tree.etydate ~= &quot;&quot; then
		table.insert(text_tree.container_parts, {
			type = &quot;etydate&quot;,
			etydate_text = data_tree.etydate,
			etydate_refs = data_tree.etydate_refs,
			term_parts = {},
			new_sentence = true,
		})
	end

	check_complexity(text_tree)
	analyze_punctuation(text_tree, true)
	return assemble_text(text_tree)
end

return export</text>
      <sha1>apkzd2ykoxaur8xi7e7q6ckn0p4heg1</sha1>
    </revision>
  </page>
  <page>
    <title>Templat:table:gregorian calendar</title>
    <ns>10</ns>
    <id>85110</id>
    <revision>
      <id>342836</id>
      <parentid>316921</parentid>
      <timestamp>2026-05-16T23:58:50Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <origin>342836</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1488" sha1="kj3vmpi66k5ie4aaa9ggxbpcx5pjukd" xml:space="preserve">{| class=&quot;wikitable&quot; style=&quot;text-align: center; white-space: nowrap; width 100%&quot;
! colspan=&quot;4&quot; | Bulan takwim Masihi {{table mul test|lang={{{lang|und}}}}} {{#ifeq:{{{gregorian calendar months}}}|-|| · {{{gregorian calendar months}}}}} {{table edit|gregorian calendar|{{{lang|}}}}}
|-
| style=&quot;background: var(--wikt-palette-lightergrey,#f2f2f2);&quot; | '''Januari'''
| style=&quot;background: var(--wikt-palette-lightergrey,#f2f2f2);&quot; | '''Februari'''
| style=&quot;background: var(--wikt-palette-lightergrey,#f2f2f2);&quot; | '''Mac'''
| style=&quot;background: var(--wikt-palette-lightergrey,#f2f2f2);&quot; | '''April'''
|-
| {{{jan}}}
| {{{feb}}}
| {{{mar}}}
| {{{apr}}}
|-
| style=&quot;background: var(--wikt-palette-lightergrey,#f2f2f2);&quot; | '''Mei'''
| style=&quot;background: var(--wikt-palette-lightergrey,#f2f2f2);&quot; | '''Jun'''
| style=&quot;background: var(--wikt-palette-lightergrey,#f2f2f2);&quot; | '''Julai'''
| style=&quot;background: var(--wikt-palette-lightergrey,#f2f2f2);&quot; | '''Ogos'''
|-
| {{{may}}}
| {{{jun}}}
| {{{jul}}}
| {{{aug}}}
|-
| style=&quot;background: var(--wikt-palette-lightergrey,#f2f2f2);&quot; | '''September'''
| style=&quot;background: var(--wikt-palette-lightergrey,#f2f2f2);&quot; | '''Oktober'''
| style=&quot;background: var(--wikt-palette-lightergrey,#f2f2f2);&quot; | '''November'''
| style=&quot;background: var(--wikt-palette-lightergrey,#f2f2f2);&quot; | '''Disember'''
|-
| {{{sep}}}
| {{{oct}}}
| {{{nov}}}
| {{{dec}}}
|}&lt;includeonly&gt;[[Category:{{{lang|}}}:Bulan takwim Masihi]]&lt;/includeonly&gt;&lt;noinclude&gt;{{table doc}}&lt;/noinclude&gt;</text>
      <sha1>kj3vmpi66k5ie4aaa9ggxbpcx5pjukd</sha1>
    </revision>
  </page>
  <page>
    <title>Kategori:Parapsikologi</title>
    <ns>14</ns>
    <id>87718</id>
    <revision>
      <id>342853</id>
      <parentid>247941</parentid>
      <timestamp>2026-05-17T08:41:30Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <minor />
      <comment>Hakimi97 telah memindahkan laman [[Kategori:Forteana]] ke [[Kategori:Parapsikologi]]: Tajuk salah eja</comment>
      <origin>247941</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="12" sha1="eomzlm5v4j7ond1phrju7cnue91g5qx" xml:space="preserve">{{auto cat}}</text>
      <sha1>eomzlm5v4j7ond1phrju7cnue91g5qx</sha1>
    </revision>
  </page>
  <page>
    <title>Kategori:ar:Bulan takwim Masihi</title>
    <ns>14</ns>
    <id>112657</id>
    <revision>
      <id>342800</id>
      <parentid>278863</parentid>
      <timestamp>2026-05-16T12:28:39Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <minor />
      <comment>Hakimi97 telah memindahkan laman [[Kategori:ar:Bulan kalendar Masihi]] ke [[Kategori:ar:Bulan takwim Masihi]]: Tajuk salah eja</comment>
      <origin>278863</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="12" sha1="eomzlm5v4j7ond1phrju7cnue91g5qx" xml:space="preserve">{{auto cat}}</text>
      <sha1>eomzlm5v4j7ond1phrju7cnue91g5qx</sha1>
    </revision>
  </page>
  <page>
    <title>Kategori:ar:Kelengkapan dandanan diri</title>
    <ns>14</ns>
    <id>112663</id>
    <revision>
      <id>342860</id>
      <parentid>278869</parentid>
      <timestamp>2026-05-17T08:47:37Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <minor />
      <comment>Hakimi97 telah memindahkan laman [[Kategori:ar:Kelengkapan tandas]] ke [[Kategori:ar:Kelengkapan dandanan diri]]: Tajuk salah eja</comment>
      <origin>278869</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="12" sha1="eomzlm5v4j7ond1phrju7cnue91g5qx" xml:space="preserve">{{auto cat}}</text>
      <sha1>eomzlm5v4j7ond1phrju7cnue91g5qx</sha1>
    </revision>
  </page>
  <page>
    <title>Kategori:ar:Parapsikologi</title>
    <ns>14</ns>
    <id>112695</id>
    <revision>
      <id>342850</id>
      <parentid>278901</parentid>
      <timestamp>2026-05-17T08:40:15Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <minor />
      <comment>Hakimi97 telah memindahkan laman [[Kategori:ar:Forteana]] ke [[Kategori:ar:Parapsikologi]]: Tajuk salah eja</comment>
      <origin>278901</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="12" sha1="eomzlm5v4j7ond1phrju7cnue91g5qx" xml:space="preserve">{{auto cat}}</text>
      <sha1>eomzlm5v4j7ond1phrju7cnue91g5qx</sha1>
    </revision>
  </page>
  <page>
    <title>Kategori:my:Paranormal</title>
    <ns>14</ns>
    <id>113436</id>
    <revision>
      <id>342858</id>
      <parentid>279700</parentid>
      <timestamp>2026-05-17T08:43:58Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <minor />
      <comment>Hakimi97 telah memindahkan laman [[Kategori:my:Forteana]] ke [[Kategori:my:Paranormal]]: Tajuk salah eja</comment>
      <origin>279700</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="12" sha1="eomzlm5v4j7ond1phrju7cnue91g5qx" xml:space="preserve">{{auto cat}}</text>
      <sha1>eomzlm5v4j7ond1phrju7cnue91g5qx</sha1>
    </revision>
  </page>
  <page>
    <title>Kategori:zh:Kelengkapan dandanan diri</title>
    <ns>14</ns>
    <id>115316</id>
    <revision>
      <id>342856</id>
      <parentid>281887</parentid>
      <timestamp>2026-05-17T08:42:38Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <minor />
      <comment>Hakimi97 telah memindahkan laman [[Kategori:zh:Kelengkapan tandas]] ke [[Kategori:zh:Kelengkapan dandanan diri]]: Tajuk salah eja</comment>
      <origin>281887</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="12" sha1="eomzlm5v4j7ond1phrju7cnue91g5qx" xml:space="preserve">{{auto cat}}</text>
      <sha1>eomzlm5v4j7ond1phrju7cnue91g5qx</sha1>
    </revision>
  </page>
  <page>
    <title>Kategori:en:Bulan takwim Masihi</title>
    <ns>14</ns>
    <id>117622</id>
    <revision>
      <id>342810</id>
      <parentid>327410</parentid>
      <timestamp>2026-05-16T12:36:12Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <minor />
      <comment>Hakimi97 telah memindahkan laman [[Kategori:en:Bulan kalendar Masihi]] ke [[Kategori:en:Bulan takwim Masihi]]: Tajuk salah eja</comment>
      <origin>327410</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="12" sha1="eomzlm5v4j7ond1phrju7cnue91g5qx" xml:space="preserve">{{auto cat}}</text>
      <sha1>eomzlm5v4j7ond1phrju7cnue91g5qx</sha1>
    </revision>
  </page>
  <page>
    <title>Kategori:en:Bulan takwim Gregory</title>
    <ns>14</ns>
    <id>117623</id>
    <revision>
      <id>342837</id>
      <parentid>327414</parentid>
      <timestamp>2026-05-17T00:01:01Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <origin>342837</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="57" sha1="epacimr4fah52boyx2b06bcasp21gox" xml:space="preserve">{{delete|sudah ada [[:Kategori:en:Bulan takwim Masihi]]}}</text>
      <sha1>epacimr4fah52boyx2b06bcasp21gox</sha1>
    </revision>
  </page>
  <page>
    <title>Kategori:en:Kelengkapan dandanan diri</title>
    <ns>14</ns>
    <id>117668</id>
    <revision>
      <id>342864</id>
      <parentid>327633</parentid>
      <timestamp>2026-05-17T08:49:00Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <minor />
      <comment>Hakimi97 telah memindahkan laman [[Kategori:en:Kelengkapan tandas]] ke [[Kategori:en:Kelengkapan dandanan diri]]: Tajuk salah eja</comment>
      <origin>327633</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="12" sha1="eomzlm5v4j7ond1phrju7cnue91g5qx" xml:space="preserve">{{auto cat}}</text>
      <sha1>eomzlm5v4j7ond1phrju7cnue91g5qx</sha1>
    </revision>
  </page>
  <page>
    <title>Kategori:en:Forteana</title>
    <ns>14</ns>
    <id>117788</id>
    <revision>
      <id>342852</id>
      <parentid>328246</parentid>
      <timestamp>2026-05-17T08:41:07Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <origin>342852</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="27" sha1="44ksjr1xemtnyzfprzw0v5sq74e9sbx" xml:space="preserve">{{delete|tidak diperlukan}}</text>
      <sha1>44ksjr1xemtnyzfprzw0v5sq74e9sbx</sha1>
    </revision>
  </page>
  <page>
    <title>Kategori:af:Bulan takwim Masihi</title>
    <ns>14</ns>
    <id>117929</id>
    <revision>
      <id>342813</id>
      <parentid>332640</parentid>
      <timestamp>2026-05-16T12:37:41Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <minor />
      <comment>Hakimi97 telah memindahkan laman [[Kategori:af:bulan kalendar Masihi]] ke [[Kategori:af:Bulan takwim Masihi]]</comment>
      <origin>332640</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="12" sha1="eomzlm5v4j7ond1phrju7cnue91g5qx" xml:space="preserve">{{auto cat}}</text>
      <sha1>eomzlm5v4j7ond1phrju7cnue91g5qx</sha1>
    </revision>
  </page>
  <page>
    <title>Modul:template cat</title>
    <ns>828</ns>
    <id>118621</id>
    <revision>
      <id>342833</id>
      <parentid>342775</parentid>
      <timestamp>2026-05-16T14:18:43Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <origin>342833</origin>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="31516" sha1="0ff5hjaygssgnrmwqbpo1g4fnx1ce30" xml:space="preserve">-- Author: Benwing

local export = {}

local require_when_needed = require(&quot;Module:utilities/require when needed&quot;)
local is_callable = require_when_needed(&quot;Module:fun&quot;, &quot;is_callable&quot;)
local format_categories = require_when_needed(&quot;Module:utilities&quot;, &quot;format_categories&quot;)
local parse_interface_module = &quot;Module:parse interface&quot;
local m_string_utilities = require(&quot;Module:string utilities&quot;)
local und_lang = require(&quot;Module:languages&quot;).getByCode(&quot;und&quot;, true)

local ugsub = m_string_utilities.gsub
local ufind = m_string_utilities.find
local split = m_string_utilities.split

local insert = table.insert
local concat = table.concat
local unpack = unpack or table.unpack -- Lua 5.2 compatibility


-- This table detects the category type of the template given its name. When this is invoked, the language code has
-- already been removed from the beginning, and anything starting with a slash has been truncated. The entries are
-- processed in order and are two-element lists of Lua patterns (anchored on both sides; beware of hyphens, which need
-- to be %-escaped) and the category type to use. The category types themselves are mapped to categories in
-- category_type_to_category.
local detect_category_type_list = {
	-- order is important here

	-- nouns, proper nouns, pronouns
	-- (1) unambiguous decl/infl templates
	{&quot;decl%-.*proper.*&quot;, &quot;noun inflection-table&quot;},
	{&quot;infl%-.*proper.*&quot;, &quot;noun inflection-table&quot;},
	{&quot;decl%-.*pron.*&quot;, &quot;pronoun inflection-table&quot;},
	{&quot;infl%-.*pron.*&quot;, &quot;pronoun inflection-table&quot;},
	{&quot;decl%-noun.*&quot;, &quot;noun inflection-table&quot;},
	{&quot;infl%-noun.*&quot;, &quot;noun inflection-table&quot;},
	-- (2) nouns
	{&quot;noun&quot;, &quot;headword-line&quot;},
	{&quot;noun[ -]form&quot;, &quot;headword-line&quot;},
	{&quot;noun[ -]pl&quot;, &quot;headword-line&quot;},
	{&quot;noun[ -]plonly&quot;, &quot;headword-line&quot;},
	-- Some languages, e.g. Urdu, have inflection templates called e.g. [[Template:ur-noun-f-ī]]. They should be called
	-- [[Template:ur-decl-noun-f-ī]] but we can autodetect them if we exclude the likely cases that are not declension
	-- templates.
	{&quot;noun%-.*&quot;, &quot;noun inflection-table&quot;},
	{&quot;ndecl&quot;, &quot;noun inflection-table&quot;},
	{&quot;ndecl%-.*&quot;, &quot;noun inflection-table&quot;},
	-- (3) proper nouns
	{&quot;proper[ -]?noun&quot;, &quot;headword-line&quot;},
	{&quot;proper[ -]?noun[ -]form&quot;, &quot;headword-line&quot;},
	{&quot;proper[ -]?noun[ -]pl&quot;, &quot;headword-line&quot;},
	{&quot;proper[ -]?noun[ -]plonly&quot;, &quot;headword-line&quot;},
	{&quot;pnoun&quot;, &quot;headword-line&quot;},
	{&quot;pnoun[ -]form&quot;, &quot;headword-line&quot;},
	{&quot;pnoun[ -]pl&quot;, &quot;headword-line&quot;},
	{&quot;pnoun[ -]plonly&quot;, &quot;headword-line&quot;},
	{&quot;propn&quot;, &quot;headword-line&quot;},
	{&quot;propn[ -]form&quot;, &quot;headword-line&quot;},
	{&quot;propn[ -]pl&quot;, &quot;headword-line&quot;},
	{&quot;propn[ -]plonly&quot;, &quot;headword-line&quot;},
	-- See above for inflection templates without 'decl' or 'infl' in them.
	{&quot;proper[ -]?noun%-.*&quot;, &quot;noun inflection-table&quot;},
	{&quot;pnoun%-.*&quot;, &quot;noun inflection-table&quot;},
	{&quot;propn%-.*&quot;, &quot;noun inflection-table&quot;},
	-- (4) pronouns
	{&quot;pron&quot;, &quot;headword-line&quot;},
	{&quot;pronoun&quot;, &quot;headword-line&quot;},
	{&quot;pron[ -]form&quot;, &quot;headword-line&quot;},
	{&quot;pronoun[ -]form&quot;, &quot;headword-line&quot;},
	{&quot;prondecl&quot;, &quot;pronoun inflection-table&quot;},
	{&quot;prondecl%-.*&quot;, &quot;pronoun inflection-table&quot;},
	-- adjectives
	{&quot;decl%-adj.*&quot;, &quot;adjective inflection-table&quot;},
	{&quot;infl%-adj.*&quot;, &quot;adjective inflection-table&quot;},
	{&quot;adj&quot;, &quot;headword-line&quot;},
	{&quot;adjective&quot;, &quot;headword-line&quot;},
	{&quot;adj[ -]form&quot;, &quot;headword-line&quot;},
	{&quot;adjective[ -]form&quot;, &quot;headword-line&quot;},
	{&quot;adj[ -]comp&quot;, &quot;headword-line&quot;},
	{&quot;adjective[ -]comp&quot;, &quot;headword-line&quot;},
	{&quot;adj[ -]sup&quot;, &quot;headword-line&quot;},
	{&quot;adjective[ -]sup&quot;, &quot;headword-line&quot;},
	-- Some languages, e.g. Urdu and Lithuanian, have inflection templates called e.g. [[Template:ur-adj-1]] and
	-- [[Template:lt-adj-is]]. They should be called [[Template:ur-decl-adj-1]] and [[Template:lt-decl-adj-is]] but we
	-- can autodetect them if we exclude the likely cases that are not declension templates.
	{&quot;adj%-.*&quot;, &quot;adjective inflection-table&quot;},
	{&quot;adecl&quot;, &quot;adjective inflection-table&quot;},
	{&quot;adecl%-.*&quot;, &quot;adjective inflection-table&quot;},
	-- verbs; need to avoid including conjunctions
	{&quot;verb&quot;, &quot;headword-line&quot;},
	{&quot;conj&quot;, &quot;verb inflection-table&quot;},
	{&quot;conj[0-9 -].*&quot;, &quot;verb inflection-table&quot;},
	{&quot;conjug.*&quot;, &quot;verb inflection-table&quot;},
	{&quot;infl%-verb.*&quot;, &quot;verb inflection-table&quot;},

	-- pronunciation
	{&quot;.*IPA.*&quot;, &quot;pronunciation&quot;},
	{&quot;pronunciation&quot;, &quot;pronunciation&quot;},
	{&quot;pr&quot;, &quot;pronunciation&quot;},
	{&quot;p&quot;, &quot;pronunciation&quot;},

	-- form-of
	{&quot;.*form of&quot;, &quot;form-of&quot;},

	-- pronominal boxes
	{&quot;.*personal pronouns&quot;, &quot;personal pronoun&quot;},
	{&quot;.*demonstrative.*&quot;, &quot;demonstrative&quot;},
	{&quot;.*interrogative.*&quot;, &quot;interrogative&quot;},
	{&quot;.*possessives&quot;, &quot;possessive&quot;},
	{&quot;.*possessive .*&quot;, &quot;possessive&quot;},
	{&quot;.*reflexives&quot;, &quot;reflexive&quot;},
	{&quot;.*reflexive .*&quot;, &quot;reflexive&quot;},
	-- these next two should precede 'relative'
	{&quot;.*correlatives&quot;, &quot;pro-form&quot;},
	{&quot;.*correlative .*&quot;, &quot;pro-form&quot;},
	{&quot;.*relative .*&quot;, &quot;relative&quot;},
	{&quot;.*articles&quot;, &quot;article&quot;},
	{&quot;.*prefixes&quot;, &quot;affix&quot;},
	{&quot;.*suffixes&quot;, &quot;affix&quot;},

	-- TOC tables
	{&quot;.*TOC&quot;, &quot;TOC&quot;},

	-- numbers, numerals
	{&quot;.*numbers&quot;, &quot;number&quot;},
	{&quot;.*numerals&quot;, &quot;number&quot;},
	{&quot;.*ordinals&quot;, &quot;ordinal&quot;},
	{&quot;.*cardinals&quot;, &quot;cardinal&quot;},
	{&quot;.*digits&quot;, &quot;digit&quot;},

	-- transliteration
	{&quot;.*xlit&quot;, &quot;orthographic conversion&quot;},
	{&quot;.*translit&quot;, &quot;orthographic conversion&quot;},

	-- orthographic and regional variants
	{&quot;.*variant&quot;, &quot;orthographic variant&quot;},
	{&quot;.*regional&quot;, &quot;regional variant&quot;},
	
	-- sign production templates
	-- FIXME: We should limit this to sign languages. As it is, we put it near the bottom of the
	-- pattern list so it doesn't accidentally override other patterns for non-sign languages.
	{&quot;prod .*&quot;, &quot;sign production&quot;},
}

-- This table indicates how to convert template category types to categories. It consists of a list of pairs, where the
-- first element is the category type and the second element is a key-value table containing the following keys:
-- * `aliases`: Optional list of aliases for the category type, which can be used when explicitly specifying the type,
--   e.g. {{tcat|hw}} instead of {{tcat|headword-line}}.
-- * `cats`: List of categories to add the template to. Each entry either specifies a ''raw'' category (if the category
--   name begins with &quot;Category:&quot;), a ''full table'' category (if the category name begins with &quot;label:&quot;, where what
--   follows specifies the full label without the prefixed language name) or a ''regular label'' category (for other
--   strings, where e.g. if the label is &quot;noun inflection-table&quot;, the category name is
--   &quot;LANG noun inflection-table templates&quot;). An entry is either a string, directly specifying the category name, or a
--   key-value table with keys `name` (the category name) and `sort` (how to generate the sort base). By default, the
--   sort base for raw categories is a comma-separated list of the language names (not codes) associated with the
--   template, or the full template name if there are no languages, and the sort base for label categories is the
--   template name minus the initial language code. If this isn't correct, the `sort` field specifies how to compute the
--   sort base. It is either a function of two arguments, the template name and language object, which should return the
--   sort base; or a table of specs telling how to compute the sort base. In the case of a function, the template name
--   passed in is the full name for raw categories, but the name minus any language code prefix in the case of label
--   categories; and for raw categories, a list of all associated language objects is passed in, or {nil} if none, while
--   for label categories, a single language object is passed in. (Label categories can only exist if there are
--   associated languages.) In the case where `sort` is a table of specs, it is a list where each element is a
--   two-element list of a Lua pattern anchored on both sides and the corresponding pattern replacement string. The
--   specs are processed in order.
local category_type_to_category = {
	-- Inflection-table templates
	{&quot;noun inflection-table&quot;, {
		aliases = {&quot;nouninfl&quot;, &quot;noundecl&quot;, &quot;ndecl&quot;},
		cats = {{name = &quot;noun inflection-table&quot;, sort = {
			{&quot;infl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;decl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;noun%-(.*)&quot;, &quot;%1&quot;},
			-- put this twice to catch noun-decl-* and decl-noun-*
			{&quot;infl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;decl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;noun&quot;, &quot;*&quot;},
			{&quot;ndecl%-base%-(.*)&quot;, &quot; %1&quot;},
			{&quot;ndecl%-base&quot;, &quot; &quot;},
			{&quot;ndecl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;ndecl&quot;, &quot;*&quot;},
			{&quot;propndecl%-base%-(.*)&quot;, &quot; %1&quot;},
			{&quot;propndecl%-base&quot;, &quot; &quot;},
			{&quot;propndecl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;propndecl&quot;, &quot;*&quot;},
			{&quot;proper[ -]?noun%-(.*)&quot;, &quot;%1&quot;},
			{&quot;propn%-(.*)&quot;, &quot;%1&quot;},
			{&quot;pnoun%-(.*)&quot;, &quot;%1&quot;},
		}}},
	}},
	{&quot;pronoun inflection-table&quot;, {
		aliases = {&quot;proninfl&quot;, &quot;prondecl&quot;},
		cats = {{name = &quot;pronoun inflection-table&quot;, sort = {
			{&quot;infl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;decl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;pronoun%-(.*)&quot;, &quot;%1&quot;},
			{&quot;pron%-(.*)&quot;, &quot;%1&quot;},
			-- put this twice to catch pron-decl-* and decl-pron-*
			{&quot;infl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;decl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;pronoun&quot;, &quot;*&quot;},
			{&quot;pron&quot;, &quot;*&quot;},
			{&quot;prondecl%-base%-(.*)&quot;, &quot; %1&quot;},
			{&quot;prondecl%-base&quot;, &quot; &quot;},
			{&quot;prondecl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;prondecl&quot;, &quot;*&quot;},
		}}},
	}},
	{&quot;article inflection-table&quot;, {
		aliases = {&quot;artinfl&quot;, &quot;artdecl&quot;},
		cats = {{name = &quot;article inflection-table&quot;, sort = {
			{&quot;infl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;decl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;article%-(.*)&quot;, &quot;%1&quot;},
			{&quot;art%-(.*)&quot;, &quot;%1&quot;},
			-- put this twice to catch art-decl-* and decl-art-*
			{&quot;infl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;decl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;article&quot;, &quot;*&quot;},
			{&quot;art&quot;, &quot;*&quot;},
			{&quot;artdecl%-base%-(.*)&quot;, &quot; %1&quot;},
			{&quot;artdecl%-base&quot;, &quot; &quot;},
			{&quot;artdecl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;artdecl&quot;, &quot;*&quot;},
		}}},
	}},
	{&quot;determiner inflection-table&quot;, {
		aliases = {&quot;detinfl&quot;, &quot;detdecl&quot;},
		cats = {{name = &quot;determiner inflection-table&quot;, sort = {
			{&quot;infl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;decl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;determiner%-(.*)&quot;, &quot;%1&quot;},
			{&quot;det%-(.*)&quot;, &quot;%1&quot;},
			-- put this twice to catch det-decl-* and decl-det-*
			{&quot;infl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;decl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;determiner&quot;, &quot;*&quot;},
			{&quot;det&quot;, &quot;*&quot;},
			{&quot;detdecl%-base%-(.*)&quot;, &quot; %1&quot;},
			{&quot;detdecl%-base&quot;, &quot; &quot;},
			{&quot;detdecl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;detdecl&quot;, &quot;*&quot;},
		}}},
	}},
	{&quot;preposition inflection-table&quot;, {
		aliases = {&quot;prepinfl&quot;, &quot;prepdecl&quot;},
		cats = {{name = &quot;preposition inflection-table&quot;, sort = {
			{&quot;infl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;decl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;preposition%-(.*)&quot;, &quot;%1&quot;},
			{&quot;prep%-(.*)&quot;, &quot;%1&quot;},
			-- put this twice to catch prep-decl-* and decl-prep-*
			{&quot;infl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;decl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;preposition&quot;, &quot;*&quot;},
			{&quot;prep&quot;, &quot;*&quot;},
			{&quot;prepdecl%-base%-(.*)&quot;, &quot; %1&quot;},
			{&quot;prepdecl%-base&quot;, &quot; &quot;},
			{&quot;prepdecl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;prepdecl&quot;, &quot;*&quot;},
			{&quot;prepinfl%-base%-(.*)&quot;, &quot; %1&quot;},
			{&quot;prepinfl%-base&quot;, &quot; &quot;},
			{&quot;prepinfl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;prepinfl&quot;, &quot;*&quot;},
		}}},
	}},
	{&quot;postposition inflection-table&quot;, {
		aliases = {&quot;postpinfl&quot;, &quot;postpdecl&quot;},
		cats = {{name = &quot;postposition inflection-table&quot;, sort = {
			{&quot;infl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;decl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;postposition%-(.*)&quot;, &quot;%1&quot;},
			{&quot;postp%-(.*)&quot;, &quot;%1&quot;},
			{&quot;post%-(.*)&quot;, &quot;%1&quot;},
			-- put this twice to catch postp-decl-* and decl-postp-*
			{&quot;infl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;decl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;postposition&quot;, &quot;*&quot;},
			{&quot;postp&quot;, &quot;*&quot;},
			{&quot;post&quot;, &quot;*&quot;},
			{&quot;postpdecl%-base%-(.*)&quot;, &quot; %1&quot;},
			{&quot;postpdecl%-base&quot;, &quot; &quot;},
			{&quot;postpdecl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;postpdecl&quot;, &quot;*&quot;},
			{&quot;postpinfl%-base%-(.*)&quot;, &quot; %1&quot;},
			{&quot;postpinfl%-base&quot;, &quot; &quot;},
			{&quot;postpinfl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;postpinfl&quot;, &quot;*&quot;},
		}}},
	}},
	{&quot;adjective inflection-table&quot;, {
		aliases = {&quot;adjinfl&quot;, &quot;adjdecl&quot;, &quot;adecl&quot;},
		cats = {{name = &quot;adjective inflection-table&quot;, sort = {
			{&quot;infl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;decl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;adj%-(.*)&quot;, &quot;%1&quot;},
			{&quot;adjective%-(.*)&quot;, &quot;%1&quot;},
			-- put this twice to catch adj-decl-* and decl-adj-*
			{&quot;infl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;decl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;adj&quot;, &quot;*&quot;},
			{&quot;adjective&quot;, &quot;*&quot;},
			{&quot;adecl%-base%-(.*)&quot;, &quot; %1&quot;},
			{&quot;adecl%-base&quot;, &quot; &quot;},
			{&quot;adecl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;adecl&quot;, &quot;*&quot;},
		}}},
	}},
	{&quot;numeral inflection-table&quot;, {
		aliases = {&quot;numinfl&quot;, &quot;numdecl&quot;},
		cats = {{name = &quot;numeral inflection-table&quot;, sort = {
			{&quot;infl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;decl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;numeral%-(.*)&quot;, &quot;%1&quot;},
			{&quot;number%-(.*)&quot;, &quot;%1&quot;},
			{&quot;num%-(.*)&quot;, &quot;%1&quot;},
			-- put this twice to catch num-decl-* and decl-num-*
			{&quot;infl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;decl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;numeral&quot;, &quot;*&quot;},
			{&quot;number&quot;, &quot;*&quot;},
			{&quot;num&quot;, &quot;*&quot;},
			{&quot;numdecl%-base%-(.*)&quot;, &quot; %1&quot;},
			{&quot;numdecl%-base&quot;, &quot; &quot;},
			{&quot;numdecl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;numdecl&quot;, &quot;*&quot;},
		}}},
	}},
	{&quot;nominal inflection-table&quot;, {
		aliases = {&quot;nominfl&quot;, &quot;nomdecl&quot;},
		cats = {{name = &quot;nominal inflection-table&quot;, sort = {
			{&quot;infl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;decl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;nominal%-(.*)&quot;, &quot;%1&quot;},
			{&quot;nom%-(.*)&quot;, &quot;%1&quot;},
			-- put this twice to catch nom-decl-* and decl-nom-*
			{&quot;infl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;decl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;nominal&quot;, &quot;*&quot;},
			{&quot;nom&quot;, &quot;*&quot;},
			{&quot;nomdecl%-base%-(.*)&quot;, &quot; %1&quot;},
			{&quot;nomdecl%-base&quot;, &quot; &quot;},
			{&quot;nomdecl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;nomdecl&quot;, &quot;*&quot;},
		}}},
	}},
	{&quot;verb inflection-table&quot;, {
		aliases = {&quot;verbinfl&quot;, &quot;conj&quot;},
		cats = {{name = &quot;verb inflection-table&quot;, sort = {
			{&quot;infl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;verb%-(.*)&quot;, &quot;%1&quot;},
			-- put this twice to catch verb-infl-* and infl-verb-*
			{&quot;infl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;conj%-base%-(.*)&quot;, &quot; %1&quot;},
			{&quot;conj%-base&quot;, &quot; &quot;},
			-- handle conj2, conj1-c, etc.
			{&quot;conj%-?(.*)&quot;, &quot;%1&quot;},
			{&quot;conj&quot;, &quot;*&quot;},
		}}},
	}},
	{&quot;adverb inflection-table&quot;, {
		aliases = {&quot;advinfl&quot;},
		cats = {{name = &quot;adverb inflection-table&quot;, sort = {
			{&quot;infl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;decl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;adverb%-(.*)&quot;, &quot;%1&quot;},
			{&quot;adv%-(.*)&quot;, &quot;%1&quot;},
			-- put this twice to catch adv-decl-* and decl-adv-*
			{&quot;infl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;decl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;adverb&quot;, &quot;*&quot;},
			{&quot;adv&quot;, &quot;*&quot;},
			{&quot;advinfl%-base%-(.*)&quot;, &quot; %1&quot;},
			{&quot;advinfl%-base&quot;, &quot; &quot;},
			{&quot;advinfl%-(.*)&quot;, &quot;%1&quot;},
			{&quot;advinfl&quot;, &quot;*&quot;},
		}}},
	}},

	-- Inflection-table subtemplates
	{&quot;inflection-table sub&quot;, {
		aliases = {&quot;inflsub&quot;},
		cats = {&quot;label:inflection-table subtemplates&quot;},
	}},

	-- Definition templates
	-- Headword-line templates
	{&quot;headword-line&quot;, {
		aliases = {&quot;hw&quot;, &quot;headword&quot;},
		cats = {&quot;baris pengepala kata&quot;},
	}},

	-- Definition templates
	{&quot;definition&quot;, {
		aliases = {&quot;def&quot;, &quot;defn&quot;},
		cats = {&quot;takrifan&quot;},
	}},
	{&quot;form-of&quot;, {
		aliases = {&quot;form of&quot;},
		cats = {&quot;bentuk bagi&quot;},
	}},

	-- Etymology and pronunciation templates
	{&quot;etymology&quot;, {
		aliases = {&quot;etym&quot;},
		cats = {&quot;etimologi&quot;},
	}},
	{&quot;morphology&quot;, {
		aliases = {&quot;morph&quot;},
		cats = {&quot;etimologi&quot;, &quot;Kategori:Templat morfologi khusus bahasa&quot;},
	}},
	{&quot;pronunciation&quot;, {
		aliases = {&quot;pron&quot;},
		cats = {&quot;sebutan&quot;},
	}},
	{&quot;sign production&quot;, {
		aliases = {&quot;signprod&quot;},
		cats = {{name = &quot;sign production&quot;, sort = {
			{&quot;prod (.*)&quot;, &quot;%1&quot;},
		}}},
	}},

	-- Pseudo-namespace templates
	{&quot;reference&quot;, {
		aliases = {&quot;ref&quot;},
		cats = {{name = &quot;rujukan&quot;, allow_etym = true}},
	}},
	{&quot;quotation&quot;, {
		aliases = {&quot;quote&quot;},
		cats = {&quot;petikan&quot;},
	}},
	{&quot;usage&quot;, {
		cats = {&quot;penggunaan&quot;},
	}},
	{&quot;list&quot;, {
		cats = {&quot;senarai&quot;},
	}},
	{&quot;auto-table&quot;, {
		aliases = {&quot;table&quot;},
		cats = {&quot;jadual automatik&quot;},
	}},

	-- Navigation templates
	
	-- Pro-form box templates
	{&quot;pro-form&quot;, {
		aliases = {&quot;pro-forms&quot;},
		cats = {&quot;navigasi&quot;, &quot;Kategori:Templat kotak pro-bentuk&quot;},
	}},
	{&quot;adposition&quot;, {
		aliases = {&quot;adpositions&quot;, &quot;preposition&quot;, &quot;prepositions&quot;, &quot;postposition&quot;, &quot;postpositions&quot;},
		cats = {&quot;navigasi&quot;, &quot;Kategori:Templat kotak adposisi&quot;},
	}},
	{&quot;affix&quot;, {
		aliases = {&quot;affixes&quot;, &quot;prefix&quot;, &quot;prefixes&quot;, &quot;suffix&quot;, &quot;suffixes&quot;},
		cats = {&quot;navigasi&quot;, &quot;Kategori:Templat kotak imbuhan pro-bentuk&quot;},
	}},
	{&quot;article&quot;, {
		aliases = {&quot;articles&quot;},
		cats = {&quot;navigasi&quot;, &quot;Category:Grammatical article box templates&quot;},
	}},
	{&quot;demonstrative&quot;, {
		aliases = {&quot;demonstratives&quot;},
		cats = {&quot;navigasi&quot;, &quot;Category:Demonstrative box templates&quot;},
	}},
	{&quot;interrogative&quot;, {
		aliases = {&quot;interrogatives&quot;},
		cats = {&quot;navigasi&quot;, &quot;Category:Interrogative box templates&quot;},
	}},
	{&quot;personal pronoun&quot;, {
		aliases = {&quot;perspron&quot;, &quot;personal pronouns&quot;},
		cats = {&quot;navigasi&quot;, &quot;Category:Personal pronoun box templates&quot;},
	}},
	{&quot;possessive&quot;, {
		aliases = {&quot;possessives&quot;},
		cats = {&quot;navigasi&quot;, &quot;Category:Possessive pronoun and determiner box templates&quot;},
	}},
	{&quot;reflexive&quot;, {
		aliases = {&quot;reflexives&quot;},
		cats = {&quot;navigasi&quot;, &quot;Category:Reflexive pronoun and determiner box templates&quot;},
	}},
	{&quot;relative&quot;, {
		aliases = {&quot;relatives&quot;},
		cats = {&quot;navigasi&quot;, &quot;Category:Relative pronoun and determiner box templates&quot;},
	}},
	{&quot;navigation&quot;, {
		-- miscellaneous navigation box templates like {{eu-aux verbs}}, {{pt-forms of address}}
		aliases = {&quot;nav&quot;},
		cats = {&quot;navigasi&quot;},
	}},
	{&quot;TOC&quot;, {
		cats = {{name = &quot;navigation&quot;, sort = {
			{&quot;categoryTOC&quot;, &quot;TOC&quot;},
		}}, &quot;Kategori:Templat TOC&quot;},
	}},
	{&quot;number&quot;, {
		aliases = {&quot;numbers&quot;},
		cats = {&quot;navigasi&quot;, &quot;Kategori:Templat nombor khusus bahasa&quot;},
	}},
	{&quot;cardinal&quot;, {
		aliases = {&quot;cardinals&quot;},
		cats = {&quot;navigasi&quot;, &quot;Kategori:Templat nombor khusus bahasa&quot;},
	}},
	{&quot;ordinal&quot;, {
		aliases = {&quot;ordinals&quot;},
		cats = {&quot;navigasi&quot;, &quot;Kategori:Templat nombor khusus bahasa&quot;},
	}},
	{&quot;digit&quot;, {
		aliases = {&quot;digits&quot;},
		cats = {&quot;senarai&quot;, &quot;Kategori:Templat nombor khusus bahasa&quot;},
	}},

	-- Entry templates
	{&quot;entry&quot;, {
		cats = {&quot;kata masukan&quot;},
	}},

	-- Orthographic conversion templates (e.g. for converting between scripts)
	{&quot;orthographic conversion&quot;, {
		aliases = {&quot;transliteration&quot;, &quot;translit&quot;, &quot;xlit&quot;, &quot;orthconv&quot;, &quot;scriptconv&quot;},
		cats = {&quot;pertukaran&quot;, &quot;Kategori:Templat pertukaran ortografi&quot;},
	}},

	-- Orthographic and regional variant templates (for displaying orthographic, script and/or regional variants)
	{&quot;orthographic variant&quot;, {
		aliases = {&quot;orthvar&quot;, &quot;scriptvar&quot;},
		-- Currently we categorize orthographic and regional variants the same but we could split them if needed
		cats = {&quot;navigasi&quot;, &quot;Kategori:Templat kelainan ortografi dan setempat&quot;},
	}},
	{&quot;regional variant&quot;, {
		aliases = {&quot;regvar&quot;},
		cats = {&quot;navigasi&quot;, &quot;Kategori:Templat kelainan ortografi dan setempat&quot;},
	}},

	-- Internal link templates
	{&quot;link&quot;, {
		cats = {&quot;pautan&quot;, &quot;Kategori:Templat pautan dalaman khusus bahasa&quot;},
	}},
}

local category_type_to_category_map = {}

for _, category_type_to_category_spec in ipairs(category_type_to_category) do
	local category_type, props = unpack(category_type_to_category_spec)
	category_type_to_category_map[category_type] = props
	if props.aliases then
		for _, alias in ipairs(props.aliases) do
			category_type_to_category_map[alias] = props
		end
	end
end

-- Split an argument on comma, but not comma followed by whitespace; split off sort base after a colon.
local function split_on_comma_and_split_off_sort_base(val)
	local cattypes
	if val:find(&quot;,&quot;) then
		-- Don't optimize more than this because there can be commas backslashed, inside of links or followed by
		-- whitespace that don't cause splitting.
		cattypes = require(parse_interface_module).split_on_comma(val)
	else
		cattypes = {val}
	end
	for i, cattype_spec in ipairs(cattypes) do
		if cattype_spec:find(&quot;:&quot;) then
			local cattype, sort_base = cattype_spec:match(&quot;^(.-):(.*)$&quot;)
			sort_base = sort_base:gsub(&quot;_&quot;, &quot; &quot;)
			cattypes[i] = {name = cattype, sort_base = sort_base}
		end
	end
	return cattypes
end

local function get_lang_or_script(code)
	return code == &quot;-&quot; and code or
		require(&quot;Module:languages&quot;).getByCode(code, nil, &quot;allow etym&quot;) or
		require(&quot;Module:languages&quot;).getByCode(code .. &quot;-pro&quot;, nil, &quot;allow etym&quot;) or
		require(&quot;Module:scripts&quot;).getByCode(code)
end

local function obj_code(obj)
	if obj == &quot;-&quot; then
		return obj
	end
	return obj:getCode()
end

local function get_prefixed_obj(after_prefix)
	return after_prefix:match(&quot;^(%a[%a-]*%a):(.+)$&quot;)
end

local function get_suffixed_obj(after_prefix)
	local rest, objcode = after_prefix:match(&quot;^(.+)/(%a[%a-]*%a)$&quot;)
	return objcode, rest
end

local pseudo_namespace_templates = {
	{&quot;R:&quot;, {
		category_type = &quot;rujukan&quot;,
		get_obj_and_rest = get_prefixed_obj,
	}},
	{&quot;RQ:&quot;, {
		category_type = &quot;petikan&quot;,
		get_obj_and_rest = get_prefixed_obj,
	}},
	{&quot;U:&quot;, {
		category_type = &quot;penggunaan&quot;,
		get_obj_and_rest = get_prefixed_obj,
	}},
	{&quot;list:&quot;, {
		category_type = &quot;senarai&quot;,
		get_obj_and_rest = get_suffixed_obj,
	}},
	{&quot;table:&quot;, {
		category_type = &quot;jadual automatik&quot;,
		get_obj_and_rest = get_suffixed_obj,
	}},
}

local function infer_lang_or_script_code_and_category_type(name)
	if name:find(&quot;:&quot;) then -- only check for pseudo-namespace prefix when a colon is present
		for _, pseudo_namespace_spec in ipairs(pseudo_namespace_templates) do
			local prefix, props = unpack(pseudo_namespace_spec)
			local after_prefix = name:match(&quot;^&quot; .. prefix .. &quot;(.+)$&quot;)
			if after_prefix then
				local objcode, rest = props.get_obj_and_rest(after_prefix)
				local obj
				if objcode then
					obj = get_lang_or_script(objcode) -- may return nil
					if not obj then
						rest = after_prefix
					end
				else
					rest = after_prefix
				end
				return obj, rest, props.category_type
			end
		end
	end

	local hyphen_parts = split(name, &quot;%-&quot;)
	for i = #hyphen_parts - 1, 1, -1 do
		local code = concat(hyphen_parts, &quot;-&quot;, 1, i)
		local obj = get_lang_or_script(code)
		if obj then
			local rest = concat(hyphen_parts, &quot;-&quot;, i + 1)
			return obj, rest, nil
		end
	end
	return nil, name, nil
end

local function process_sortbase_specs(sortbase, specs)
	for _, spec in ipairs(specs) do
		local from, to = unpack(spec)
		sortbase = ugsub(sortbase, &quot;^&quot; .. from .. &quot;$&quot;, to)
	end
	return sortbase
end

local function template_name_minus_langcode_to_category_type(name)
	for _, type_spec in ipairs(detect_category_type_list) do
		local pattern, intended_type = unpack(type_spec)
		if ufind(name, &quot;^&quot; .. pattern .. &quot;$&quot;) then
			return intended_type
		end
	end
	return nil
end

local function compute_categories_for_template(full_template_name, template_name_minus_langcode, category_type,
	langs_or_scripts)
	local overriding_sort_base
	if type(category_type) == &quot;table&quot; then
		overriding_sort_base = category_type.sort_base
		category_type = category_type.name
	end
	if not category_type_to_category_map[category_type] then
		error(&quot;Unrecognized template category type: &quot; .. category_type)
	end
	local props = category_type_to_category_map[category_type]
	if not props.cats then
		error(&quot;Internal error: No categories given for category type: &quot; .. category_type)
	end
	local categories = {}
	for _, catspec in ipairs(props.cats) do
		if type(catspec) == &quot;string&quot; then
			catspec = {name = catspec}
		end
		local rawcat = catspec.name:match(&quot;^Kategori:(.*)&quot;)
		if rawcat then
			local sortbase
			-- User-specified sort base does not apply to raw categories, which have a different sort key format
			-- than language-specific categories.
			if not catspec.sort then
				if langs_or_scripts then
					local langnames = {}
					for _, lang_or_sc in ipairs(langs_or_scripts) do
						insert(langnames, lang_or_sc:getCanonicalName()) -- FIXME: or lang:getFullName()?
					end
					sortbase = concat(langnames, &quot;,&quot;)
				else
					sortbase = full_template_name
				end
			elseif is_callable(catspec.sort) then
				sortbase = catspec.sort(full_template_name, langs_or_scripts)
			else
				sortbase = process_sortbase_specs(full_template_name, catspec.sort)
			end
			insert(categories, {cat = rawcat, lang = und_lang, sort_base = sortbase})
		elseif langs_or_scripts then
			for _, lang_or_sc in ipairs(langs_or_scripts) do
				local sortbase
				if overriding_sort_base then
					sortbase = overriding_sort_base
				elseif not catspec.sort then
					sortbase = template_name_minus_langcode
				elseif is_callable(catspec.sort) then
					sortbase = catspec.sort(template_name_minus_langcode, lang_or_sc)
				else
					sortbase = process_sortbase_specs(template_name_minus_langcode, catspec.sort)
				end
				if lang_or_sc:hasType(&quot;script&quot;) then
					insert(categories, {
						cat = (&quot;Templat %s&quot;):format(lang_or_sc:getCategoryName()), lang = und_lang, sc = lang_or_sc,
						sort_base = sortbase,
					})
				else
					local cat
					local full_label = catspec.name:match(&quot;^label:(.*)$&quot;)
					local lang_name = catspec.allow_etym and lang_or_sc:getCanonicalName() or lang_or_sc:getFullName()
					if full_label then
						cat = (&quot;%s bahasa %s&quot;):format(full_label, lang_name)
					else
						cat = (&quot;Templat %s bahasa %s&quot;):format(catspec.name, lang_name)
					end
					insert(categories, {
						cat = cat, lang = lang_or_sc:getFull(), sort_base = sortbase,
					})
				end
			end
		end
	end
	if not categories[1] then
		error((&quot;No categories generated for template [[Template:%s]] with category type '%s'&quot;):format(
			full_template_name, category_type))
	end

	return categories
end

--[==[
Main entry point.
]==]
function export.categorize(frame)
	local params = {
		[1] = {}, -- comma-separated list of category types; by default, inferred from template name
		lang = {}, -- comma-separated list of languages; by default, inferred from template name
		[&quot;pagename&quot;] = {}, -- for testing
		[&quot;json&quot;] = {type = &quot;boolean&quot;}, -- for testing
	}

	local parent_args = frame:getParent().args
	args = require(&quot;Module:parameters&quot;).process(parent_args, params)
	local category_specs = {}

	local function insert_cat(cat, sort_key)
		for _, existing_cat in ipairs(category_specs) do
			if existing_cat.cat == cat then
				return
			end
		end
		insert(category_specs, {cat = cat, sort_key = sort_key})
	end

	local pagename = args.pagename
	if not pagename then
		title = mw.title.getCurrentTitle()
		pagename = title.fullText
	end

	if pagename:find(&quot;/doc$&quot;) or pagename:find(&quot;/doc/&quot;) then
		return &quot;&quot;
	end

	if pagename:find(&quot;^Templat:Pengguna:&quot;) then
		insert_cat(&quot;Templat kotak pasir pengguna&quot;, (pagename:gsub(&quot;^Templat:Pengguna:&quot;, &quot;&quot;)))
	elseif pagename:find(&quot;^Pengguna:&quot;) then
		insert_cat(&quot;Templat kotak pasir pengguna&quot;, (pagename:gsub(&quot;^Pengguna:&quot;, &quot;&quot;)))
	else
		if not pagename:find(&quot;^Templat:&quot;) then
			error((&quot;This template should only be used in the Template namespace, not on page '%s'&quot;):format(pagename))
		end
		local full_template_name = pagename:gsub(&quot;^Templat:&quot;, &quot;&quot;)
		local rootpage = full_template_name:gsub(&quot;/.*&quot;, &quot;&quot;)
		if full_template_name:find(&quot;/sandbox&quot;) then
			insert_cat(&quot;Templat kotak pasir&quot;, full_template_name)
		elseif full_template_name:find(&quot;^sandbox/&quot;) then
			insert_cat(&quot;Templat kotak pasir&quot;, full_template_name:gsub(&quot;^sandbox/&quot;, &quot;&quot;))
		else
			local template_objs
			if args.lang == &quot;-&quot; then
				template_objs = false
			elseif args.lang then
				template_objs = {}
				for _, code in ipairs(split(args.lang, &quot;,&quot;)) do
					-- We need to have an indicator of families because we allow bare family codes to stand for proto-languages.
					if code:find(&quot;^fam:&quot;) then
						code = code:gsub(&quot;^fam:&quot;, &quot;&quot;)
						local family = require(&quot;Module:families&quot;).getByCode(code) or
							error((&quot;Unrecognized family code '%s' in [[Module:template cat]]&quot;):format(code))
						local descendants = family:getDescendantCodes()
						for _, desc in ipairs(descendants) do
							local obj = get_lang_or_script(desc)
							if obj then
								-- make sure we skip families without proto-languages
								insert(template_objs, obj)
							end
						end
					else
						local obj = get_lang_or_script(code)
						if not obj then
							error((&quot;Unrecognized language or script code '%s'&quot;):format(code))
						end
						insert(template_objs, obj)
					end
				end
			end

			local cattypes
			if args[1] then
				cattypes = split_on_comma_and_split_off_sort_base(args[1])
			end

			local inferred_obj, inferred_rest, inferred_cattype =
				infer_lang_or_script_code_and_category_type(rootpage)
			if template_objs == nil or not cattypes then
				if template_objs == nil then
					if not inferred_obj then
						if not inferred_cattype then
							error((&quot;Unable to infer language or script from template root page '%s' for template '%s'; specify lang/script and type explicitly&quot;):format(
								rootpage, pagename))
						else
							error((&quot;Unable to infer language or script from template root page '%s' for template '%s', inferred category type '%s'; specify lang/script explicitly&quot;):format(
								rootpage, pagename, inferred_cattype))
						end
					else
						template_objs = {inferred_obj}
					end
				end
				if not cattypes then
					inferred_cattype = inferred_cattype or
						template_name_minus_langcode_to_category_type(inferred_rest)
					if not inferred_cattype then
						error((&quot;Unable to infer template category type from template remainder (after stripping langcode) '%s' for template '%s'; specify type explicitly&quot;):format(
							inferred_rest, pagename))
					end
					cattypes = {inferred_cattype}
				end
			end

			for _, cattype in ipairs(cattypes) do
				local cats = compute_categories_for_template(full_template_name, inferred_rest, cattype, template_objs)
				for _, cat in ipairs(cats) do
					insert(category_specs, cat)
				end
			end
		end
	end

	-- We are returning categories for templates or user-space pages, so we need to force the output.
	local retval = format_categories(category_specs, nil, nil, nil, &quot;force_output&quot;)
	if args.json then
		return require(&quot;Module:JSON&quot;).toJSON {
			category_specs = category_specs,
			retval = mw.text.nowiki(retval),
		}
	else
		return retval
	end
end

--[==[Table used in the documentation to {{tl|template cat}}.]==]
function export.pattern_to_category_type_table()
	local parts = {}
	local function ins(text)
		insert(parts, text)
	end
	ins('{|class=&quot;wikitable&quot;')
	ins(&quot;! Corak !! Jenis kategori terinferensi&quot;)
	for _, detect_spec in ipairs(detect_category_type_list) do
		local pattern, category_type = unpack(detect_spec)
		ins(&quot;|-&quot;)
		ins((&quot;| &lt;code&gt;%s&lt;/code&gt; || &lt;code&gt;%s&lt;/code&gt;&quot;):format(pattern, category_type))
	end
	ins(&quot;|}&quot;)
	return concat(parts, &quot;\n&quot;)
end

--[==[Table used in the documentation to {{tl|template cat}}.]==]
function export.category_type_to_category_table()
	local parts = {}
	local function ins(text)
		insert(parts, text)
	end
	local category_types = {}
	local category_type_to_aliases = {}

	for _, category_type_to_category_spec in ipairs(category_type_to_category) do
		local category_type, props = unpack(category_type_to_category_spec)
		insert(category_types, category_type)
		category_type_to_aliases[category_type] = {}
		if props.aliases then
			for _, alias in ipairs(props.aliases) do
				insert(category_type_to_aliases[category_type], alias)
			end
			table.sort(category_type_to_aliases[category_type])
		end
	end
	table.sort(category_types)

	local function get_category_type_categories(category_type)
		local cats = {}
		for _, catspec in ipairs(category_type_to_category_map[category_type].cats) do
			if type(catspec) == &quot;string&quot; then
				catspec = {name = catspec}
			end
			local cat = catspec.name
			if cat:find(&quot;^Kategori:&quot;) then
				insert(cats, (&quot;&lt;code&gt;%s&lt;/code&gt;&quot;):format((cat:gsub(&quot;^Kategori:&quot;, &quot;&quot;))))
			elseif cat:find(&quot;^label:&quot;) then
				insert(cats, (&quot;&lt;code&gt;&lt;var&gt;LANG&lt;/var&gt; %s&lt;/code&gt;&quot;):format((cat:gsub(&quot;^label:&quot;, &quot;&quot;))))
			else
				insert(cats, (&quot;&lt;code&gt;&lt;var&gt;LANG&lt;/var&gt; %s templates&lt;/code&gt;&quot;):format(cat))
			end
		end
		return concat(cats, &quot;, &quot;)
	end

	ins('{|class=&quot;wikitable&quot;')
	ins(&quot;! Jenis kategori !! Jenis kategori berkanun !! Kategori&quot;)
	for _, category_type in ipairs(category_types) do
		ins(&quot;|-&quot;)
		ins((&quot;| &lt;code&gt;'''%s'''&lt;/code&gt; || ''(same)'' || &lt;code&gt;%s&lt;/code&gt;&quot;):format(
			category_type, get_category_type_categories(category_type)))
		for _, alias in ipairs(category_type_to_aliases[category_type]) do
			ins(&quot;|-&quot;)
			ins((&quot;| &lt;code&gt;%s&lt;/code&gt; || &lt;code&gt;'''%s'''&lt;/code&gt; || &lt;code&gt;%s&lt;/code&gt;&quot;):format(
				alias, category_type, get_category_type_categories(category_type)))
		end
	end
	ins(&quot;|}&quot;)
	return concat(parts, &quot;\n&quot;)
end

return export</text>
      <sha1>0ff5hjaygssgnrmwqbpo1g4fnx1ce30</sha1>
    </revision>
  </page>
  <page>
    <title>Kategori:ar:Bulan kalendar Masihi</title>
    <ns>14</ns>
    <id>118624</id>
    <redirect title="Kategori:ar:Bulan takwim Masihi" />
    <revision>
      <id>342801</id>
      <timestamp>2026-05-16T12:28:39Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <comment>Hakimi97 telah memindahkan laman [[Kategori:ar:Bulan kalendar Masihi]] ke [[Kategori:ar:Bulan takwim Masihi]]: Tajuk salah eja</comment>
      <origin>342801</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="45" sha1="6mynv8thv7j6wd18unqctgih53zjwzz" xml:space="preserve">#LENCONG [[:Kategori:ar:Bulan takwim Masihi]]</text>
      <sha1>6mynv8thv7j6wd18unqctgih53zjwzz</sha1>
    </revision>
  </page>
  <page>
    <title>Kategori:en:Bulan kalendar Masihi</title>
    <ns>14</ns>
    <id>118625</id>
    <redirect title="Kategori:en:Bulan takwim Masihi" />
    <revision>
      <id>342811</id>
      <timestamp>2026-05-16T12:36:13Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <comment>Hakimi97 telah memindahkan laman [[Kategori:en:Bulan kalendar Masihi]] ke [[Kategori:en:Bulan takwim Masihi]]: Tajuk salah eja</comment>
      <origin>342811</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="45" sha1="nap3daw8rypybqp7h9hr34fl0dod9v2" xml:space="preserve">#LENCONG [[:Kategori:en:Bulan takwim Masihi]]</text>
      <sha1>nap3daw8rypybqp7h9hr34fl0dod9v2</sha1>
    </revision>
  </page>
  <page>
    <title>Kategori:af:bulan kalendar Masihi</title>
    <ns>14</ns>
    <id>118626</id>
    <redirect title="Kategori:af:Bulan takwim Masihi" />
    <revision>
      <id>342814</id>
      <timestamp>2026-05-16T12:37:42Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <comment>Hakimi97 telah memindahkan laman [[Kategori:af:bulan kalendar Masihi]] ke [[Kategori:af:Bulan takwim Masihi]]</comment>
      <origin>342814</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="45" sha1="aql0dtizg44gdobr01lbzuiycwmzm02" xml:space="preserve">#LENCONG [[:Kategori:af:Bulan takwim Masihi]]</text>
      <sha1>aql0dtizg44gdobr01lbzuiycwmzm02</sha1>
    </revision>
  </page>
  <page>
    <title>Modul:etymon/data</title>
    <ns>828</ns>
    <id>118627</id>
    <revision>
      <id>342817</id>
      <timestamp>2026-05-16T13:38:28Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <comment>Mencipta laman baru dengan kandungan 'local export = {}  export.STATUS = { 	OK = &quot;ok&quot;, 	INLINE = &quot;inline&quot;, 	MISSING = &quot;missing&quot;, 	REDLINK = &quot;redlink&quot;, 	AMBIGUOUS = &quot;ambiguous&quot;, }  export.TRANSITIVE = { 	ALWAYS = &quot;always&quot;,                                            -- always recurse into children 	NEVER = &quot;never&quot;,                                              -- never recurse into children 	CROSS_LANG = &quot;cross_lang&quot;,                                    -- only recurse when source lang differs...'</comment>
      <origin>342817</origin>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="15269" sha1="en6z2me7ggveh5mllhfh8xeo89dolmh" xml:space="preserve">local export = {}

export.STATUS = {
	OK = &quot;ok&quot;,
	INLINE = &quot;inline&quot;,
	MISSING = &quot;missing&quot;,
	REDLINK = &quot;redlink&quot;,
	AMBIGUOUS = &quot;ambiguous&quot;,
}

export.TRANSITIVE = {
	ALWAYS = &quot;always&quot;,                                            -- always recurse into children
	NEVER = &quot;never&quot;,                                              -- never recurse into children
	CROSS_LANG = &quot;cross_lang&quot;,                                    -- only recurse when source lang differs from target lang (but pos chain continues)
	CROSS_LANG_NO_INTERNAL_SOURCE = &quot;cross_lang_no_internal_source&quot;, -- like CROSS_LANG, but source breaks for internal derivations in the same language context
}

-- Deep merge tables (nested tables are merged recursively, later values override earlier)
local function deep_merge(...)
	local result = {}
	for _, t in ipairs({ ... }) do
		for k, v in pairs(t) do
			if type(v) == &quot;table&quot; and type(result[k]) == &quot;table&quot; then
				result[k] = deep_merge(result[k], v)
			else
				result[k] = v
			end
		end
	end
	return result
end

local function make_glossary_link(term, display_text)
	if not term then return display_text end
	return &quot;[[Appendix:Glossary#&quot; .. term:gsub(&quot; &quot;, &quot;_&quot;) .. &quot;|&quot; .. display_text .. &quot;]]&quot;
end

-- Extract base word and connector from text like &quot;Borrowed from&quot; or &quot;calque of&quot;
local function split_glossary_text(text)
	for _, pattern in ipairs({ &quot;^(.-)(%s+[Oo][Ff])$&quot;, &quot;^(.-)(%s+[Ff][Rr][Oo][Mm])$&quot; }) do
		local base, rest = text:match(pattern)
		if base then return base, rest end
	end
	return text, &quot;&quot;
end

local TRANSITIVE = export.TRANSITIVE

local function create_keyword(opts)
	local entry = {
		is_group = opts.is_group or false,
		abbrev = opts.abbrev,
		glossary = opts.glossary,

		transitive = opts.transitive or TRANSITIVE.ALWAYS, -- default &quot;always&quot;
		inherited_chain = opts.inherited_chain or false,
		affix_categories = opts.affix_categories or false,
		borrowing_type = opts.borrowing_type,
		specialized_borrowing = opts.specialized_borrowing,
		toplevel_category = opts.toplevel_category,
		no_child_categories = opts.no_child_categories or false,
		source_category_type = opts.source_category_type,
		invisible = (opts.invisible == true and &quot;all&quot;) or opts.invisible or false,
		pos_override = opts.pos_override,
		new_sentence = opts.new_sentence or false,
		separate_clause = opts.separate_clause or false,
		aliases = opts.aliases,
	}

	-- Only set text/phrase when visible in text (invisible ~= &quot;all&quot; and ~= &quot;text&quot;)
	local inv = entry.invisible
	if inv ~= &quot;all&quot; and inv ~= &quot;text&quot; then
		entry.phrase = opts.phrase
		if opts.text then
			if opts.glossary then
				local base_word, rest = split_glossary_text(opts.text)
				entry.text = make_glossary_link(opts.glossary, base_word) .. rest
			else
				entry.text = opts.text
			end
		end
	end

	return entry
end

-- Shared defaults for keyword groups
local DEFAULTS = {
	-- Keywords that pass through inheritance chain
	inheritance = {
		transitive = TRANSITIVE.ALWAYS,
		inherited_chain = true,
	},
	-- Standard transitive derivation
	transitive = {
		transitive = TRANSITIVE.ALWAYS,
	},
	-- Standard for internal derivations: transitive across languages, but not within them
	internal_derivation = {
		transitive = TRANSITIVE.CROSS_LANG,
	},
	-- Borrowing keywords
	borrowing = {
		transitive = TRANSITIVE.ALWAYS,
	},
	-- Affix group keywords (compound words, blends, etc.)
	affix_group = {
		is_group = true,
		transitive = TRANSITIVE.CROSS_LANG,
		affix_categories = true,
	},
	-- Calque-like keywords (calque, partial calque, semantic loan)
	calque_like = {
		transitive = TRANSITIVE.NEVER,
		no_child_categories = true,
		new_sentence = true,
	},
	-- Non-transitive influence
	influence_like = {
		transitive = TRANSITIVE.NEVER,
		no_child_categories = true,
	},
}

export.keywords = {
	--
	-- Inheritance keywords
	--
	[&quot;from&quot;] = create_keyword(deep_merge(DEFAULTS.inheritance, {
		text = &quot;From&quot;, phrase = &quot;from&quot;,
	})),
	[&quot;inherited&quot;] = create_keyword(deep_merge(DEFAULTS.inheritance, {
		text = &quot;Inherited from&quot;,
		phrase = &quot;from&quot;,
		glossary = &quot;inherited&quot;,
		aliases = { &quot;inh&quot; },
	})),

	--
	-- Basic derivation keywords
	--
	[&quot;uder&quot;] = create_keyword(deep_merge(DEFAULTS.transitive, {
		text = &quot;From&quot;,
		phrase = &quot;from&quot;,
		toplevel_category = &quot;undefined derivations&quot;,
	})),
	[&quot;derived&quot;] = create_keyword(deep_merge(DEFAULTS.transitive, {
		text = &quot;Derived from&quot;,
		phrase = &quot;from&quot;,
		abbrev = &quot;der.&quot;,
		glossary = &quot;derived terms&quot;,
		aliases = { &quot;der&quot; },
	})),

	--
	-- Affix/compound group keywords
	--
	[&quot;affix&quot;] = create_keyword(deep_merge(DEFAULTS.affix_group, {
		text = &quot;From&quot;,
		phrase = &quot;from&quot;,
		aliases = { &quot;af&quot; },
	})),
	[&quot;surf&quot;] = create_keyword(deep_merge(DEFAULTS.affix_group, {
		text = &quot;By surface analysis,&quot;,
		phrase = &quot;by surface analysis,&quot;,
		abbrev = &quot;surf.&quot;,
		glossary = &quot;surface analysis&quot;,
		new_sentence = true,
		invisible = &quot;tree&quot;,
	})),
	[&quot;blend&quot;] = create_keyword(deep_merge(DEFAULTS.affix_group, {
		text = &quot;Blend of&quot;,
		phrase = &quot;a blend of&quot;,
		abbrev = &quot;blend&quot;,
		glossary = &quot;blend&quot;,
		toplevel_category = &quot;blends&quot;,
	})),
	[&quot;univerbation&quot;] = create_keyword(deep_merge(DEFAULTS.affix_group, {
		text = &quot;Univerbation of&quot;,
		phrase = &quot;univerbation of&quot;,
		abbrev = &quot;univ.&quot;,
		glossary = &quot;univerbation&quot;,
		toplevel_category = &quot;univerbations&quot;,
		aliases = { &quot;univ&quot; },
	})),

	--
	-- Borrowing keywords
	--
	[&quot;bor&quot;] = create_keyword(deep_merge(DEFAULTS.borrowing, {
		text = &quot;Borrowed from&quot;,
		phrase = &quot;borrowed from&quot;,
		abbrev = &quot;bor.&quot;,
		glossary = &quot;loanword&quot;,
		borrowing_type = &quot;borrowed&quot;,
		aliases = { &quot;borrowed&quot; },
	})),
	[&quot;lbor&quot;] = create_keyword(deep_merge(DEFAULTS.borrowing, {
		text = &quot;Learned borrowing from&quot;,
		phrase = &quot;a learned borrowing from&quot;,
		abbrev = &quot;lbor.&quot;,
		glossary = &quot;learned borrowing&quot;,
		specialized_borrowing = &quot;learned&quot;,
	})),
	[&quot;obor&quot;] = create_keyword(deep_merge(DEFAULTS.borrowing, {
		text = &quot;Orthographic borrowing from&quot;,
		phrase = &quot;an orthographic borrowing from&quot;,
		abbrev = &quot;obor.&quot;,
		glossary = &quot;orthographic borrowing&quot;,
		specialized_borrowing = &quot;orthographic&quot;,
	})),
	[&quot;slbor&quot;] = create_keyword(deep_merge(DEFAULTS.borrowing, {
		text = &quot;Semi-learned borrowing from&quot;,
		phrase = &quot;a semi-learned borrowing from&quot;,
		abbrev = &quot;slbor.&quot;,
		glossary = &quot;semi-learned borrowing&quot;,
		specialized_borrowing = &quot;semi-learned&quot;,
	})),
	[&quot;ubor&quot;] = create_keyword(deep_merge(DEFAULTS.borrowing, {
		text = &quot;Unadapted borrowing from&quot;,
		phrase = &quot;an unadapted borrowing from&quot;,
		abbrev = &quot;ubor.&quot;,
		glossary = &quot;unadapted borrowing&quot;,
		specialized_borrowing = &quot;unadapted&quot;,
	})),

	--
	-- Calque-like keywords (non-transitive, start new sentence)
	--
	[&quot;calque&quot;] = create_keyword(deep_merge(DEFAULTS.calque_like, {
		text = &quot;Calque of&quot;,
		phrase = &quot;a calque of&quot;,
		abbrev = &quot;calq.&quot;,
		glossary = &quot;calque&quot;,
		specialized_borrowing = &quot;calque&quot;,
		aliases = { &quot;cal&quot;, &quot;clq&quot; },
	})),
	[&quot;partial calque&quot;] = create_keyword(deep_merge(DEFAULTS.calque_like, {
		text = &quot;Partial calque of&quot;,
		phrase = &quot;a partial calque of&quot;,
		abbrev = &quot;pcalq.&quot;,
		glossary = &quot;partial calque&quot;,
		specialized_borrowing = &quot;partial-calque&quot;,
		aliases = { &quot;pcal&quot; },
	})),
	[&quot;semantic loan&quot;] = create_keyword(deep_merge(DEFAULTS.calque_like, {
		text = &quot;Semantic loan of&quot;,
		phrase = &quot;a semantic loan of&quot;,
		abbrev = &quot;sl.&quot;,
		glossary = &quot;semantic loan&quot;,
		specialized_borrowing = &quot;semantic-loan&quot;,
		aliases = { &quot;sl&quot; },
	})),

	--
	-- Influence keywords (non-transitive, separate clause)
	--
	[&quot;influence&quot;] = create_keyword(deep_merge(DEFAULTS.influence_like, {
		text = &quot;Influenced by&quot;,
		phrase = &quot;influenced by&quot;,
		abbrev = &quot;influ.&quot;,
		glossary = &quot;contamination&quot;,
		separate_clause = true,
	})),

	--
	-- Morphological derivation keywords
	--
	[&quot;clipping&quot;] = create_keyword(deep_merge(DEFAULTS.transitive, {
		text = &quot;Clipping of&quot;,
		phrase = &quot;clipping of&quot;,
		abbrev = &quot;clip.&quot;,
		glossary = &quot;clipping&quot;,
		toplevel_category = &quot;clippings&quot;,
		aliases = { &quot;clip&quot; },
	})),
	[&quot;ellipsis&quot;] = create_keyword(deep_merge(DEFAULTS.transitive, {
		text = &quot;Ellipsis of&quot;,
		phrase = &quot;ellipsis of&quot;,
		abbrev = &quot;ellip.&quot;,
		glossary = &quot;ellipsis&quot;,
		toplevel_category = &quot;ellipses&quot;,
		aliases = { &quot;ellip&quot; },
	})),
	[&quot;back-formation&quot;] = create_keyword(deep_merge(DEFAULTS.transitive, {
		text = &quot;Back-formation from&quot;,
		phrase = &quot;a back-formation from&quot;,
		abbrev = &quot;bf.&quot;,
		glossary = &quot;back-formation&quot;,
		toplevel_category = &quot;back-formations&quot;,
		aliases = { &quot;bf&quot; },
	})),
	[&quot;nominalization&quot;] = create_keyword(deep_merge(DEFAULTS.transitive, {
		text = &quot;Nominalization of&quot;,
		phrase = &quot;a nominalization of&quot;,
		abbrev = &quot;nom.&quot;,
		glossary = &quot;nominalization&quot;,
		toplevel_category = &quot;nominalizations&quot;,
		aliases = { &quot;nom&quot; },
	})),
	[&quot;transliteration&quot;] = create_keyword(deep_merge(DEFAULTS.transitive, {
		text = &quot;Transliteration of&quot;,
		phrase = &quot;borrowed from&quot;,
		abbrev = &quot;translit.&quot;,
		glossary = &quot;transliteration&quot;,
		aliases = { &quot;translit&quot; },
	})),
	[&quot;vrd&quot;] = create_keyword(deep_merge(DEFAULTS.transitive, {
		text = &quot;Vṛddhi derivative of&quot;,
		phrase = &quot;a vṛddhi derivative of&quot;,
		abbrev = &quot;vṛd.&quot;,
		glossary = &quot;vṛddhi derivative&quot;,
	})),
	[&quot;apheretic&quot;] = create_keyword(deep_merge(DEFAULTS.transitive, {
		text = &quot;Apheretic form of&quot;,
		phrase = &quot;an apheretic form of&quot;,
		abbrev = &quot;aph.&quot;,
		glossary = &quot;apheresis&quot;,
		aliases = { &quot;apheresis&quot;, &quot;aphetic&quot; },
	})),
	[&quot;denominal&quot;] = create_keyword(deep_merge(DEFAULTS.transitive, {
		text = &quot;Denominal verb from&quot;,
		phrase = &quot;denominal verb from&quot;,
		abbrev = &quot;denom.&quot;,
		glossary = &quot;denominal&quot;,
		toplevel_category = &quot;denominal verbs&quot;,
		aliases = { &quot;denom&quot; },
	})),
	[&quot;deverbal&quot;] = create_keyword(deep_merge(DEFAULTS.transitive, {
		text = &quot;Deverbal from&quot;,
		phrase = &quot;deverbal from&quot;,
		abbrev = &quot;deverb.&quot;,
		glossary = &quot;deverbal&quot;,
		toplevel_category = &quot;deverbals&quot;,
	})),
	[&quot;reduplication&quot;] = create_keyword(deep_merge(DEFAULTS.transitive, {
		text = &quot;Reduplication of&quot;,
		phrase = &quot;reduplication of&quot;,
		abbrev = &quot;redup.&quot;,
		glossary = &quot;reduplication&quot;,
		toplevel_category = &quot;reduplications&quot;,
		aliases = { &quot;redup&quot; },
	})),
	[&quot;abbreviation&quot;] = create_keyword(deep_merge(DEFAULTS.transitive, {
		text = &quot;Abbreviation of&quot;,
		phrase = &quot;abbreviation of&quot;,
		abbrev = &quot;abbr.&quot;,
		glossary = &quot;abbreviation&quot;,
		aliases = { &quot;abbr&quot;, &quot;abbrev&quot; },
	})),
	[&quot;syllabic abbreviation&quot;] = create_keyword(deep_merge(DEFAULTS.transitive, {
		text = &quot;Syllabic abbreviation of&quot;,
		phrase = &quot;syllabic abbreviation of&quot;,
		abbrev = &quot;syl. abbr.&quot;,
		glossary = &quot;syllabic abbreviation&quot;,
		aliases = { &quot;sylabbr&quot;, &quot;sylabbrev&quot; },
	})),
	[&quot;acronym&quot;] = create_keyword(deep_merge(DEFAULTS.transitive, {
		text = &quot;Acronym of&quot;,
		phrase = &quot;acronym of&quot;,
		abbrev = &quot;acronym&quot;,
		glossary = &quot;acronym&quot;,
		aliases = { &quot;acro&quot; },
	})),
	[&quot;initialism&quot;] = create_keyword(deep_merge(DEFAULTS.transitive, {
		text = &quot;Initialism of&quot;,
		phrase = &quot;initialism of&quot;,
		abbrev = &quot;init.&quot;,
		glossary = &quot;initialism&quot;,
		aliases = { &quot;init&quot; },
	})),
	[&quot;metathesis&quot;] = create_keyword(deep_merge(DEFAULTS.transitive, {
		text = &quot;Metathesis of&quot;,
		phrase = &quot;metathesis of&quot;,
		abbrev = &quot;meta.&quot;,
		glossary = &quot;metathesis&quot;,
		toplevel_category = &quot;words derived through metathesis&quot;,
		aliases = { &quot;meta&quot; },
	})),

	--
	-- Invisible keywords (no text output)
	--
	[&quot;root&quot;] = create_keyword {
		transitive = TRANSITIVE.ALWAYS,
		invisible = &quot;all&quot;,
		pos_override = &quot;root&quot;,
	},
	[&quot;afeq&quot;] = create_keyword(deep_merge(DEFAULTS.affix_group, {
		text = &quot;From&quot;,
		phrase = &quot;from&quot;,
		transitive = TRANSITIVE.NEVER,
		invisible = &quot;all&quot;,
	})),
}

local aliases_to_register = {}
local canonical_aliases = {}
-- Map every keyword (canonical or alias) to its canonical form for consistent checks and tracking.
export.keyword_canonical = {}

for name, keyword_data in pairs(export.keywords) do
	export.keyword_canonical[name] = name
	if keyword_data.aliases then
		canonical_aliases[name] = keyword_data.aliases
		for _, alias in ipairs(keyword_data.aliases) do
			if export.keywords[alias] then
				error(&quot;Alias '&quot; ..
				alias .. &quot;' defined in keyword '&quot; .. name .. &quot;' collides with existing keyword '&quot; .. alias .. &quot;'.&quot;)
			end
			if aliases_to_register[alias] then
				error(&quot;Alias '&quot; ..
				alias .. &quot;' defined in keyword '&quot; .. name .. &quot;' is already claimed by another keyword.&quot;)
			end
			aliases_to_register[alias] = keyword_data
			export.keyword_canonical[alias] = name
		end
		keyword_data.aliases = nil
	end
end

for alias, data in pairs(aliases_to_register) do
	export.keywords[alias] = data
end

--
-- Language exception presets
--
local EXCEPTION_PRESETS = {
	-- Fully disallowed: no tree, no text, no categories
	disallowed = {
		disallow = { tree = true, text = true },
		suppress_categories = true,
	},
	-- Suppress transliteration only
	no_translit = {
		suppress_tr = true,
	},
	-- Suppress all categories only
	no_categories = {
		suppress_categories = true,
	},
}

--[=[
Available exception options:
	disallow = {               Related options for disallowing output:
		tree                   Disallow etymology trees for this language
		text                   Disallow etymology text generation for this language
		ref                    Reference link shown when tree/text is disallowed
	}
	suppress_tr                Suppress transliteration in links
	suppress_categories        Suppress all category generation
	normalize_to               Normalize language code to a different code
	normalize_from_families    Apply normalization to languages in these families
	normalize_exclude_families Exclude these families from normalization
	keyword_overrides          Per-keyword categorisation overrides (e.g. { [&quot;af&quot;] = { transitive = TRANSITIVE.NEVER } })
]=]
local function create_exception(preset, overrides)
	local base = preset and EXCEPTION_PRESETS[preset] or {}
	return deep_merge(base, overrides or {})
end

export.config = {
	lang_exceptions = {

		[&quot;zh&quot;] = create_exception(&quot;disallowed&quot;, {
			disallow = { ref = &quot;[[Wiktionary:Beer parlour/2025/May#Template:etymon for Chinese]]&quot; },
			suppress_tr = true,
			normalize_to = &quot;zh&quot;,
			normalize_from_families = { &quot;zhx&quot; },
			normalize_exclude_families = { &quot;qfa-cnt&quot; },
		}),
	},
}

-- Supported codes for the nominalization &lt;g:code&gt; modifier (subset of common gender/number-style codes)
export.nominalization_g_codes = {
	[&quot;m&quot;] = &quot;masculine&quot;,
	[&quot;f&quot;] = &quot;feminine&quot;,
	[&quot;n&quot;] = &quot;neuter&quot;,
	[&quot;c&quot;] = &quot;common&quot;,
	[&quot;gneut&quot;] = &quot;gender-neutral&quot;,
	[&quot;s&quot;] = &quot;singular&quot;,
	[&quot;p&quot;] = &quot;plural&quot;,
	[&quot;d&quot;] = &quot;dual&quot;,
	[&quot;pauc&quot;] = &quot;paucal&quot;,
	[&quot;mf&quot;] = &quot;masculine or feminine&quot;,
	[&quot;fm&quot;] = &quot;masculine or feminine&quot;,
	[&quot;mfn&quot;] = &quot;masculine, feminine or neuter&quot;,
	[&quot;mnf&quot;] = &quot;masculine, feminine or neuter&quot;,
	[&quot;fmn&quot;] = &quot;masculine, feminine or neuter&quot;,
	[&quot;fnm&quot;] = &quot;masculine, feminine or neuter&quot;,
	[&quot;nmf&quot;] = &quot;masculine, feminine or neuter&quot;,
	[&quot;nfm&quot;] = &quot;masculine, feminine or neuter&quot;,
}

--
-- Propagate keyword overrides to aliases
--
if export.config.lang_exceptions then
	for lang_code, exception in pairs(export.config.lang_exceptions) do
		if exception.keyword_overrides then
			for canonical, aliases in pairs(canonical_aliases) do
				if exception.keyword_overrides[canonical] then
					local override_data = exception.keyword_overrides[canonical]
					for _, alias in ipairs(aliases) do
						if not exception.keyword_overrides[alias] then
							exception.keyword_overrides[alias] = override_data
						end
					end
				end
			end
		end
	end
end

return export</text>
      <sha1>en6z2me7ggveh5mllhfh8xeo89dolmh</sha1>
    </revision>
  </page>
  <page>
    <title>Modul:module loader</title>
    <ns>828</ns>
    <id>118628</id>
    <revision>
      <id>342821</id>
      <timestamp>2026-05-16T13:44:42Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <comment>Mengemas kini mengikut padanan Wikikamus bahasa Inggeris (semakan [[en:Special:Diff/89545220|89545220]])</comment>
      <origin>342821</origin>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="8076" sha1="iwyqw4o7jo9m9e6uy2lpdgswy00nml1" xml:space="preserve">--[==[ intro:
A generic lazy-loading module loader with function-level caching. Provides a unified interface
for loading modules via `require()` or `mw.loadData()`.

== Features ==
* Lazy loading: modules are only loaded when first accessed
* Function caching: individual functions are cached after first call
* Duplicate detection: errors on duplicate names or paths

== Usage ==

```
local loader = require(&quot;Module:module loader&quot;)

local M = loader.init({
    require = {
        utilities = &quot;Module:utilities&quot;,
        languages = &quot;Module:languages&quot;,
    },
    loadData = {
        headword_data = &quot;Module:headword/data&quot;,
        parameters_data = &quot;Module:parameters/data&quot;,
    },
})

-- Modules are loaded lazily on first access:
M.utilities.format_categories(...)  -- loads Module:utilities, caches function
M.headword_data.page                -- loads via mw.loadData
```

== Parameters ==

; ``opts``.require : __table__
: Maps short names to module paths. Modules are loaded via {require()} on first access.
  Functions within the module are cached individually.

; ``opts``.loadData : __table__
: Maps short names to module paths. Modules are loaded via {mw.loadData()} on first access.
  The entire table is cached (no function-level proxying).

; ``opts``.loadDataOptional : __table__
: Maps short names to module paths. Same as {loadData} but load is wrapped in pcall; missing or failing modules yield nil.

; ``opts``.requireOptional : __table__
: Maps short names to module paths. Same as {require} but load is wrapped in pcall; missing or failing modules yield nil.

; ``opts``.lazy : __table__
: Maps short names to lazy getters. Each entry is either a function () → value (cached on first access)
  or a table of name → function () → value for a nested lazy object (e.g. ``mw`` with getCurrentTitle, getCurrentFrame, getContentLanguage).
]==]

local export = {}

local NIL = {} -- sentinel for optional loadData/require that failed (so we don't retry)

-- Validate module configuration for duplicates.
-- Throws an error if duplicate names or paths are found.
local function validate(modules, data_modules, optional_data_modules, optional_require_modules, lazy_modules)
	local seen_names = {}
	local seen_paths = {}

	-- Check require modules
	for name, path in pairs(modules) do
		if seen_names[name] then
			error(&quot;Module loader: duplicate name '&quot; .. name .. &quot;'&quot;)
		end
		seen_names[name] = &quot;require&quot;

		if seen_paths[path] then
			error(&quot;Module loader: module '&quot; .. path .. &quot;' loaded twice (as '&quot; .. seen_paths[path] .. &quot;' and '&quot; .. name .. &quot;')&quot;)
		end
		seen_paths[path] = name
	end

	-- Check loadData modules
	for name, path in pairs(data_modules) do
		if seen_names[name] then
			error(&quot;Module loader: duplicate name '&quot; .. name .. &quot;' (in both require and loadData)&quot;)
		end
		seen_names[name] = &quot;loadData&quot;

		if seen_paths[path] then
			error(&quot;Module loader: module '&quot; .. path .. &quot;' loaded twice (as '&quot; .. seen_paths[path] .. &quot;' and '&quot; .. name .. &quot;')&quot;)
		end
		seen_paths[path] = name
	end

	-- Check loadDataOptional (names must not clash; paths can duplicate optional)
	for name, path in pairs(optional_data_modules or {}) do
		if seen_names[name] then
			error(&quot;Module loader: duplicate name '&quot; .. name .. &quot;'&quot;)
		end
		seen_names[name] = &quot;loadDataOptional&quot;
	end

	-- Check requireOptional (names must not clash)
	for name, path in pairs(optional_require_modules or {}) do
		if seen_names[name] then
			error(&quot;Module loader: duplicate name '&quot; .. name .. &quot;'&quot;)
		end
		seen_names[name] = &quot;requireOptional&quot;
	end

	-- Check lazy (names must not clash)
	for name in pairs(lazy_modules or {}) do
		if seen_names[name] then
			error(&quot;Module loader: duplicate name '&quot; .. name .. &quot;'&quot;)
		end
		seen_names[name] = &quot;lazy&quot;
	end
end

--[==[
Create a lazy-loading module proxy.

The returned proxy uses metatables to intercept access:
* For `require` modules: creates a sub-proxy that caches individual functions
* For `loadData` modules: returns the data table directly (read-only, no proxying)
* For function modules: caches and returns the function directly

Arguments:
* ``opts`` (__table__): Configuration options.
** ``opts``.require (__table__): Maps short names to module paths (loaded via {require()}).
** ``opts``.loadData (__table__): Maps short names to module paths (loaded via {mw.loadData()}).
** ``opts``.loadDataOptional (__table__): Same as loadData but load is wrapped in pcall; missing modules yield nil.
** ``opts``.requireOptional (__table__): Same as require but load is wrapped in pcall; missing or failing modules yield nil.
** ``opts``.lazy (__table__): Maps names to lazy getters. Value is a function () → value, or a table of name → function () → value for a nested lazy object.

Returns a __table__ proxy that loads modules/functions on demand.
]==]
-- Build a proxy for a lazy object: table of name → function () → value. Each key is evaluated once and cached.
local function make_lazy_object_proxy(getters)
	return setmetatable({}, {
		__index = function(proxy, key)
			local getter = getters[key]
			if type(getter) ~= &quot;function&quot; then return nil end
			local value = getter()
			rawset(proxy, key, value)
			return value
		end
	})
end

function export.init(opts)
	local modules = opts.require or {}
	local data_modules = opts.loadData or {}
	local optional_data_modules = opts.loadDataOptional or {}
	local optional_require_modules = opts.requireOptional or {}
	local lazy_modules = opts.lazy or {}

	validate(modules, data_modules, optional_data_modules, optional_require_modules, lazy_modules)

	local loaded_modules = {}

	local function get_module(module_name)
		if loaded_modules[module_name] ~= nil then
			local m = loaded_modules[module_name]
			return m == NIL and nil or m
		end

		if data_modules[module_name] then
			loaded_modules[module_name] = mw.loadData(data_modules[module_name])
		elseif optional_data_modules[module_name] then
			local ok, data = pcall(mw.loadData, optional_data_modules[module_name])
			loaded_modules[module_name] = (ok and data) and data or NIL
		elseif optional_require_modules[module_name] then
			local ok, mod = pcall(require, optional_require_modules[module_name])
			loaded_modules[module_name] = (ok and mod and type(mod) == &quot;table&quot;) and mod or NIL
		elseif modules[module_name] then
			loaded_modules[module_name] = require(modules[module_name])
		end

		local m = loaded_modules[module_name]
		return m == NIL and nil or m
	end

	local proxy_metatable = {
		__index = function(proxy, module_name)
			-- Lazy: single getter function or table of getters (nested lazy object)
			if lazy_modules[module_name] then
				local lazy_def = lazy_modules[module_name]
				if type(lazy_def) == &quot;function&quot; then
					local value = lazy_def()
					rawset(proxy, module_name, value)
					return value
				end
				if type(lazy_def) == &quot;table&quot; then
					local sub = make_lazy_object_proxy(lazy_def)
					rawset(proxy, module_name, sub)
					return sub
				end
			end

			local module = get_module(module_name)
			if not module then return nil end

			-- If the module itself is a function, cache and return it directly
			if type(module) == &quot;function&quot; then
				rawset(proxy, module_name, module)
				return module
			end

			-- For loadData / loadDataOptional modules, return the table directly (no function proxying)
			if data_modules[module_name] or optional_data_modules[module_name] then
				rawset(proxy, module_name, module)
				return module
			end

			-- requireOptional modules get the same function-level proxy as require
			-- (optional_require_modules is not listed above so they fall through to the proxy)

			-- Otherwise create a proxy that lazily caches individual functions
			local function_proxy = setmetatable({}, {
				__index = function(function_cache, function_name)
					local cached_function = module[function_name]
					rawset(function_cache, function_name, cached_function)
					return cached_function
				end
			})

			rawset(proxy, module_name, function_proxy)
			return function_proxy
		end
	}

	return setmetatable({}, proxy_metatable)
end

return export</text>
      <sha1>iwyqw4o7jo9m9e6uy2lpdgswy00nml1</sha1>
    </revision>
  </page>
  <page>
    <title>Modul:etymon/descendants</title>
    <ns>828</ns>
    <id>118629</id>
    <revision>
      <id>342822</id>
      <timestamp>2026-05-16T13:46:24Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <comment>Mengemas kini mengikut padanan Wikikamus bahasa Inggeris (semakan [[en:Special:Diff/90119833|90119833]])</comment>
      <origin>342822</origin>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="13042" sha1="njoa75ldlbxvifpj024ykipfx44kfcd" xml:space="preserve">local export = {}

local M = require(&quot;Module:module loader&quot;).init({
	require = {
		template_parser = &quot;Module:template parser&quot;,
		links = &quot;Module:links&quot;,
		languages = &quot;Module:languages&quot;,
	},
})

local TRACKABLE_KEYWORDS = {
	inherited = true,
	bor = true,
	lbor = true,
	slbor = true,
	derived = true,
	uder = true,
}

local DESCENDANT_TEMPLATES = {
	[&quot;desc&quot;] = true,
	[&quot;descendant&quot;] = true,
	[&quot;desctree&quot;] = true,
	[&quot;descendants tree&quot;] = true,
}

local SKIPPED_TERMS = {
	[&quot;&quot;] = true,
	[&quot;-&quot;] = true,
}

local CHECK_MISSING_HEADER = { missing_header = true, missing_entry = false }
local STRIPPED_REF_TEMPLATES = {
	ref = true,
	refn = true,
}
local ENABLE_DESCENDANTS_TRACKING = false

local function _resolve_explicit_cache_id(explicit_id, parent_etymon)
	if parent_etymon then
		return parent_etymon.id or &quot;*&quot;
	end
	return explicit_id
end

local function _resolve_single_cache_id(id_data)
	return (type(id_data) == &quot;table&quot; and id_data.id) or id_data or &quot;*&quot;
end

local function _resolve_cache_id(lookup)
	if not lookup then
		return nil
	end
	if lookup.id then
		return lookup.id
	end
	if lookup.explicit_id then
		return _resolve_explicit_cache_id(lookup.explicit_id, lookup.parent_etymon)
	end
	if lookup.id_data ~= nil then
		return _resolve_single_cache_id(lookup.id_data)
	end
	return nil
end

local function _get_cached_check(cache_table, is_toplevel, base_key, cache_id)
	if not is_toplevel or not cache_table or not base_key or not cache_id then
		return nil
	end
	return cache_table[base_key .. &quot;:&quot; .. cache_id]
end

local function _store_checks(cache_table, lang_page_key, checks_by_id, redirected_from)
	if not cache_table or not lang_page_key or not checks_by_id then
		return
	end

	for id, check in pairs(checks_by_id) do
		cache_table[lang_page_key .. &quot;:&quot; .. id] = check
	end
	if redirected_from then
		for id, check in pairs(checks_by_id) do
			cache_table[redirected_from .. &quot;:&quot; .. id] = check
		end
	end
end

local function _strip_refs(value)
	if type(value) ~= &quot;string&quot; or value == &quot;&quot; then
		return value
	end

	local get_node_class = M.template_parser.class_else_type
	local function trim_local(text)
		return (type(text) == &quot;string&quot; and text:match(&quot;^%s*(.-)%s*$&quot;)) or &quot;&quot;
	end
	local function lower_local(text)
		return text and mw.ustring.lower(text) or text
	end
	local function template_name_unexpanded(template_node)
		return lower_local(trim_local(tostring(template_node[1]) or &quot;&quot;))
	end
	local function stringify_without_ref_templates(node)
		if type(node) ~= &quot;table&quot; then
			return node == nil and &quot;&quot; or tostring(node)
		end

		local node_class = get_node_class(node)
		if node_class == &quot;template&quot; and STRIPPED_REF_TEMPLATES[template_name_unexpanded(node)] then
			return &quot;&quot;
		end
		if node_class == &quot;template&quot; then
			return tostring(node)
		end
		if node_class == &quot;heading&quot; then
			return tostring(node)
		end
		if node_class and node_class ~= &quot;wikitext&quot; then
			return tostring(node)
		end

		local pieces = {}
		for i = 1, #node do
			pieces[i] = stringify_without_ref_templates(node[i])
		end
		return table.concat(pieces)
	end

	local parsed = M.template_parser.parse(value)
	local cleaned = stringify_without_ref_templates(parsed)

	local changed = true
	while changed do
		local next_cleaned = mw.ustring.gsub(cleaned, &quot;&lt;%s*[Rr][Ee][Ff][^&gt;]-/&gt;&quot;, &quot;&quot;)
		next_cleaned = mw.ustring.gsub(next_cleaned, &quot;&lt;%s*[Rr][Ee][Ff][^&gt;]*&gt;.-&lt;%s*/%s*[Rr][Ee][Ff]%s*&gt;&quot;, &quot;&quot;)
		next_cleaned = mw.ustring.gsub(next_cleaned, &quot;{{%s*[Rr][Ee][Ff]%s*}}&quot;, &quot;&quot;)
		next_cleaned = mw.ustring.gsub(next_cleaned, &quot;{{%s*[Rr][Ee][Ff]%s*|[^{}]-}}&quot;, &quot;&quot;)
		changed = next_cleaned ~= cleaned
		cleaned = next_cleaned
	end

	return cleaned
end

local function _trim(value)
	if type(value) ~= &quot;string&quot; then
		return nil
	end
	return value:match(&quot;^%s*(.-)%s*$&quot;)
end

local function _lower(value)
	return value and mw.ustring.lower(value) or value
end

local function _is_index_in_range(index, start_index, end_index)
	return index and index &gt;= start_index and index &lt;= end_index
end

local function _build_parse_index(lang_section)
	local parsed = M.template_parser.parse(lang_section)
	local headings = {}
	local templates = {}

	for heading in parsed:iterate_nodes(&quot;heading&quot;) do
		local heading_name = heading:get_name()
		table.insert(headings, {
			index = heading.index or 1,
			level = heading.level or 0,
			name = heading_name and _lower(_trim(heading_name) or &quot;&quot;) or nil,
			length = #tostring(heading),
		})
	end

	for template in parsed:iterate_nodes(&quot;template&quot;) do
		local template_name = template:get_name()
		local template_args = template:get_arguments()
		table.insert(templates, {
			index = template.index or 1,
			name = template_name and _lower(_trim(template_name) or &quot;&quot;) or &quot;&quot;,
			args = template_args or {},
		})
	end

	return {
		headings = headings,
		templates = templates,
	}
end

local function _build_regions(lang_section, headings)
	local content_length = #lang_section
	local etymology_headings = {}
	for _, heading in ipairs(headings) do
		if heading.level == 3 and heading.name and mw.ustring.match(heading.name, &quot;^etymology&quot;) then
			table.insert(etymology_headings, heading)
		end
	end

	if #etymology_headings == 0 then
		return {
			{ start_index = 1, end_index = content_length }
		}
	end

	local regions = {}
	for i = 1, #etymology_headings do
		local heading = etymology_headings[i]
		local next_heading = etymology_headings[i + 1]
		local start_index = heading.index
		local end_index = next_heading and (next_heading.index - 1) or content_length
		if i == 1 and heading.index &gt; 1 then
			local preamble = lang_section:sub(1, heading.index - 1)
			if preamble:match(&quot;%S&quot;) then
				start_index = 1
			end
		end
		table.insert(regions, {
			start_index = start_index,
			end_index = end_index,
		})
	end

	return regions
end

local function _count_region_etymons(region, templates, etymon_lang_code)
	local count = 0
	for _, template in ipairs(templates) do
		if _is_index_in_range(template.index, region.start_index, region.end_index)
			and template.name == &quot;etymon&quot;
			and template.args[1] == etymon_lang_code then
			count = count + 1
		end
	end
	return count
end

local function _get_descendants_sections(region, headings)
	local sections = {}
	for i = 1, #headings do
		local heading = headings[i]
		if _is_index_in_range(heading.index, region.start_index, region.end_index)
			and heading.name == &quot;descendants&quot; then
			local body_start = heading.index + heading.length
			local body_end = region.end_index
			for j = i + 1, #headings do
				local next_heading = headings[j]
				if next_heading.index &gt; region.end_index then
					break
				end
				if next_heading.level &lt;= heading.level then
					body_end = next_heading.index - 1
					break
				end
			end
			table.insert(sections, {
				start_index = body_start,
				end_index = body_end,
			})
		end
	end
	return sections
end

local function _template_lang_matches_entry(template_lang_code, entry_full_code, cache)
	local normalized_code = _trim(template_lang_code)
	if not normalized_code or normalized_code == &quot;&quot; then
		return false
	end

	local cached = cache[normalized_code]
	if cached ~= nil then
		return cached
	end

	local template_lang = M.languages.getByCode(normalized_code, nil, true)
	local is_match = template_lang and template_lang:getFullCode() == entry_full_code or false
	cache[normalized_code] = is_match
	return is_match
end

local function _template_lists_target(template_args, first_term_index, target_page_lower, entry_lang)
	for arg_index = first_term_index, #template_args do
		local template_term = _trim(template_args[arg_index])
		if template_term and not SKIPPED_TERMS[template_term] then
			if _lower(template_term) == target_page_lower then
				return true
			end

			local template_page = M.links.get_link_page(template_term, entry_lang)
			if _lower(template_page) == target_page_lower then
				return true
			end
		end
	end
	return false
end

local function _is_target_listed_in_descendants(descendants_sections, templates, entry_title, entry_lang)
	if #descendants_sections == 0 then
		return false
	end

	local target_page = M.links.get_link_page(entry_title, entry_lang)
	local target_page_lower = _lower(target_page)
	local entry_full_code = entry_lang:getFullCode()
	local lang_match_cache = {}

	for _, section in ipairs(descendants_sections) do
		for _, template in ipairs(templates) do
			if _is_index_in_range(template.index, section.start_index, section.end_index)
				and DESCENDANT_TEMPLATES[template.name] then
				local lang_arg_index = nil
				for arg_index = 1, #template.args do
					if _template_lang_matches_entry(template.args[arg_index], entry_full_code, lang_match_cache) then
						lang_arg_index = arg_index
						break
					end
				end
				if lang_arg_index and _template_lists_target(template.args, lang_arg_index + 1, target_page_lower, entry_lang) then
					return true
				end
			end
		end
	end

	return false
end

local function _region_has_descendant_template(region, templates)
	for _, template in ipairs(templates) do
		if _is_index_in_range(template.index, region.start_index, region.end_index)
			and DESCENDANT_TEMPLATES[template.name] then
			return true
		end
	end
	return false
end

local function _get_region_check(region, parsed_index, entry_title, entry_lang)
	local descendants_sections = _get_descendants_sections(region, parsed_index.headings)
	if #descendants_sections == 0 then
		if _region_has_descendant_template(region, parsed_index.templates) then
			local fallback_sections = { {
				start_index = region.start_index,
				end_index = region.end_index,
			} }
			return {
				missing_header = false,
				missing_entry = not _is_target_listed_in_descendants(fallback_sections, parsed_index.templates, entry_title, entry_lang),
			}
		end
		return CHECK_MISSING_HEADER
	end

	return {
		missing_header = false,
		missing_entry = not _is_target_listed_in_descendants(descendants_sections, parsed_index.templates, entry_title, entry_lang),
	}
end

local function _build_checks_by_id(lang_section, etymon_lang_code, found_templates_for_lang, entry_title, entry_lang)
	local checks_by_id = {}
	local parsed_index = _build_parse_index(lang_section)
	local regions = _build_regions(lang_section, parsed_index.headings)
	local template_list_index = 1
	local mapping_failed = false

	for _, region in ipairs(regions) do
		local region_etymon_count = _count_region_etymons(region, parsed_index.templates, etymon_lang_code)
		local region_check = nil
		if region_etymon_count &gt; 0 then
			region_check = _get_region_check(region, parsed_index, entry_title, entry_lang)
		end

		for _ = 1, region_etymon_count do
			local found_template_args = found_templates_for_lang[template_list_index]
			if not found_template_args then
				mapping_failed = true
				break
			end
			checks_by_id[found_template_args.id or &quot;*&quot;] = region_check
			template_list_index = template_list_index + 1
		end
		if mapping_failed then
			break
		end
	end

	if mapping_failed or template_list_index ~= (#found_templates_for_lang + 1) then
		local global_region = { start_index = 1, end_index = #lang_section }
		local fallback_check = _get_region_check(global_region, parsed_index, entry_title, entry_lang)
		checks_by_id = {}
		for _, template_args in ipairs(found_templates_for_lang) do
			checks_by_id[template_args.id or &quot;*&quot;] = fallback_check
		end
	end

	return checks_by_id
end

local function _compute_checks_for_page(opts)
	opts = opts or {}
	local found_templates_for_lang = opts.found_templates_for_lang or {}
	if #found_templates_for_lang == 0 then
		return {}
	end

	local entry_title = opts.entry_title
	local entry_lang = opts.entry_lang
	local etymon_lang_code = opts.etymon_lang_code
	if not entry_title or not entry_lang or not etymon_lang_code then
		return {}
	end

	local sanitized_lang_section = _strip_refs(opts.lang_section or &quot;&quot;)

	return _build_checks_by_id(
		sanitized_lang_section,
		etymon_lang_code,
		found_templates_for_lang,
		entry_title,
		entry_lang
	)
end

function export.cache_page_checks(opts)
	if not ENABLE_DESCENDANTS_TRACKING then
		return {}
	end
	opts = opts or {}
	local cache_table = opts.cached_descendants_checks
	local lang_page_key = opts.lang_page_key
	if not cache_table or not lang_page_key then
		return {}
	end

	local checks_by_id = _compute_checks_for_page(opts)
	_store_checks(cache_table, lang_page_key, checks_by_id, opts.redirected_from)
	return checks_by_id
end

function export.get_lookup_check(opts)
	if not ENABLE_DESCENDANTS_TRACKING then
		return nil
	end
	opts = opts or {}
	return _get_cached_check(
		opts.cached_descendants_checks,
		opts.is_toplevel,
		opts.base_key,
		_resolve_cache_id(opts.lookup)
	)
end

function export.get_term_sync_flags(keyword, term_status, descendants_check)
	if not ENABLE_DESCENDANTS_TRACKING then
		return false, false
	end
	local should_track = term_status == &quot;ok&quot;
		and TRACKABLE_KEYWORDS[keyword] == true
		and descendants_check ~= nil
	if not should_track then
		return false, false
	end

	return descendants_check.missing_header or false, descendants_check.missing_entry or false
end

return export</text>
      <sha1>njoa75ldlbxvifpj024ykipfx44kfcd</sha1>
    </revision>
  </page>
  <page>
    <title>Modul:etymon/data/text allowed</title>
    <ns>828</ns>
    <id>118630</id>
    <revision>
      <id>342827</id>
      <timestamp>2026-05-16T13:55:21Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <comment>Mencipta laman baru dengan kandungan '--[=[ Languages and families that may use the {{etymon}} `text=` parameter (language-community consensus). ]=]  return { 	-- Mode: &quot;off&quot; = disabled, &quot;warn&quot; = warn only, &quot;error&quot; = enforce. 	default_mode = &quot;warn&quot;, 	langs = { 		[&quot;bg&quot;] = true, 		[&quot;bnt-sab-pro&quot;] = true, 		[&quot;cs&quot;] = true, 		[&quot;en&quot;] = true, 		[&quot;es&quot;] = true, 		[&quot;fa&quot;] = true, 		[&quot;hrx&quot;] = true, 		[&quot;hsb&quot;] = true, 		[&quot;iir-pro&quot;] = true, 		[&quot;jbo&quot;] = true, 		[&quot;jdt&quot;] = true, 		[&quot;la&quot;] = true, 		[&quot;mul&quot;] =...'</comment>
      <origin>342827</origin>
      <model>Scribunto</model>
      <format>text/plain</format>
      <text bytes="1024" sha1="tc1am4wig5hhrcueh4azua0q8gj7j8o" xml:space="preserve">--[=[
Languages and families that may use the {{etymon}} `text=` parameter (language-community consensus).
]=]

return {
	-- Mode: &quot;off&quot; = disabled, &quot;warn&quot; = warn only, &quot;error&quot; = enforce.
	default_mode = &quot;warn&quot;,
	langs = {
		[&quot;bg&quot;] = true,
		[&quot;bnt-sab-pro&quot;] = true,
		[&quot;cs&quot;] = true,
		[&quot;en&quot;] = true,
		[&quot;es&quot;] = true,
		[&quot;fa&quot;] = true,
		[&quot;hrx&quot;] = true,
		[&quot;hsb&quot;] = true,
		[&quot;iir-pro&quot;] = true,
		[&quot;jbo&quot;] = true,
		[&quot;jdt&quot;] = true,
		[&quot;la&quot;] = true,
		[&quot;mul&quot;] = true,
		[&quot;ota&quot;] = true,
		[&quot;ps&quot;] = true,
		[&quot;ro&quot;] = true,
		[&quot;sk&quot;] = true,
		[&quot;sw&quot;] = true,
		[&quot;tg&quot;] = true,
		[&quot;tl&quot;] = true,
		[&quot;tr&quot;] = true,
		[&quot;uk&quot;] = true,
		[&quot;uz&quot;] = true,
		[&quot;zlw-ocs&quot;] = true,
		[&quot;zlw-osk&quot;] = true,
	},
	families = {
		[&quot;ber&quot;] = true,      -- Berber
		[&quot;dra&quot;] = true,      -- Dravidian
		[&quot;inc&quot;] = true,      -- Indo-Aryan
		[&quot;iir-nur&quot;] = true,  -- Nuristani
		[&quot;roa-gap&quot;] = true,  -- Galician-Portuguese
		[&quot;sem-ara&quot;] = true,  -- Aramaic
		[&quot;sem-arb&quot;] = true,  -- Arabic
		[&quot;tup&quot;] = true,      -- Tupian
		[&quot;zlw-lch&quot;] = true,  -- Lechitic
	},
}</text>
      <sha1>tc1am4wig5hhrcueh4azua0q8gj7j8o</sha1>
    </revision>
  </page>
  <page>
    <title>Kategori:Templat Tulisan Hiragana</title>
    <ns>14</ns>
    <id>118631</id>
    <revision>
      <id>342834</id>
      <timestamp>2026-05-16T14:19:07Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <comment>Mencipta laman baru dengan kandungan '{{auto cat}}'</comment>
      <origin>342834</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="12" sha1="eomzlm5v4j7ond1phrju7cnue91g5qx" xml:space="preserve">{{auto cat}}</text>
      <sha1>eomzlm5v4j7ond1phrju7cnue91g5qx</sha1>
    </revision>
  </page>
  <page>
    <title>Templat:Hira-categoryTOC/full</title>
    <ns>10</ns>
    <id>118632</id>
    <revision>
      <id>342835</id>
      <timestamp>2026-05-16T14:20:15Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <comment>Mencipta laman baru dengan kandungan '&lt;small&gt;{{#invoke:table of contents|full|lang=ja|あ|い|う|え|お|か|き|く|け|こ|さ|し|す|せ|そ|た|ち|つ|て|と|な|に|ぬ|ね|の|は|ひ|ふ|へ|ほ|ま|み|む|め|も|や|ゆ|よ|ら|り|る|れ|ろ|わ|ん}}&lt;/small&gt;&lt;noinclude&gt;{{tcat}}&lt;/noinclude&gt;'</comment>
      <origin>342835</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="268" sha1="iuh2ty7ezs4s2r60sncbiig1ordb61d" xml:space="preserve">&lt;small&gt;{{#invoke:table of contents|full|lang=ja|あ|い|う|え|お|か|き|く|け|こ|さ|し|す|せ|そ|た|ち|つ|て|と|な|に|ぬ|ね|の|は|ひ|ふ|へ|ほ|ま|み|む|め|も|や|ゆ|よ|ら|り|る|れ|ろ|わ|ん}}&lt;/small&gt;&lt;noinclude&gt;{{tcat}}&lt;/noinclude&gt;</text>
      <sha1>iuh2ty7ezs4s2r60sncbiig1ordb61d</sha1>
    </revision>
  </page>
  <page>
    <title>Wikikamus:Bahasa Isyarat Malaysia</title>
    <ns>4</ns>
    <id>118633</id>
    <revision>
      <id>342838</id>
      <timestamp>2026-05-17T02:57:56Z</timestamp>
      <contributor>
        <username>PeaceSeekers</username>
        <id>3334</id>
      </contributor>
      <comment>Mencipta laman baru dengan kandungan '{{gb|bahasa=Isyarat Malaysia|kod=zml|keterangan=Bahasa Isyarat Malaysia (BIM) ialah bahasa isyarat rasmi yang digunakan di Malaysia, berdasarkan Akta Orang Kurang Upaya 2008. Ia terbit sebagai keturunan kepada [[wt:Bahasa Isyarat Amerika|Bahasa Isyarat Amerika]].}}'</comment>
      <origin>342838</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="265" sha1="m8lt9bpj8chhtwm813dcmbswlqd3swg" xml:space="preserve">{{gb|bahasa=Isyarat Malaysia|kod=zml|keterangan=Bahasa Isyarat Malaysia (BIM) ialah bahasa isyarat rasmi yang digunakan di Malaysia, berdasarkan Akta Orang Kurang Upaya 2008. Ia terbit sebagai keturunan kepada [[wt:Bahasa Isyarat Amerika|Bahasa Isyarat Amerika]].}}</text>
      <sha1>m8lt9bpj8chhtwm813dcmbswlqd3swg</sha1>
    </revision>
    <revision>
      <id>342840</id>
      <parentid>342838</parentid>
      <timestamp>2026-05-17T03:09:04Z</timestamp>
      <contributor>
        <username>PeaceSeekers</username>
        <id>3334</id>
      </contributor>
      <minor />
      <origin>342840</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="265" sha1="jmoo27qih07n0s4ocfua8h6errxs2uf" xml:space="preserve">{{gb|bahasa=Isyarat Malaysia|kod=xml|keterangan=Bahasa Isyarat Malaysia (BIM) ialah bahasa isyarat rasmi yang digunakan di Malaysia, berdasarkan Akta Orang Kurang Upaya 2008. Ia terbit sebagai keturunan kepada [[wt:Bahasa Isyarat Amerika|Bahasa Isyarat Amerika]].}}</text>
      <sha1>jmoo27qih07n0s4ocfua8h6errxs2uf</sha1>
    </revision>
  </page>
  <page>
    <title>Wikikamus:xml</title>
    <ns>4</ns>
    <id>118634</id>
    <redirect title="Wikikamus:Bahasa Isyarat Malaysia" />
    <revision>
      <id>342839</id>
      <timestamp>2026-05-17T03:02:02Z</timestamp>
      <contributor>
        <username>PeaceSeekers</username>
        <id>3334</id>
      </contributor>
      <comment>Melencong ke [[Wikikamus:Bahasa Isyarat Malaysia]]</comment>
      <origin>342839</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="46" sha1="bovh100onrsqw6scqsfwj1y34n0dtho" xml:space="preserve">#LENCONG [[Wikikamus:Bahasa Isyarat Malaysia]]</text>
      <sha1>bovh100onrsqw6scqsfwj1y34n0dtho</sha1>
    </revision>
    <revision>
      <id>342841</id>
      <parentid>342839</parentid>
      <timestamp>2026-05-17T03:10:19Z</timestamp>
      <contributor>
        <username>PeaceSeekers</username>
        <id>3334</id>
      </contributor>
      <minor />
      <comment>PeaceSeekers telah memindahkan laman [[Wikikamus:zml]] ke [[Wikikamus:xml]] tanpa meninggalkan lencongan: Tajuk salah eja</comment>
      <origin>342839</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="46" sha1="bovh100onrsqw6scqsfwj1y34n0dtho" xml:space="preserve">#LENCONG [[Wikikamus:Bahasa Isyarat Malaysia]]</text>
      <sha1>bovh100onrsqw6scqsfwj1y34n0dtho</sha1>
    </revision>
  </page>
  <page>
    <title>Wikikamus:xml/tahun</title>
    <ns>4</ns>
    <id>118635</id>
    <revision>
      <id>342842</id>
      <timestamp>2026-05-17T03:19:10Z</timestamp>
      <contributor>
        <username>PeaceSeekers</username>
        <id>3334</id>
      </contributor>
      <comment>Mencipta laman baru dengan kandungan '=={{bahasa|{{safesubst:ROOTPAGENAME}}}}== [[Fail:BIM tahun.webm|thumb|&quot;tahun&quot; dalam Bahasa Isyarat Malaysia.]]  ===Kata nama=== {{inti|{{safesubst:ROOTPAGENAME}}|kata nama}} #Kedua-dua tangan digenggam lalu satu genggamam mengelilingi satu lagi genggaman ibarat Bumi mengelilingi Matahari.'</comment>
      <origin>342842</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="243" sha1="rw357gbxaz6v5it3i8x97ls31q3d5rq" xml:space="preserve">=={{bahasa|xml}}==
[[Fail:BIM tahun.webm|thumb|&quot;tahun&quot; dalam Bahasa Isyarat Malaysia.]]

===Kata nama===
{{inti|xml|kata nama}}
#Kedua-dua tangan digenggam lalu satu genggamam mengelilingi satu lagi genggaman ibarat Bumi mengelilingi Matahari.</text>
      <sha1>rw357gbxaz6v5it3i8x97ls31q3d5rq</sha1>
    </revision>
  </page>
  <page>
    <title>Wikikamus:Bahasa Isyarat Jepun</title>
    <ns>4</ns>
    <id>118636</id>
    <revision>
      <id>342843</id>
      <timestamp>2026-05-17T03:26:06Z</timestamp>
      <contributor>
        <username>PeaceSeekers</username>
        <id>3334</id>
      </contributor>
      <comment>Mencipta laman baru dengan kandungan '{{gb|bahasa=Isyarat Jepun|kod=jsl|keterangan=Bahasa Isyarat Jepun (日本手話; ''Nihon Shuwa'') ialah bahasa isyarat utama Jepun.}}'</comment>
      <origin>342843</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="133" sha1="0waj1vbaj7t01k5flpiza5dboz3l7el" xml:space="preserve">{{gb|bahasa=Isyarat Jepun|kod=jsl|keterangan=Bahasa Isyarat Jepun (日本手話; ''Nihon Shuwa'') ialah bahasa isyarat utama Jepun.}}</text>
      <sha1>0waj1vbaj7t01k5flpiza5dboz3l7el</sha1>
    </revision>
  </page>
  <page>
    <title>Wikikamus:jsl/gunung</title>
    <ns>4</ns>
    <id>118637</id>
    <revision>
      <id>342844</id>
      <timestamp>2026-05-17T03:29:00Z</timestamp>
      <contributor>
        <username>PeaceSeekers</username>
        <id>3334</id>
      </contributor>
      <comment>Mencipta laman baru dengan kandungan '=={{bahasa|{{safesubst:ROOTPAGENAME}}}}== [[Fail:JSLyama.gif|thumb|172x172px]]  ===Kata nama=== {{inti|{{safesubst:ROOTPAGENAME}}|kata nama}} # Jari melakar rupa [[gunung]] secara kasar dengan melakar bentuk segi tiga.'</comment>
      <origin>342844</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="172" sha1="9v68a6bfv5pm2t7kekft670k2kacued" xml:space="preserve">=={{bahasa|jsl}}==
[[Fail:JSLyama.gif|thumb|172x172px]]

===Kata nama===
{{inti|jsl|kata nama}}
# Jari melakar rupa [[gunung]] secara kasar dengan melakar bentuk segi tiga.</text>
      <sha1>9v68a6bfv5pm2t7kekft670k2kacued</sha1>
    </revision>
  </page>
  <page>
    <title>Wikikamus:jsl/aku</title>
    <ns>4</ns>
    <id>118638</id>
    <revision>
      <id>342845</id>
      <timestamp>2026-05-17T03:48:24Z</timestamp>
      <contributor>
        <username>PeaceSeekers</username>
        <id>3334</id>
      </contributor>
      <comment>Mencipta laman baru dengan kandungan '=={{bahasa|jsl}}== [[File:JSLwatshi06041102.gif|thumb|172x172px|&quot;aku&quot; dalam Bahasa Isyarat Jepun (1).]] [[File:JSLwatashi060411.gif|thumb|172x172px|&quot;aku&quot; dalam Bahasa Isyarat Jepun (2).]]  ===Kata ganti nama=== {{inti|jsl|kata ganti nama}}  # Jari menunjuk diri di kepala. # Jari menunjuk diri di kepala sambil menundukkan diri.'</comment>
      <origin>342845</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="328" sha1="nei3bzlf4w51dlh4uojlhgsmesfzko6" xml:space="preserve">=={{bahasa|jsl}}==
[[File:JSLwatshi06041102.gif|thumb|172x172px|&quot;aku&quot; dalam Bahasa Isyarat Jepun (1).]]
[[File:JSLwatashi060411.gif|thumb|172x172px|&quot;aku&quot; dalam Bahasa Isyarat Jepun (2).]]

===Kata ganti nama===
{{inti|jsl|kata ganti nama}}

# Jari menunjuk diri di kepala.
# Jari menunjuk diri di kepala sambil menundukkan diri.</text>
      <sha1>nei3bzlf4w51dlh4uojlhgsmesfzko6</sha1>
    </revision>
  </page>
  <page>
    <title>Kategori:ar:Forteana</title>
    <ns>14</ns>
    <id>118639</id>
    <redirect title="Kategori:ar:Parapsikologi" />
    <revision>
      <id>342851</id>
      <timestamp>2026-05-17T08:40:15Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <comment>Hakimi97 telah memindahkan laman [[Kategori:ar:Forteana]] ke [[Kategori:ar:Parapsikologi]]: Tajuk salah eja</comment>
      <origin>342851</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="39" sha1="2hf60xel4nfz5zdogyw6rutjhrl57ot" xml:space="preserve">#LENCONG [[:Kategori:ar:Parapsikologi]]</text>
      <sha1>2hf60xel4nfz5zdogyw6rutjhrl57ot</sha1>
    </revision>
  </page>
  <page>
    <title>Kategori:Forteana</title>
    <ns>14</ns>
    <id>118640</id>
    <redirect title="Kategori:Parapsikologi" />
    <revision>
      <id>342854</id>
      <timestamp>2026-05-17T08:41:31Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <comment>Hakimi97 telah memindahkan laman [[Kategori:Forteana]] ke [[Kategori:Parapsikologi]]: Tajuk salah eja</comment>
      <origin>342854</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="36" sha1="igm1ygx6f11ra2gfd999wsx6n2m8ivk" xml:space="preserve">#LENCONG [[:Kategori:Parapsikologi]]</text>
      <sha1>igm1ygx6f11ra2gfd999wsx6n2m8ivk</sha1>
    </revision>
  </page>
  <page>
    <title>Kategori:zh:Kelengkapan tandas</title>
    <ns>14</ns>
    <id>118641</id>
    <redirect title="Kategori:zh:Kelengkapan dandanan diri" />
    <revision>
      <id>342857</id>
      <timestamp>2026-05-17T08:42:39Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <comment>Hakimi97 telah memindahkan laman [[Kategori:zh:Kelengkapan tandas]] ke [[Kategori:zh:Kelengkapan dandanan diri]]: Tajuk salah eja</comment>
      <origin>342857</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="51" sha1="bmp4zz5798f78hlxksczh0wgs5b0wvc" xml:space="preserve">#LENCONG [[:Kategori:zh:Kelengkapan dandanan diri]]</text>
      <sha1>bmp4zz5798f78hlxksczh0wgs5b0wvc</sha1>
    </revision>
  </page>
  <page>
    <title>Kategori:my:Forteana</title>
    <ns>14</ns>
    <id>118642</id>
    <redirect title="Kategori:my:Paranormal" />
    <revision>
      <id>342859</id>
      <timestamp>2026-05-17T08:43:58Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <comment>Hakimi97 telah memindahkan laman [[Kategori:my:Forteana]] ke [[Kategori:my:Paranormal]]: Tajuk salah eja</comment>
      <origin>342859</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="36" sha1="n8r642q339rg2hv83o6kgq5yafpjpow" xml:space="preserve">#LENCONG [[:Kategori:my:Paranormal]]</text>
      <sha1>n8r642q339rg2hv83o6kgq5yafpjpow</sha1>
    </revision>
  </page>
  <page>
    <title>Kategori:ar:Kelengkapan tandas</title>
    <ns>14</ns>
    <id>118643</id>
    <redirect title="Kategori:ar:Kelengkapan dandanan diri" />
    <revision>
      <id>342861</id>
      <timestamp>2026-05-17T08:47:37Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <comment>Hakimi97 telah memindahkan laman [[Kategori:ar:Kelengkapan tandas]] ke [[Kategori:ar:Kelengkapan dandanan diri]]: Tajuk salah eja</comment>
      <origin>342861</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="51" sha1="61cwfqtnk3dpxc8t3z70r4j9izynzwh" xml:space="preserve">#LENCONG [[:Kategori:ar:Kelengkapan dandanan diri]]</text>
      <sha1>61cwfqtnk3dpxc8t3z70r4j9izynzwh</sha1>
    </revision>
  </page>
  <page>
    <title>Kategori:en:Kelengkapan tandas</title>
    <ns>14</ns>
    <id>118644</id>
    <redirect title="Kategori:en:Kelengkapan dandanan diri" />
    <revision>
      <id>342865</id>
      <timestamp>2026-05-17T08:49:00Z</timestamp>
      <contributor>
        <username>Hakimi97</username>
        <id>2668</id>
      </contributor>
      <comment>Hakimi97 telah memindahkan laman [[Kategori:en:Kelengkapan tandas]] ke [[Kategori:en:Kelengkapan dandanan diri]]: Tajuk salah eja</comment>
      <origin>342865</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="51" sha1="bpha8no9yle0v4h58xjjgup47ag0zw8" xml:space="preserve">#LENCONG [[:Kategori:en:Kelengkapan dandanan diri]]</text>
      <sha1>bpha8no9yle0v4h58xjjgup47ag0zw8</sha1>
    </revision>
  </page>
</mediawiki>