tine

<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="ku">
  <siteinfo>
    <sitename>Wîkîferheng</sitename>
    <dbname>kuwiktionary</dbname>
    <base>https://ku.wiktionary.org/wiki/Destp%C3%AAk</base>
    <generator>MediaWiki 1.48.0-wmf.4</generator>
    <case>case-sensitive</case>
    <namespaces>
      <namespace key="-2" case="case-sensitive">Medya</namespace>
      <namespace key="-1" case="first-letter">Taybet</namespace>
      <namespace key="0" case="case-sensitive" />
      <namespace key="1" case="case-sensitive">Gotûbêj</namespace>
      <namespace key="2" case="first-letter">Bikarhêner</namespace>
      <namespace key="3" case="first-letter">Gotûbêja bikarhêner</namespace>
      <namespace key="4" case="case-sensitive">Wîkîferheng</namespace>
      <namespace key="5" case="case-sensitive">Gotûbêja Wîkîferhengê</namespace>
      <namespace key="6" case="case-sensitive">Wêne</namespace>
      <namespace key="7" case="case-sensitive">Gotûbêja wêneyî</namespace>
      <namespace key="8" case="first-letter">MediaWiki</namespace>
      <namespace key="9" case="first-letter">Gotûbêja MediaWiki</namespace>
      <namespace key="10" case="case-sensitive">Şablon</namespace>
      <namespace key="11" case="case-sensitive">Gotûbêja şablonê</namespace>
      <namespace key="12" case="case-sensitive">Alîkarî</namespace>
      <namespace key="13" case="case-sensitive">Gotûbêja alîkariyê</namespace>
      <namespace key="14" case="case-sensitive">Kategorî</namespace>
      <namespace key="15" case="case-sensitive">Gotûbêja kategoriyê</namespace>
      <namespace key="100" case="case-sensitive">Pêvek</namespace>
      <namespace key="101" case="case-sensitive">Gotûbêja pêvekê</namespace>
      <namespace key="102" case="case-sensitive">Nimînok</namespace>
      <namespace key="103" case="case-sensitive">Gotûbêja nimînokê</namespace>
      <namespace key="104" case="case-sensitive">Portal</namespace>
      <namespace key="105" case="case-sensitive">Gotûbêja portalê</namespace>
      <namespace key="106" case="case-sensitive">Tewandin</namespace>
      <namespace key="107" case="case-sensitive">Gotûbêja tewandinê</namespace>
      <namespace key="108" case="case-sensitive">Jinûvesazî</namespace>
      <namespace key="109" case="case-sensitive">Gotûbêja jinûvesaziyê</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">Gotûbêja modulê</namespace>
      <namespace key="1728" case="case-sensitive">Event</namespace>
      <namespace key="1729" case="case-sensitive">Event talk</namespace>
    </namespaces>
  </siteinfo>
  <page>
    <title>tine</title>
    <ns>0</ns>
    <id>8691</id>
    <revision>
      <id>6903093</id>
      <parentid>6729036</parentid>
      <timestamp>2026-11-10T15:21:38Z</timestamp>
      <contributor>
        <username>Keyomerd</username>
        <id>8814</id>
      </contributor>
      <comment>/* Ji wêjeya klasîk */</comment>
      <origin>6903093</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1962" sha1="mgotvhfyp06bfmfh8k81urtylhrj7vm" xml:space="preserve">{{h-bnr|Tine|tinê|tîne|ține}}
{{ds|tine|tune|çine}}

== {{ziman|ku}} ==

=== Bilêvkirin ===
* {{ku-kîte}}

=== Formeke lêkerê ===
{{lêker|ku|form=erê}}
# ''[[dema niha|Dema niha]] ya [[yekjimar]] bo kesê sêyem ji lêkera'' '''[[nebûn]]'''.
#: ''Ew '''tine'''.''
# ne [[xwedî bûn]]
#: '' Min ferheng '''tine'''.''
# ne [[xwestin]]
#* {{J:Robert Louis Stevenson:Meseleya Seyr a Dr. Jekyll û Mr. Hyde|r=28|jêgirtin=Dilê min '''tine''' tiştekî bêtir bibihîsim.}}

=== Rengdêr ===
{{ku-tewîn-rd|tine}}
{{rengdêr|ku}}
# [[neyî]], [[nîn]], [[nî]], ne [[heyî]]
# ne ti tişt

==== Ji wêjeya klasîk ====
* {{J:Melayê Cizîrî:Dîwana Melayê Cizîrî|jêgirtin=Lew xef xedengan nuhtine&lt;br /&gt;Ji qewsê hilalê jih '''tine'''&lt;br /&gt;Heyranê dêma mehweş în}}

==== Formên alternatîv ====
* [[çine]]
* [[çune]]
* [[tune]]
* [[nîne]]

==== Dijmane ====
* [[heye]]

==== Jê ====
{{kol3|ku
|tine bûn
|tinebûn
|tine kirin
|tinekirin
|tinetî
|tineyî
}}

==== Etîmolojî ====
[[ti]] + [[ne]], bi hin devokên kurmancî herwiha [[tune]], [[çine]], [[çune]], zazakî [[çinî]]. Herwiha bide ber ermenî ''çe'' (&quot;ne&quot;).

==== Rastnivîsîn ====
Binere rûpela [[ti]]

==== Werger ====
{{werger-ser}}
* {{Z|de}}: {{W+|de|abwesend}}, {{W+|de|nicht}}
* {{Z|fa}}: {{W+|fa|نیست}}, {{W+|fa|نیستی|guman=erê}}
* {{Z|he}}: {{W+|he|אין}}
* {{Z|en}}: {{W+|en|zero}}, {{W+|en|naturopathy}}, {{W-|en|there is not}}, {{W-|en|ther are not}}, {{W-|en|there aren't}}, {{W-|en|there isn't}}, {{W-|en|has not}}, {{W+|en|have not}}
* {{Z|tr}}: {{W+|tr|yok}}, {{W+|tr|sıfır}}, {{W+|tr|mafiş}}, {{W+|tr|silik}}
* {{Z|yi}}: {{W-|yi|נישטאָ}}
{{werger-bin}}

==== Anagram ====
* {{anagram|ku|a=eint|etin|neti}}

== {{ziman|en}} ==

=== Navdêr ===
{{navdêr|en}}
# [[sertîj]], [[stirî]], [[çetel]] &lt;ref&gt;Ferhenga Kurdî-Îngîlîzî ya Salah Sadallah&lt;/ref&gt;

==== Anagram ====
* {{anagram|en|a=eint|Tien}}

=== Çavkanî ===
{{çavkanî}}</text>
      <sha1>mgotvhfyp06bfmfh8k81urtylhrj7vm</sha1>
    </revision>
  </page>
  <page>
    <title>xeyirîn</title>
    <ns>0</ns>
    <id>45630</id>
    <revision>
      <id>6903089</id>
      <parentid>6805631</parentid>
      <timestamp>2026-11-10T12:29:40Z</timestamp>
      <contributor>
        <username>Keyomerd</username>
        <id>8814</id>
      </contributor>
      <comment>/* Lêker */</comment>
      <origin>6903089</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1209" sha1="jxwt9f3gohgse598w16vvo4m0by48sk" xml:space="preserve">== {{ziman|ku}} ==

=== Bilêvkirin ===
* {{ku-kîte}}

=== Lêker ===
{{lêker|ku|c=ngh}}
# [[tav]] ([[roj]]) [[tarî]] bûn ji ber ku [[heyv]] dikeve ber
# [[guherîn]], [[hatin guhartin]]
#: ''Çi gereke '''bixeyire''' ku hun cardin vegerin Kurdistanê? Eger '''xeyirî''', çêbû em dixwazin vegerin Kurdistanê.''
# [[çilmisîn]]
#* {{jêder|ku|jêgirtin=Îro qewî têtin girî&lt;/br&gt;Sosin di mêrgan '''xeyirî'''&lt;/br&gt;Sed heyf li lêvê şekirî&lt;/br&gt;Êdî venaxwut şerbetê|{{Jêgirtin/Feqiyê Teyran/Dîwan}}}}

==== Ji wêjeya klasîk ====
* {{J:Feqiyê Teyran|jêgirtin=Muksî yê jar û bedtir im&lt;/br&gt;Ferhemnî '''xeyre''' rabimîn}}

==== Tewandin ====
''Lêker'':
:-xeyir-

==== Bi alfabeyên din ====
* {{ku-ar|خه‌یرین}}

==== Formên alternatîv ====
* [[xeyrîn]]

==== Jê ====
* [[xeyirandî]]
* [[xeyirîner]]
* [[roj xeyirîn]]

==== Têkildar ====
* [[xeyirandin]]

==== Etîmolojî ====
{{etîmon|ku|:qertaf|xeyr|-în}}

==== Werger ====
{{werger-ser}}
* {{Z|en}}: {{W+|en|eclipse}}
* {{Z|tr}}: {{W+|tr|solmak|guman=erê}}
{{werger-bin}}

=== Navdêr ===
{{navdêr|ku|z=m}}
# {{mane?|ku}}

==== Tewandin ====
{{ku-tewîn-nav|mê}}

==== Werger ====
{{werger-ser}}
{{werger-bin}}</text>
      <sha1>jxwt9f3gohgse598w16vvo4m0by48sk</sha1>
    </revision>
  </page>
  <page>
    <title>çilmisîn</title>
    <ns>0</ns>
    <id>50347</id>
    <revision>
      <id>6903090</id>
      <parentid>6472414</parentid>
      <timestamp>2026-11-10T12:29:58Z</timestamp>
      <contributor>
        <username>Keyomerd</username>
        <id>8814</id>
      </contributor>
      <comment>/* Lêker */</comment>
      <origin>6903090</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="5031" sha1="9vncah784vw5pikxalj8e8g2t128pkm" xml:space="preserve">== {{ziman|ku}} ==

=== Bilêvkirin ===
* {{ku-kîte}}

=== Lêker ===
{{ku-tewîn-reh|çilmisîn|form=ngh|niha=çilmis|borî=çilmisî}}
[[Wêne:Withered Hibiscus Blossom.jpg|thumb|Guleke çilmisî.]]
{{lêker|ku|c=x-ngh}}
# [[xeyirîn]], [[qurmiçîn]], [[qirmiçîn]], [[qermiçîn]], &lt;br&gt; (gul û giya yan [[leş]]) ji ber [[piçek]] [[hişk]]bûnê [[xeml]] û [[geşî|geşiya]] xwe [[ji dest dan]]
#: ''Gul '''çilmisîn''', &lt;br&gt;Rûyê mirovên pîr qurmiçî ye.''
#* {{jêder|ku|jêgirtin=Ey felek bo te dinalim &lt;br&gt;[[bo çi|Bo çi]] nêrgiz '''çilmisîn'''&lt;br&gt;Ew çima bextê me [[ho]] ye&lt;br&gt;Em bê dost û bêkes in.|Helbest: Bedirxan Sindî, stran: Mihemed Şêxo}}

==== Bi alfabeyên din ====
* {{ku-ar|چلمسین}}

==== Formên alternatîv ====
* [[çelmisîn]]
* [[çirmisîn]]

==== Dijmane ====
* [[bişkivîn]]

==== Jê ====
* [[çilmisiyayî]]
* [[çilmisî]]
* [[çilmisok]]

==== Têkildar ====
* [[çilmisandin]]

==== Etîmolojî ====
Hevreha soranî [[çiro]] bûn, kirmaşanî [[çilüsyan]], ermenî [[թարշամել]] (tarşamêl) / [[թառամել]] / (taramêl) herdu bi maneya &quot;çilmisîn&quot;, avestayî ''terşne-'' (tî, têhn, hewceyî avê), sanskrîtî ''trşyeti-'' (tî, hewceyî avê), yûnaniya kevn [[τέρσομαι]] (têrmosoy: [[hişk]] / [[ziwa]] bûn), latînî [[terra]] ([[ax]], erdê ziwa) û [[torrere]] ([[sotin]], [[şewitîn]]), almanî [[dürr]] ([[ziwa]], [[hişk]]), albanî [[thartë]] (tirş) û [[ter]] ([[hişk]] / [[ziwa]] bûn), îngilîzî [[thirst]] ([[têhn|tên]], hewcedariya bi avê) û [[dry]] ([[hişk]], [[ziwa]])... hemû ji {{ji|ine-pro|ku|-}} {{jinûvesazî|ine-pro|ters-|w=[[hişk]], [[ziwa]]}} ku herwiha serekaniya [[tî]] / [[tên]] (hewceyî avê) û [[tirş]]) yên kurdî ye jî. Bo guherîna &quot;t &gt; ç&quot; bide ber &quot;[[pate]]/[[paçe]]&quot; û &quot;[[qurt]]/[[qurç]]&quot;. Guherîna &quot;l/r&quot; di kurdî de [[diyarde]]yeke [[berbelav]] e.

Ji formeke [[kevnar]] a [[hevpar]] a wekî *terşemsîn, rş/rd/rj di kurdî de [[gelek caran]] dibe l (binêre [[dil]], [[hiştin|hêl-]], [[bilîn]] û frs: {{g|fa|ورزیدن}}(werzîden)). m'ên ku pêş dengekî [[dengdêr]] tên jî [[li gor]] zimanî dibin dibe v/w. anku di [[kirmaşanî]] de bûye *çelewsîn &gt; *çilûsîn û bi [[dengnasî|dengnasiya]] [[kirmaşanî]] bûye &quot;çilüsiyan/çilüsîn&quot; ji ber ku w'ên [[kurmancî|badînî]] bi [[kurdiya başûrî|kurmanciyên palewanî]] dibin ü. Bi [[soranî]] *çilewsîn bûye lê s herçima ketiye û paşê jî wek [[lêker]] êdî nemaye û wek *çilew maye ku bûye &quot;[[çiro]]&quot;. Di [[kurmancî|badînî]] de m cih [[guhartin|guhartiye]] [[lewma]] jî nebûye v, wek &quot;[[çilmisîn]]&quot; maye. [[-mis]] di vir de paşgireke transformatîf e ku maneya guherînê nîşan dide, anku ''çilmisîn'' = ''tirş ketin''. Bo zêdetir agehî binêre [[-ij]].

==== Bi zaravayên din ====
* {{Z|ckb}}: {{W-|ckb|گەچڵان}}, {{W-|ckb|چرچ بوون}}, {{W-|ckb|ژاکان}}, {{W-|ckb|سیس هەڵگەڕان}}, {{W-|ckb|سیس هەڵاتن}}, {{W-|ckb|سیس بوون}}

==== Werger ====
{{werger-ser}}
* {{Z|de}}: {{W+|de|welken}}, {{W+|de|verwelken}}, {{W+|de|dörren}}, {{W+|de|bleichen}}, {{W+|de|verblassen}}, {{W+|de|verblühen}}, {{W-|de|ausbleichen}}, {{W+|de|Blässe|f|guman=erê}}, {{W+|de|verhallen|guman=erê}}
* {{Z|cs}}: {{W+|cs|vadnout}}
* {{Z|zh}}: [[枯萎]](kūwěi)
* {{Z|da}}: {{W-|da|visne}}
* {{Z|ar}}: [[صعق]] (se'eqe), {{W+|ar|زبل}}, {{W-|ar|اصفر|guman=erê}}
* {{Z|hy}}: [[թարշամել]] (tʿaršamel) / [[թառամել]] / (tʿaṙamel)
* {{Z|fa}}: {{W+|fa|پژمردن|tr=pejmoden}}, {{W-|fa|پژمرده شدن}}
* {{Z|fi}}: {{W-|fi|kuihdutua}}, {{W+|fi|nuutua}}, {{W+|fi|näivettyä}}, {{W+|fi|lakastua}}
* {{Z|fr}}: {{W+|fr|flétrir}}, se [[faner]]
* {{Z|nl}}: {{W+|nl|verschrompelen}}
* {{Z|en}}: to {{W+|en|wither}}, to {{W+|en|shrivel}}, to {{W+|en|droop}}, to {{W+|en|dry up}}, to {{W+|en|fade}}, to {{W+|en|wilt}}, {{W+|en|shriveling}}, {{W+|en|withering}}, {{W+|en|wizen}}, {{W+|en|shrinkage|guman=erê}}, {{W+|en|discoloration|guman=erê}}, {{W+|en|shrinking|guman=erê}}
* {{Z|it}}: {{W+|it|appassire}}
* {{Z|ja}}: {{W+|ja|枯れる|tr=かれる, kareru}}
* {{Z|ko}}: [[시들다]] (sideurda)
* {{Z|pl}}: {{W-|pl|wysuszać}}, {{W+|pl|suszyć}}
* {{Z|pt}}: {{W+|pt|murchar}}
* {{Z|ro}}: {{W+|ro|veșteji}}, {{W+|ro|ofili}}
* {{Z|ru}}: [[вянуть]] (vyanuti), [[завянуть]] (zavyanuti), [[увянуть]] (uvyanuti), [[увядать]] (uvyadáti), [[сохнуть]] (sóxnuti), [[засохнуть]] (zasóxnuti)
* {{Z|es}}: {{W+|es|marchitarse}}
* {{Z|sv}}: {{W+|sv|vissna}}, {{W-|sv|förtorka}}
* {{Z|tr}}: {{W+|tr|solmak}}, {{W+|tr|pörsümek}}, {{W-|tr|renk atmak}}, {{W+|tr|uçmak}}, {{W+|tr|uçuklaşmak}}
* {{Z|el}}: {{W+|el|μαραίνομαι}}
{{werger-bin}}

=== Navdêr ===
{{navdêr|ku|z=m}}
# {{mane?|ku}}

==== Tewandin ====
{{ku-tewîn-nav|mê}}

==== Werger ====
{{werger-ser}}
* {{Z|tr}}: {{W+|tr|solma}}, {{W+|tr|soluş}}, {{W+|tr|pörsüme}}, {{W+|tr|uçuklaşma}}
{{werger-bin}}</text>
      <sha1>9vncah784vw5pikxalj8e8g2t128pkm</sha1>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Gadgets-definition</title>
    <ns>8</ns>
    <id>118586</id>
    <revision>
      <id>6903103</id>
      <parentid>6902727</parentid>
      <timestamp>2026-11-10T21:28:01Z</timestamp>
      <contributor>
        <username>Wikihez</username>
        <id>7344</id>
      </contributor>
      <minor />
      <comment>Wizard modules: add the files form.js and steps/sections.js</comment>
      <origin>6903103</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="6571" sha1="s148e4dhizqbd7z2ar7s7yrmdysk36s" xml:space="preserve">Binêre [[Taybet:Gadgets]] ji bo belgekirina amûrên li jêr.

==Rû==
* fix-kuarab-title[default|namespaces=0,108|actions=view]|fix-kuarab-title.js
* definition-links[default|namespaces=0,108|actions=view]|definition-links.js
* LiveClock[dependencies=mediawiki.util]|LiveClock.js
* charinsert-styles[hidden|type=styles]|charinsert-styles.css
* LanguagesAndScripts[default]|LanguagesAndScripts.css
* jeder[dependencies=ext.gadget.VisibilityToggles|default]|jeder.css|jeder.js
* CodeLinks[default|dependencies=site,mediawiki.util]|CodeLinks.js
* Tabset[default]|Tabset.js|Tabset.css
* kuTewandin[default]|kuTewandin.js
* wikt.orange-links[dependencies=mediawiki.api,mediawiki.util,mediawiki.Title]|wikt.orange-links.js|wikt.orange-links.css
* wikt.showids[package|namespaces=0,2,4,108|actions=view|dependencies=mediawiki.util]|wikt.showids.js|wikt.showids.css
* wikt.targeted-translations[default|namespaces=0,2,4,108|actions=view|dependencies=mediawiki.storage]|wikt.targeted-translations.js|wikt.targeted-translations.css
* EtytreeZoom[default|dependencies=mediawiki.util]|EtytreeZoom.js
* PagePreviews[default|dependencies=site,mediawiki.api,mediawiki.util,mediawiki.Title|skins=vector,vector-2022,monobook,timeless,modern,cologneblue]|PagePreviews.js
* AutoRedirect[default|dependencies=user,mediawiki.util|actions=view|namespaces=0]|AutoRedirect.js
* TreeDescs[default|namespaces=0,108|peers=TreeDescs-pagestyles]|TreeDescs.js
* clearer-edit-summary[default|actions=view]|clearer-edit-summary.js
* DeluxeHistory[dependencies=user,mediawiki.util]|DeluxeHistory.js|DeluxeHistory.css
* JumpToError[dependencies=mediawiki.notification]|JumpToError.js
* purgetab[dependencies=mediawiki.api,mediawiki.util]|purgetab.js

==AmûrênGuhartinê==
* check-transpage[default|namespaces=0,108|actions=view]|check-transpage.js
* preload-text[default|actions=edit|dependencies=mediawiki.util]|preload-text.js
* wikEd|wikEd.js
* charinsert[default|peers=charinsert-styles]|charinsert.js
* translation_editor[dependencies=mediawiki.notification|type=general]|silent_fail_storage.js|editor.js|translation_editor.js|translation_editor.css
* QQ[dependencies=mediawiki.util,oojs-ui-core,oojs-ui-widgets|type=general]|QQ.js|QQ.css
* WiktAccFormCreation[dependencies=mediawiki.util]|WiktAccFormCreation.js
* AjaxEdit[dependencies=mediawiki.util,mediawiki.user,mediawiki.api]|AjaxEdit.js
* EditHere[dependencies=mediawiki.api,oojs-ui-core,oojs-ui-widgets]|EditHere.js
* aWa[rights=autoconfirmed|dependencies=mediawiki.util,mediawiki.api,mediawiki.user,user.options,mediawiki.Title|type=general]|aWa.js|aWa.css
* start[default|package|namespaces=0,2,4,108|dependencies=mediawiki.util,ext.gadget.wikt.core]|start.js
* wikt.dsb[default|package|namespaces=0,2,4,108|actions=view|dependencies=mediawiki.util,ext.gadget.wikt.core]|wikt.dsb.js|wikt.dsb.css
* linkify-toolbar[default|actions=edit,submit|dependencies=ext.gadget.linkify,jquery.textSelection,ext.wikiEditor]|linkify-toolbar.js

==Kategorî==
* HotCat|HotCat.js
* Cat-a-lot[rights=autoconfirmed]|Cat-a-lot.css|Cat-a-lot.js

==AmûrênVeşartî==
* check-transpage-popup[hidden|package|dependencies=oojs-ui,mediawiki.user]|check-transpage-popup.js
* StorageUtils[hidden|dependencies=mediawiki.cookie,mediawiki.storage]|StorageUtils.js
* charinsert-core[hidden|dependencies=jquery.textSelection,user,mediawiki.storage]|charinsert-core.js
* VisibilityToggles[hidden|dependencies=user,mediawiki.cookie,mediawiki.storage]|VisibilityToggles.js
* defaultVisibilityToggles[hidden|default|dependencies=ext.gadget.VisibilityToggles]|defaultVisibilityToggles.js
* Site[hidden|default]|Site.css
* catfix[hidden|default|dependencies=mediawiki.Title,mediawiki.util|categories=Pages using catfix]|catfix.js
* Palette[hidden|default]|Palette.css
* test[rights=autoconfirmed]|test.js
* citoid-helper[hidden|dependencies=mediawiki.util]|citoid-helper.js
* wikt.core[hidden|package|dependencies=mediawiki.util,mediawiki.storage]|wikt.core.js|wikt.core/sections.js|wikt.core/prefs.js|wikt.core/data-sections.json|wikt.core.css
* wikt.suggest[hidden|package|dependencies=mediawiki.util]|wikt.suggest.js|wikt.suggest.css
* wikt.lang-metadata[hidden|package]|wikt.lang-metadata.js|wikt.lang-metadata.json
* wikt.edit-data[hidden|package|dependencies=ext.gadget.wikt.lang-metadata]|wikt.edit-data.js|wikt.edit/data-main.json
* wikt.edit[hidden|package|dependencies=mediawiki.util,mediawiki.api,ext.gadget.wikt.core,ext.gadget.wikt.suggest,ext.gadget.wikt.edit-data]|wikt.edit.js|wikt.edit/util.js|wikt.edit/wikitext.js|wikt.edit/langs.js|wikt.edit/labels.js|wikt.edit/posparams.js|wikt.edit/ziman-core.json|wikt.edit.css
* wikt.cite[hidden|package|dependencies=mediawiki.api,oojs-ui-core,oojs-ui-widgets,oojs-ui-windows,ext.gadget.citoid-helper,ext.gadget.wikt.edit]|wikt.cite.js|wikt.cite/etimon.js|wikt.cite.css
* wikt.dsb-panels[hidden|package|dependencies=mediawiki.util,mediawiki.api,ext.gadget.wikt.core,ext.gadget.wikt.edit]|wikt.dsb-panels.js|wikt.dsb-panels.css
* wikt.dsb-sense[hidden|package|dependencies=ext.gadget.wikt.dsb-panels,ext.gadget.wikt.cite,ext.gadget.wikt.add-examples,oojs-ui-windows]|wikt.dsb-sense.js
* wikt.dsb-subsection[hidden|package|dependencies=ext.gadget.wikt.dsb-panels,ext.gadget.wikt.cite,oojs-ui-windows]|wikt.dsb-subsection.js
* wikt.dsb-pos[hidden|package|dependencies=ext.gadget.wikt.dsb-panels]|wikt.dsb-pos.js
* wikt.start-wizard-styles[hidden|type=general]|wikt.start-wizard.css
* wikt.start-wizard-steps[hidden|package]|wikt.start-wizard-steps.js|wikt.start-wizard-steps/sections.js
* wikt.start-wizard[hidden|package|dependencies=mediawiki.util,mediawiki.api,ext.gadget.wikt.core,ext.gadget.wikt.edit,ext.gadget.wikt.cite,ext.gadget.StorageUtils,ext.gadget.citoid-helper,oojs-ui-core,oojs-ui-widgets,oojs-ui-windows,ext.gadget.wikt.start-wizard-steps,ext.gadget.wikt.start-wizard-styles]|wikt.start-wizard.js|wikt.start-wizard/form.js
* wikt.add-examples[hidden|package|dependencies=oojs,oojs-ui,ext.gadget.citoid-helper,ext.gadget.StorageUtils,ext.gadget.wikt.core,ext.gadget.wikt.edit,ext.gadget.wikt.cite]|wikt.add-examples.js|wikt.add-examples.css
* wikt.translation-adder[hidden|package|dependencies=mediawiki.util,mediawiki.api,mediawiki.storage,ext.gadget.StorageUtils,ext.gadget.wikt.suggest,ext.gadget.wikt.lang-metadata]|wikt.translation-adder.js|wikt.translation-adder/editor.js|wikt.translation-adder/language-utils.js|wikt.translation-adder/data.js|wikt.translation-adder.css
* linkify[hidden|dependencies=mediawiki.api]|linkify.js
* TreeDescs-pagestyles[hidden|type=styles]|TreeDescs-pagestyles.css</text>
      <sha1>s148e4dhizqbd7z2ar7s7yrmdysk36s</sha1>
    </revision>
  </page>
  <page>
    <title>xûsî</title>
    <ns>0</ns>
    <id>429954</id>
    <revision>
      <id>6903091</id>
      <parentid>6538068</parentid>
      <timestamp>2026-11-10T12:41:53Z</timestamp>
      <contributor>
        <username>Keyomerd</username>
        <id>8814</id>
      </contributor>
      <comment>/* Formên alternatîv */</comment>
      <origin>6903091</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="5310" sha1="g1kgebeboyrsyvz4l4rsokn3gqw87ed" xml:space="preserve">{{h-bnr|xuşî}}
{{ds|xwîs|xwîsar}}

== {{ziman|ku}} ==

=== Bilêvkirin ===
* {{ku-kîte}}

=== Navdêr ===
[[Wêne:FrostyLeaf.jpg|thumb|250px|xwîsar li ser [[pelg]]eke [[dar]]an]]
[[Wêne:Fleur_de_givre_L.jpg|thumb|250px|[[krîstal]]ên [[xwîsar]]ê ji nêzîk ve]]
{{navdêr|ku|z=m}}
# [[xunav|Xunavên]] [[qerisî]], [[çip]]ên [[av]]ê yên ku ji ber [[sarma]]yê bûne [[qeşa]] anku [[sehol]].

==== Tewandin ====
{{ku-tewîn-nav|mê}}

==== Formên alternatîv ====
{{kol3|ku|cure=Herwiha
|xûsar
|xûs
|xûsk
|xwîs
|xwîsar
|xwîsî
|xwîsk
|xewsar
}}

==== Etîmolojî ====
{{bêetîmolojî|ku}}

==== Werger ====
{{werger-ser}}
* {{Z|sq}}: {{W+|sq|ngricë|m}}, {{W+|sq|brymë|m}}, {{W+|sq|çaf|n}}
* {{Z|de}}: {{W+|de|Reif|n}}
* {{Z|alt}}: {{W-|alt|кыру}}
* {{Z|ami}}: {{W-|ami|'o'ol}}
* {{Z|rup}}: {{W-|rup|brumã|m}}
* {{Z|as}}: {{W-|as|নিয়ৰ}}
* {{Z|ay}}: {{W-|ay|juyphi}}
* {{Z|ain}}: {{W-|ain|シンナㇺ|tr=sinnam}}
* {{Z|az}}: {{W+|az|qırov}}
* {{Z|eu}}: {{W-|eu|antzigar}}, {{W-|eu|intzigar}}
* {{Z|ba}}: {{W-|ba|ҡырау}}
* {{Z|be}}: {{W-|be|і́ней|n}}, {{W-|be|шэ́рань|m}}
* {{Z|bg}}: {{W+|bg|слана|m}}, {{W+|bg|скреж|n}}
* {{Z|cim}}: {{W-|cim|bròzama|m}}, {{W-|cim|bròst|n}}
* {{Z|cs}}: {{W+|cs|jinovatka|m}}, {{W+|cs|mráz|n}}
* {{Z|zh}}:
*: {{Z|yue}}: {{W-|yue|霜|tr=soeng1}}
*: {{Z|cmn}}: {{W+|cmn|霜|tr=shuāng}}
* {{Z|cv}}: {{W-|cv|тӑм}}
* {{Z|da}}: {{W+|da|frost|g}}
* {{Z|ar}}: {{W-|ar|صَقِيع|n}}
*: {{Z|acw}}: {{W-|acw|صقيع|tr=ṣagīʕ|n|sc=Arab}}
*: {{Z|ary}}: {{W-|ary|جْريحة|m|tr=jriḥa}}
* {{Z|hy}}: {{W+|hy|եղյամ}}
* {{Z|eo}}: {{W+|eo|prujno}}
* {{Z|et}}: {{W+|et|härmatis}}
* {{Z|fa}}: {{W+|fa|هسر|tr=hasar}}
* {{Z|fo}}: {{W-|fo|frost|nt}}
* {{Z|fi}}: {{W+|fi|kuura}}, {{W+|fi|huurre}}, {{W+|fi|härmä}}
* {{Z|fr}}: {{W+|fr|givre|n}}
* {{Z|gd}}: {{W-|gd|reòthadh|n}}
* {{Z|gl}}: {{W+|gl|rosada|m}}, {{W+|gl|xeada|m}}, {{W+|gl|lazo|n}}, {{W+|gl|carazo|n}}, {{W-|gl|pruina|m}}, {{W-|gl|estromba|m}}
* {{Z|gn}}: {{W+|gn|eláda}}
* {{Z|nl}}: {{W+|nl|rijp}}, {{W+|nl|rijm}}
* {{Z|he}}: {{W+|he|כְּפוֹר|n|tr=k'for}}
* {{Z|ang}}: {{W-|ang|hrīm|n}}
* {{Z|en}}: {{W+|en|frost}}, {{W+|en|hoar frost}}
* {{Z|ga}}: {{W-|ga|sioc|n}}, {{W-|ga|siocán|n}}, {{W-|ga|reo|n}}, {{W-|ga|cuisne|n}}
* {{Z|it}}: {{W+|it|brina|m}}
* {{Z|is}}: {{W-|is|hrím|nt}}
* {{Z|ja}}: {{W+|ja|霜|tr=[[しも]], shimo|sc=Jpan}}
* {{Z|krc}}: {{W-|krc|къырау}}
* {{Z|kdr}}: {{W-|kdr|kyrav}}
* {{Z|kaa}}: {{W-|kaa|qıraw}}
* {{Z|ca}}: {{W+|ca|gelada|m}}, {{W+|ca|glaçada|m}}, {{W+|ca|gebre|n}}
* {{Z|qu}}: {{W-|qu|qasa}}
* {{Z|ky}}: {{W+|ky|кыроо}}
* {{Z|ko}}: {{W+|ko|서리}}
* {{Z|kum}}: {{W-|kum|къырав}}
* {{Z|la}}: {{W-|la|pruīna|m}}, {{W-|la|gelicidium|nt}}
* {{Z|lo}}: {{W-|lo|ນ້ຳກະດ້າງ}}, {{W-|lo|ໝອກຂຸ້ນ}}
* {{Z|lb}}: {{W-|lb|Räif|n}}
* {{Z|ms}}: {{W+|ms|ibun}}
* {{Z|mnc}}: {{W-|mnc|ᡤᡝᠴᡝᠨ}}
* {{Z|mi}}: {{W-|mi|hukapapa}}, {{W-|mi|hukapuri}}, {{W-|mi|hukatū}}, {{W-|mi|hauhunga}}, {{W-|mi|hukapapa}}
* {{Z|hu}}: {{W+|hu|dér}}, {{W+|hu|zúzmara}}
* {{Z|nap}}: {{W-|nap|ggelo}}
* {{Z|nv}}: {{W-|nv|shoh}}, {{W-|nv|dahtooʼ tin}}, {{W-|nv|dah tin}}
* {{Z|nog}}: {{W-|nog|кырав}}
* {{Z|nrf}}: {{W-|nrf|gélée|m}}
* {{Z|no}}:
*: {{Z|nb}}: {{W+|nb|rim|nt}}, {{W+|nb|frost|n}}
*: {{Z|nn}}: {{W-|nn|frost|n}}
* {{Z|oc}}: {{W+|oc|gibre|n}}, {{W-|oc|glacina|m}}
* {{Z|ota}}: {{W-|ota|قراغو|tr=kırağu, kırağı}}
* {{Z|ug}}: {{W-|ug|qiro}}
* {{Z|uz}}: {{W+|uz|qirov}}
* {{Z|pdt}}: {{W-|pdt|Frost|n}}
* {{Z|pox}}: {{W-|pox|morz|n}}
* {{Z|pl}}: {{W+|pl|mróz|n}}
* {{Z|pt}}: {{W+|pt|geada|m}}
* Punjabi:
*: Gurmuxî: {{W-|pa|ਕੱਕਰ|n}}
*: Şahmuxî: {{W-|pa|کَکَّر|n}}
* {{Z|kk}}: {{W-|kk|қырау|sc=Cyrl}}
* {{Z|ro}}: {{W+|ro|brumă|m}}
* {{Z|ru}}: {{W+|ru|и́ней|n}}, {{W+|ru|и́зморозь|m}}
* {{Z|sa}}: {{W+|sa|हिम|tr=himá|n}}
* {{Z|sh}}:
*: Kirîlî: {{W-|sh|мра̏з|n}}, {{W-|sh|и̑ње|nt}}, {{W-|sh|сла́на|m}}
*: Latînî: {{W+|sh|mrȁz|n}}, {{W+|sh|ȋnje|nt}}, {{W+|sh|slána|m}}
* {{Z|sk}}: {{W-|sk|mráz|n}}
* {{Z|sl}}: {{W-|sl|ivje|nt}}, {{W-|sl|slana|m}}
* Sorbî:
*: {{Z|dsb}}: {{W-|dsb|mroz|n}}
* {{Z|es}}: {{W+|es|escarcha|m}}
* {{Z|sv}}: {{W+|sv|frost|g}}, {{W+|sv|rimfrost|g}}
* {{Z|cjs}}: {{W-|cjs|қыраа|tr=qyraa}}
* {{Z|tl}}: {{W-|tl|eskartsa}}, {{W-|tl|yamog}}, {{W-|tl|andap}}
* {{Z|rif}}: {{W-|rif|ajris|n}}
* {{Z|th}}: {{W-|th|น้ำค้างแข็ง|tr=nám káang kɛ̌ɛng}}
* {{Z|te}}: {{W+|te|హిమము}}
* {{Z|crh}}: {{W-|crh|qırav}}
* {{Z|tt}}: {{W+|tt|кырау}}
* {{Z|tr}}: {{W+|tr|kırağı}}
* {{Z|kim}}: {{W-|kim|һыраа|tr=hyraa}}
* {{Z|tyv}}: {{W-|tyv|хыраа}}
* {{Z|uk}}: {{W-|uk|і́ній|n}}
* {{Z|vec}}: {{W+|vec|bròxa|m}}, {{W+|vec|bróxema|m}}
* {{Z|vi}}: {{W+|vi|sương giá}}
* {{Z|vo}}: {{W+|vo|flod}}
* {{Z|wa}}: {{W+|wa|djalêye|m}}
* {{Z|cy}}: {{W+|cy|rhew|n}}, {{W+|cy|barrug|n}}
* {{Z|kjh}}: {{W-|kjh|хро}}
* {{Z|yi}}: {{W-|yi|יאָדלעבוים|n}}
* {{Z|el}}: {{W+|el|πάγος|n}}, {{W+|el|πάχνη|m}}
*: Kevn: {{W-|grc|κρυμός|n}}, {{W+|el|πάγος|n}}, {{W-|grc|πάχνη|m}}
* {{Z|nmn}}: {{W-|nmn|ǁqa̰ã}}

{{werger-bin}}

:{{werger çavkanî|en|frost|beş=Ev qismê Wergerê|oldid=82402009}}</text>
      <sha1>g1kgebeboyrsyvz4l4rsokn3gqw87ed</sha1>
    </revision>
  </page>
  <page>
    <title>peratin</title>
    <ns>0</ns>
    <id>957263</id>
    <revision>
      <id>6903094</id>
      <parentid>6496824</parentid>
      <timestamp>2026-11-10T15:25:35Z</timestamp>
      <contributor>
        <username>Keyomerd</username>
        <id>8814</id>
      </contributor>
      <comment>/* Lêker */</comment>
      <origin>6903094</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="824" sha1="6vsj7ns8oyp2b7zm23pgfpvsy9kchhf" xml:space="preserve">== {{ziman|ku}} ==

=== Bilêvkirin ===
* {{ku-kîte}}

=== Lêker ===
{{ku-tewîn-lk|peratin|form=gerguhêz|niha=perêj|borî=perat}}
{{lêker|ku|c=x-gh}}
# [[sotin]], [[şewitandin]]
#* {{jêder|ku|jêgirtin=Bilbilên wê gulşenê, ji ezel her dibêjin&lt;/br&gt;Heta ku der neymînî, ji me'den da dirêjin&lt;/br&gt;Herfek ji wesfan tenê, alem '''naperêjin'''|{{Jêgirtin/Feqiyê Teyran/Dîwan}}}}

==== Formên alternatîv ====
* [[perêhtin]]

==== Têkildar ====
* [[perijîn]]

==== Etîmolojî ====
Ji {{hv|ira-pro|*peri-}} + {{g|ira-pro|*tač}}, hevreha {{hv|ku|bihatin}} ko ji {{hv|ira-pro|*wi-}} + {{g|ira-pro|*tač}} e.

==== Werger ====
{{werger-ser}}
{{werger-bin}}

=== Navdêr ===
{{navdêr|ku|z=m}}
# {{mane?|ku}}

==== Werger ====
{{werger-ser}}
{{werger-bin}}

==== Anagram ====
* {{anagram|ku|a=aeinprt|peritan}}</text>
      <sha1>6vsj7ns8oyp2b7zm23pgfpvsy9kchhf</sha1>
    </revision>
    <revision>
      <id>6903097</id>
      <parentid>6903094</parentid>
      <timestamp>2026-11-10T15:44:04Z</timestamp>
      <contributor>
        <username>Wikihez</username>
        <id>7344</id>
      </contributor>
      <comment>/* Lêker */  (bi [[MediaWiki:Gadget-AjaxEdit.js|AjaxEdit]]ê re)</comment>
      <origin>6903097</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="810" sha1="jrl1j4k8deq8mjlxbky7jd63qa738pg" xml:space="preserve">== {{ziman|ku}} ==

=== Bilêvkirin ===
* {{ku-kîte}}

=== Lêker ===
{{ku-tewîn-lk|peratin|form=gerguhêz|niha=perêj|borî=perat}}
{{lêker|ku|c=x-gh}}
# [[sotin]], [[şewitandin]]
#* {{Jêgirtin/Feqiyê Teyran/Dîwan|jêgirtin=Bilbilên wê gulşenê, ji ezel her dibêjin&lt;/br&gt;Heta ku der neymînî, ji me'den da dirêjin&lt;/br&gt;Herfek ji wesfan tenê, alem '''naperêjin'''}}

==== Formên alternatîv ====
* [[perêhtin]]

==== Têkildar ====
* [[perijîn]]

==== Etîmolojî ====
Ji {{hv|ira-pro|*peri-}} + {{g|ira-pro|*tač}}, hevreha {{hv|ku|bihatin}} ko ji {{hv|ira-pro|*wi-}} + {{g|ira-pro|*tač}} e.

==== Werger ====
{{werger-ser}}
{{werger-bin}}

=== Navdêr ===
{{navdêr|ku|z=m}}
# {{mane?|ku}}

==== Werger ====
{{werger-ser}}
{{werger-bin}}

==== Anagram ====
* {{anagram|ku|a=aeinprt|peritan}}</text>
      <sha1>jrl1j4k8deq8mjlxbky7jd63qa738pg</sha1>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Gadget-wikt.add-examples.js</title>
    <ns>8</ns>
    <id>1272598</id>
    <revision>
      <id>6903106</id>
      <parentid>6902292</parentid>
      <timestamp>2026-11-10T21:29:10Z</timestamp>
      <contributor>
        <username>Wikihez</username>
        <id>7344</id>
      </contributor>
      <minor />
      <comment>Script pages under 100 KB: part of the code moved to a second file; shared code in one place</comment>
      <origin>6903106</origin>
      <model>javascript</model>
      <format>text/javascript</format>
      <text bytes="66418" sha1="5lp6bg8x1kcbfpwypq0jybii6uqgunr" xml:space="preserve">// &lt;nowiki&gt;
// dependencies (in MediaWiki:Gadgets-definition): oojs, oojs-ui, ext.gadget.citoid-helper,
// ext.gadget.StorageUtils, ext.gadget.wikt.core, ext.gadget.wikt.edit, ext.gadget.wikt.cite
//
// A ResourceLoader package module: it require()s wikt.cite, so it cannot be loaded as a plain
// script. Load it through its gadget definition or the test loader.
//
// Two copies at once would fight over wikt.addExamples, so the second to arrive does nothing.
window.wikt = window.wikt || {};
wikt.addExamples = wikt.addExamples || {};
var alreadyLoaded = wikt.addExamples.loaded;
wikt.addExamples.loaded = true;
// Formats a string using {0}, {1}, ... placeholders.
if (!String.prototype.format) {
	String.prototype.format = function(var_args) {
		var args = arguments;
		return this.replace(/{(\d+)}/g, function(match, number) {
			return typeof args[number] !== &quot;undefined&quot; ? args[number] : match;
		});
	};
}

$(function() {
	&quot;use strict&quot;;

	if (alreadyLoaded) return;

	// Entries, reconstructions and sandboxes -- the same set DefSideBoxes and the wizard run on, from
	// wikt.core, so a page one of them works on is never a page this one quietly skips.
	if (!require(&quot;ext.gadget.wikt.core&quot;).sections.isEntryPage()) return;
	if (mw.config.get(&quot;wgPageName&quot;) === &quot;Destpêk&quot; || mw.config.get(&quot;wgArticleId&quot;) === 0) return;

	var NAME = &quot;[[Mediawiki:Gadget-wikt.add-examples|Nimûne zêde bike]]&quot;;

	// This gadget puts nothing on the page of its own. DefSideBoxes opens the form from its own
	// &quot;Nimûne/jêgirtin&quot; item, through openFor()/toggleFor() below, and takes the save over.
	window.wikt = window.wikt || {};
	wikt.addExamples = wikt.addExamples || {};
	// Lets another gadget take the save over: &quot;Qeyd bike&quot; becomes msg.add and the edit joins
	// that gadget's queue. Pass null to hand publishing back. Handler gets {transform, summary, done, fail}.
	wikt.addExamples.setSubmitHandler = function (fn) {
		wikt.addExamples.submitHandler = typeof fn === &quot;function&quot; ? fn : null;
	};

	// Re-clicking the caller's own trigger closes the form again.
	wikt.addExamples.toggleFor = function (el) {
		var toggle = $(el).data(&quot;wiktAddExampleToggle&quot;);
		if (!toggle) {
			return false;
		}
		toggle();
		return true;
	};
	wikt.addExamples.openFor = function (el) {
		var open = $(el).data(&quot;wiktAddExampleOpen&quot;);
		if (!open) {
			return false;
		}
		open();
		return true;
	};
	// Opens the form on one example already under the sense el: itemEl is its &lt;dd&gt;/&lt;li&gt; on the page.
	wikt.addExamples.editFor = function (el, itemEl) {
		var editItem = $(el).data(&quot;wiktAddExampleEdit&quot;);
		return !!editItem &amp;&amp; editItem(itemEl);
	};

	var VERSION = &quot;2.0&quot;;

	// Wiki markup for bold, both the button's label and what it inserts.
	var BOLD_MARKS = &quot;'''&quot;;

	// Persists form drafts (localStorage, cookie fallback) so unsaved text survives a failed submit.
	var draftStorage = new ObjectStorage(&quot;add_examples_draft&quot;, 1);

	// Citations are built by wikt.cite, the same module the wizard uses; Citoid lives in the
	// citoid-helper gadget. &quot;citoid&quot; as a _currentJederKey is a sentinel, not a real jederDefs key.
	var cite = require(&quot;ext.gadget.wikt.cite&quot;);
	var core = require(&quot;ext.gadget.wikt.core&quot;);
	var sections = core.sections;
	var msg = core.msg;
	var edit = require(&quot;ext.gadget.wikt.edit&quot;);
	var jederDefs = cite.jederDefs;
	var nlToSpace = cite.nlToSpace;
	var boldenPageTitle = cite.boldenPageTitle;
	var CATEGORY_TEMPLATE_KEY = cite.CATEGORY_KEY;
	var RAW_TEMPLATE_KEY = cite.RAW_KEY;

	// Params the form already has boxes for; skipped when building a Kategorî:Çavkanî template's fields.
	var CATEGORY_TEMPLATE_COVERED_PARAMS = cite.COVERED_PARAMS;

	// A param labeled exactly this is filled from the language dropdown instead of shown as a field,
	// and only when the template's own TemplateData declares one.
	var CATEGORY_TEMPLATE_LANG_LABEL = cite.LANG_LABEL;

	// &quot;span&quot; is the field's width in the 12-column grid the fields render in (see .add-example-jeder-fields
	// in the CSS and _setSourceType below) -- field ORDER here is also the grid's reading order.

	// Heading/definition-list helpers and the recognized POS heading names, shared with the wizard and
	// DefSideBoxes so all three read the same page structure.
	var headingOuter = sections.headingOuter;
	var languageCodeForOl = sections.languageCodeForOl;
	var sectionOrdinalWithinLanguage = sections.sectionOrdinalWithinLanguage;
	var eachLeafDefinition = sections.eachLeafDefinition;

	// A heading's section key, the wizard's unclassified &quot;=== Mane ===&quot; placeholder included: it holds
	// real definitions, so examples belong in it, even though it is not a part of speech.
	var sectionKeyOf = sections.sectionKeyOf;
	// Locating a section and a definition inside it is wikt.edit's job, shared with DefSideBoxes.
	var wt = edit.wt;

	// Template names that count as real examples, so an annotation template is not mistaken for one.
	var exampleTemplateNames = [&quot;jêder&quot;].concat(cite.USEX_NAMES, Object.keys(jederDefs));

	// The &quot;no example yet&quot; placeholder, with or without a language parameter.
	var EMPTY_EXAMPLE_MARKER = cite.EMPTY_EXAMPLE_MARKER;

	// The template name starting a &quot;#:&quot;/&quot;#*&quot; line, or null when the line does not start with one.
	function getLineTemplateName(line) {
		var m = /^#[:*]\s*\{\{\s*([^|}]+)/.exec(line);
		return m ? m[1].trim() : null;
	}

	// Where a template block starting at startIndex closes its braces, so multi-line calls stay whole.
	// The &quot;#&quot; run a definition line carries, so a sense's own annotations can be told from a sub-sense's:
	// &quot;#:&quot; belongs to &quot;#&quot;, &quot;##:&quot; to &quot;##&quot;.
	function senseDepth(definitionLine) {
		var m = /^#+/.exec(definitionLine || &quot;&quot;);
		return m ? m[0].length : 1;
	}

	// Any annotation of that sense -- &quot;#:&quot; an example, &quot;#*&quot; a citation -- at its own depth and no other.
	function annotationRegex(definitionLine) {
		return new RegExp(&quot;^#{&quot; + senseDepth(definitionLine) + &quot;}[:*]&quot;);
	}

	function citationRegex(definitionLine) {
		return new RegExp(&quot;^#{&quot; + senseDepth(definitionLine) + &quot;}\\*&quot;);
	}

	function findBlockEnd(lines, startIndex) {
		var depth = 0;
		var i = startIndex;
		for (; i &lt; lines.length; i++) {
			var opens = (lines[i].match(/\{\{/g) || []).length;
			var closes = (lines[i].match(/\}\}/g) || []).length;
			depth += opens - closes;
			if (depth &lt;= 0) {
				break;
			}
		}
		return i;
	}


	// URL of a template's own wiki page -- lets the user check a Kategorî:Çavkanî search result
	// before picking it (see showResults below).

	// Escapes str for interpolation into a RegExp: page titles carry regex metacharacters.
	var escapeRegExp = edit.util.escapeRegExp;


	// The readable half of an mw.Api rejection.
	var apiErrorMessage = edit.util.apiErrorMessage;

	// Same marker as the wizard's, positioned inside OOUI's own wrapper rather than a new one.
	var highlightLinebreak = edit.util.makeLinebreakHighlighter({
		prefix: &quot;add-example&quot;,
		wrap: false,
		dataKey: &quot;addExampleLinebreakBackdrop&quot;,
		title: &quot;Xeta n\u00fb d\u00ea wek &lt;br&gt; b\u00ea niv\u00eesandin&quot;
	});

	// Linebreak marking on the quote text and its translation/transcription only, not the
	// bibliographic fields.
	function watchForLinebreaks(widget) {
		widget.on(&quot;change&quot;, function() {
			highlightLinebreak(widget.$input[0]);
		});
	}

	// The shared grip from wikt.edit, kept as a sibling inside OOUI's own wrapper and without the saved
	// height: these fields are plain MultilineTextInputWidgets with no class to key one by.
	function makeManualResizable(textarea) {
		edit.util.makeManualResizable(textarea, {
			wrap: false,
			persist: false,
			gripClass: &quot;add-example-resize-grip&quot;,
			doneKey: &quot;addExampleResizableDone&quot;
		});
	}

	// Applies makeManualResizable to every textarea in `context` (itself or its descendants).
	function initManualResize(context) {
		var $context = $(context);
		var $textareas = $context.is(&quot;textarea&quot;) ? $context : $context.find(&quot;textarea&quot;);
		$textareas.each(function() {
			makeManualResizable(this);
		});
	}

	var api = new mw.Api();

	// Kategorî:Çavkanî's templates and their redirects, each redirect its own entry pointing at the

	// Language display name, read from the matching section's .besazimani link text.
	function languageNameForCode(code) {
		var $mark = $(&quot;.besazimani[id='&quot; + code + &quot;']&quot;).first();
		return $mark.length ? $mark.text().trim() : null;
	}

	// Whether the page title itself (accented Kurdish Latin letters included) is written in Latin script.
	var pageTitleIsLatin = !/[^\x00-\x7FÀ-ɏḀ-ỿ‘’]/.test(mw.config.get(&quot;wgTitle&quot;) || &quot;&quot;);

	// What an example looks like once rendered: Şablon:jêder's old marker, Modul:usex's containers and
	// Modul:quote's wrapper.
	var EXAMPLE_SELECTOR = &quot;.example, .benimune, .h-usage-example, .h-quotation, .citation-whole&quot;;

	// The words drawn for one example: the example or quotation itself, never its translation or source.
	function exampleTextOf($item) {
		var $own = $item.find(&quot;.e-example, .e-quotation&quot;).first();
		if ($own.length) {
			return $own.text();
		}
		var $italic = $item.children(&quot;i&quot;).first();
		return ($italic.length ? $italic : $item.clone().children(&quot;dl, ul, .dsb-example-toolbar&quot;).remove().end()).text();
	}

	// A definition's own citation group, and the last one when it has several: a new citation is
	// written after every &quot;#:&quot;/&quot;#*&quot; line already there.
	function exampleGroupOf($li) {
		return $li.children(&quot;ul&quot;).filter(function () {
			return $(this).children(&quot;li&quot;).children(EXAMPLE_SELECTOR).length &gt; 0;
		}).last();
	}

	// Every recognized part-of-speech section, down to each of its definitions. Section, language and
	// nesting all come from the page's own structure, never from an example that happens to sit there.

	// &quot;===&quot; on most entries, &quot;====&quot; where the senses hang off numbered etymologies.
	$(&quot;h3, h4&quot;).each(function() {
		var sectionType = sectionKeyOf($(this));
		if (!sectionType) {
			return; // not a recognized word-sense section (Bilêvkirin, Etîmolojî, Çavkanî, ...)
		}
		var sectionOrdinal = sectionOrdinalWithinLanguage($(this));

		// Forward-walk siblings to the definitions &lt;ol&gt;, skipping over a declension table/TemplateStyles/the
		// headword line; stop (nothing to attach to in this section) if another heading comes first instead.
		var $ol = null;
		for (var $cursor = headingOuter($(this)).next(); $cursor.length; $cursor = $cursor.next()) {
			if ($cursor.is(&quot;ol&quot;)) {
				$ol = $cursor;
				break;
			}
			if (sections.headingDepth($cursor)) {
				break;
			}
		}
		if (!$ol) {
			return;
		}

		var language = languageCodeForOl($ol);
		if (!language) {
			console.warn(&quot;Gadget-wikt.add-examples: nikaribe koda zimanê vê beşê bibîne.&quot;, $ol);
			return;
		}

		eachLeafDefinition($ol, function($li) {
			var definitionLevel = [];
			var $definitionItem = $li;
			while ($definitionItem.prop(&quot;tagName&quot;) === &quot;LI&quot;) {
				// Skip MediaWiki's empty &lt;li class=&quot;mw-empty-elt&quot;&gt; so indices match the &quot;#&quot; lines in wikitext.
				definitionLevel.splice(0, 0, $definitionItem.prevAll(&quot;li:not(.mw-empty-elt)&quot;).length);
				$definitionItem = $definitionItem.parent().parent();
			}
			definitionLevel.splice(0, 0, sectionType + &quot;|&quot; + sectionOrdinal);

			// Where a submitted example lands: after the group's last example, or after a hidden placeholder
			// when the definition has no group.
			var $group = exampleGroupOf($li);
			var $placeholder = $group.length ? $group.children(&quot;li&quot;).last()
				: $(&quot;&lt;li style='display:none'&gt;&lt;/li&gt;&quot;);
			var $formItem = $(&quot;&lt;li&gt;&quot;);
			// Never in the DOM: Form toggles it against the title, so it stays as the &quot;is a form built
			// for this sense&quot; handle. Nothing on the page opens this gadget -- DefSideBoxes does.
			var $button = $(&quot;&lt;span&gt;&quot;).hide();
			// Says which sense and language the open form is for; the row exists only while it is open.
			var $title = $(&quot;&lt;span class='add-example-form-title'&gt;&lt;/span&gt;&quot;).hide();
			$formItem.append($title);
			// The group the button lives in: the one on the page, or a new one. A &quot;ul&quot; under a definition
			// &quot;li&quot; starts hidden, so a new one needs the explicit display override.
			var $ul = $group.length ? $group
				: $(&quot;&lt;ul&gt;&quot;).css(&quot;display&quot;, &quot;block&quot;).append($placeholder);
			// A citation already carrying the site's own small edit link does not need a second one.
			$ul.find(&quot;span.example &gt; span.stubedit&quot;).remove();
			// The panel opens after $ul, not inside it: full width, clear of the list's hanging indent.
			// edit, when given, is {index, text}: the form opens on that example instead of on a new one.
			function setFormVisible(visible, edit) {
				if (visible) {
					// A sense with no example list of its own gets one on first open, not on page load:
					// an empty list on every sense of every entry is margin nobody asked for.
					// Editing shows its title inside the form, so the list row is only for a new example.
					if (!edit &amp;&amp; !$ul.parent().length) {
						$li.append($ul);
					}
					if (!edit &amp;&amp; !$formItem.parent().length) {
						$ul.append($formItem);
					}
					if (edit) {
						$formItem.detach();
					}
					if (!$button.form) {
						$title.text(&quot;Nimûneyeke bi &quot; + (languageNameForCode(language) || &quot;zimanekî nenas&quot;).toLowerCase() + &quot; lê zêde dikî.&quot;);
						var form = new Form($placeholder, $button, $title, language, definitionLevel);
						form.onHide = function () {
							$formItem.detach();
						};
						$ul.after(form.$element);
					}
					// Right under the example being edited; after the whole list when adding a new one.
					(edit ? $(edit.item) : $ul).after($button.form.$element);
					if (edit) {
						$button.form.beginEdit(edit.index, edit.text);
					} else {
						$button.form.endEdit();
						$button.form.setVisible(true);
					}
				} else if ($button.form) {
					$button.form.setVisible(false);
					$formItem.detach();
				}
				return false;
			}
			function openForm() { return setFormVisible(true); }
			function toggleForm() { return setFormVisible(!($button.form &amp;&amp; $button.form.isVisible())); }
			$li.data(&quot;wiktAddExampleOpen&quot;, openForm);
			$li.data(&quot;wiktAddExampleToggle&quot;, toggleForm);
			// Its place among the sense's examples finds the line; the words drawn for it confirm it.
			$li.data(&quot;wiktAddExampleEdit&quot;, function (itemEl) {
				var $item = $(itemEl);
				var index = sections.exampleItemsOf($li).index($item);
				if (index === -1) {
					return false;
				}
				setFormVisible(true, { index: index, text: exampleTextOf($item), item: itemEl });
				return true;
			});
		});
	});

	// Pulls the form panel out to the page's own edges, undoing the nested list's indent.
	function alignFormToPage($form) {
		var $container = $form.closest(&quot;.mw-parser-output&quot;);
		if (!$container.length) {
			return;
		}
		// Measure unshifted: this runs on every re-open, and a margin left from last time would otherwise
		// count as part of the indent and cancel the alignment out.
		$form.css(&quot;marginLeft&quot;, 0);
		var pad = parseFloat(window.getComputedStyle($container[0]).paddingLeft) || 0;
		var containerLeft = $container.offset().left + pad;
		var indent = $form.offset().left - containerLeft;
		$form.css({
			marginLeft: indent &gt; 0 ? -indent : 0,
			width: $container.width() + &quot;px&quot;
		});
	}

	/**
	 * language is the section the sense sits in: what the new example is tagged with, and what the
	 * wikitext lookup searches for. Never the language of an example that happens to be there.
	 */
	function Form($lastExample, $button, $title, language, definitionLevel) {
		var self = this;
		this._language = language;
		this._definitionLevel = definitionLevel;
		this._$lastExample = $lastExample;
		this._$button = $button;
		this._$button.form = this;
		this._$title = $title;
		// Where the title lives when adding; while editing it moves into the form itself.
		this._$titleHome = $title.parent();
		this._currentJederKey = &quot;&quot;;
		this._jederFieldWidgets = {};
		// Set once a template is picked in the Kategorî:Çavkanî mode (see _selectCategoryTemplate); the
		// canonical template title (without the &quot;Şablon:&quot; prefix), used as `sablon` in _doSubmit.
		this._categoryTemplateName = null;
		// Set by _renderCategoryTemplateFields if the picked template's TemplateData has a &quot;koda zimanî&quot; param;
		// that param's own key, used to emit &quot;&lt;key&gt;=&lt;language&gt;&quot; in _doSubmit -- null if no such param exists.
		this._categoryTemplateLangParamKey = null;
		// Set while an example already on the page is being edited (see beginEdit): {index, original,
		// example, key}, where key is the source type the line was read into.
		this._editing = null;
		this._addTitle = null;

		// The same prompt the wizard's own example box carries, so the two ask for an example in one
		// wording and the language it is to be written in is on screen here too.
		this._textInput = new OO.ui.MultilineTextInputWidget({
			rows: 4,
			placeholder: edit.util.examplePrompt(languageNameForCode(language), false)
		});
		var textInputLayout = new OO.ui.FieldLayout(this._textInput, {
			label: &quot;Metna nimûneyê&quot;,
			align: &quot;top&quot;,
		});
		// Under the text box: what will happen to the entry's own name on save (see boldenPageTitle), and
		// the one markup button worth having beside it. Purely informational, never blocks submitting.
		this._titleBoldHint = $(&quot;&lt;span class='add-example-title-bold-hint'&gt;&lt;/span&gt;&quot;);
		this._updateTitleBoldHint = function() {
			var text = self._textInput.getValue().trim();
			var title = mw.config.get(&quot;wgTitle&quot;);
			var missing = !!text &amp;&amp; !boldenPageTitle(text, title).bolded;
			self._titleBoldHint
				.toggleClass(&quot;add-example-title-bold-warn&quot;, missing)
				.html(missing
					? &quot;Sermade (&quot; + mw.html.escape(title) + &quot;) nehat dîtin; dê neyê &lt;b&gt;stûr&lt;/b&gt;kirin.&quot;
					: &quot;Sermade otomatîk tê &lt;b&gt;stûr&lt;/b&gt;kirin.&quot;);
			// Only where it is needed: when the name is bolded on its own there is nothing to reach for.
			self._boldButton.toggle(missing);
		};
		// Shown only while the name cannot be bolded on its own -- a form the matcher does not recognise,
		// or another word the writer wants bolded.
		this._boldButton = $(&quot;&lt;button type='button' class='add-example-bold-btn'&gt;&lt;/button&gt;&quot;).hide()
			.text(BOLD_MARKS).attr(&quot;title&quot;, &quot;Nivîsa hilbijartî stûr bike&quot;);
		this._boldButton.on(&quot;click&quot;, function(e) {
			e.preventDefault();
			var input = self._textInput.$input[0];
			var value = input.value;
			var start = input.selectionStart;
			var end = input.selectionEnd;
			var next, caret;
			if (start !== end) {
				next = value.slice(0, start) + BOLD_MARKS + value.slice(start, end) + BOLD_MARKS + value.slice(end);
				caret = end + BOLD_MARKS.length * 2;
			} else {
				// Nothing selected: just the marks, where the caret is. Typing carries on after them.
				next = value.slice(0, start) + BOLD_MARKS + value.slice(start);
				caret = start + BOLD_MARKS.length;
			}
			self._textInput.setValue(next);
			input.focus();
			input.setSelectionRange(caret, caret);
		});
		this._textTools = $(&quot;&lt;div class='add-example-text-tools'&gt;&lt;/div&gt;&quot;)
			.append(this._boldButton, this._titleBoldHint);
		this._updateTitleBoldHint();
		// A pasted citation switches to raw mode rather than being wrapped in a second {{nimûne}}: a whole
		// line with its marker and a bare template call both count. Only while the type is still citoid.
		this._maybeSwitchToRaw = function(value) {
			if (self._currentJederKey !== &quot;citoid&quot; ||
				!(cite.looksLikeCitationLine(value) || cite.looksLikeTemplate(value))) {
				return;
			}
			var menu = self._sourceTypeDropdown.getMenu();
			var item = menu.findItemFromData(RAW_TEMPLATE_KEY);
			if (item) {
				menu.chooseItem(item); // calls _setSourceType() itself
			}
		};
		this._textInput.on(&quot;change&quot;, function(value) {
			self._applyButton.setDisabled(!value);
			self._maybeSwitchToRaw(value);
			self._updateReadyHint();
			self._updateTitleBoldHint();
		});
		watchForLinebreaks(this._textInput);

		// Source type: free text, a jêder-* template, or &quot;citoid&quot; -- a sentinel meaning &quot;not yet detected&quot;,
		// switched automatically once a Citoid fetch succeeds.
		var sourceTypeMenuItems = [
			new OO.ui.MenuOptionWidget({ data: &quot;citoid&quot;, label: msg.citoidAuto }),
			new OO.ui.MenuOptionWidget({ data: &quot;&quot;, label: msg.sourceByHand }),
		];
		for (var jederKey in jederDefs) {
			if (jederDefs.hasOwnProperty(jederKey)) {
				sourceTypeMenuItems.push(new OO.ui.MenuOptionWidget({
					data: jederKey,
					label: jederDefs[jederKey].label,
				}));
			}
		}
		sourceTypeMenuItems.push(new OO.ui.MenuOptionWidget({
			data: CATEGORY_TEMPLATE_KEY,
			label: msg.sourceFromCategory,
		}));
		// Paste a finished citation into the example box and have it saved exactly as typed -- the quickest
		// way to reuse one jêgirtin across several entries.
		sourceTypeMenuItems.push(new OO.ui.MenuOptionWidget({
			data: RAW_TEMPLATE_KEY,
			label: msg.sourceRaw,
		}));
		// Shown only in raw mode, where there is nothing else to fill in.
		this._rawTemplateHint = new OO.ui.MessageWidget({
			type: &quot;notice&quot;,
			inline: true,
			label: &quot;Şablona temam li qada \&quot;Metna nimûneyê\&quot; binivîse \u2014 wek xwe tê qeydkirin. &quot;
				+ &quot;Tenê navê maddeyê yê di nav jêgirtin= de tê stûrkirin.&quot;,
			classes: [&quot;add-example-raw-hint&quot;],
		});
		this._rawTemplateHint.toggle(false);

		this._sourceTypeDropdown = new OO.ui.DropdownWidget({
			menu: { items: sourceTypeMenuItems },
			label: msg.citoidAuto,
		});
		var sourceTypeLayout = new OO.ui.FieldLayout(this._sourceTypeDropdown, {
			label: &quot;Şablona çavkaniyê&quot;,
			align: &quot;top&quot;,
		});
		this._sourceTypeDropdown.getMenu().on(&quot;choose&quot;, function(menuOption) {
			self._setSourceType(menuOption.getData());
		});

		this._sourceInput = new OO.ui.MultilineTextInputWidget();
		this._sourceInput.on(&quot;change&quot;, function() {
			self._updateReadyHint();
		});
		this._sourceInputLayout = new OO.ui.FieldLayout(this._sourceInput, {
			label: &quot;Çavkaniya nimûneyê&quot;,
			align: &quot;top&quot;,
		});

		// Visible in every mode: submit() reads it as &quot;url=&quot; regardless. The Citoid button sits beside it.
		this._sourceURLInput = new OO.ui.TextInputWidget({
			icon: &quot;link&quot;,
			placeholder: &quot;https://… an jî DOI/ISBN&quot;,
		});
		this._citoidButton = new OO.ui.ButtonWidget({
			label: msg.citoidFill,
			icon: &quot;download&quot;,
			flags: [&quot;progressive&quot;],
			title: &quot;Li gorî URL, DOI an ISBNya jorîn, malûmatan ji Citoid tîne û qadên şablona jêder-* otomatîk tijî dike.&quot;,
			classes: [&quot;add-example-citoid-fetch&quot;],
		});
		this._citoidButton.on(&quot;click&quot;, this._fillFromCitoid.bind(this));
		this._sourceURLInput.on(&quot;change&quot;, function() {
			self._updateReadyHint();
			self._autofillVideoTimestamp();
		});

		// URL input and its auto-fill button as one flex row; a bare OO.ui.Widget used as the container.
		this._urlRowWidget = new OO.ui.Widget({ classes: [&quot;add-example-url-row&quot;] });
		this._urlRowWidget.$element.append(this._sourceURLInput.$element, this._citoidButton.$element);
		this._sourceURLInputLayout = new OO.ui.FieldLayout(this._urlRowWidget, {
			label: &quot;Lînk, DOI an ISBNya çavkaniyê&quot;,
			align: &quot;top&quot;,
			help: &quot;Li qutiyê URL, DOI an ISBN binivîse û pê lê bike butona '&quot; + msg.citoidFill + &quot;' da ku otomatîk çavkanî were dagirtin.&quot;,
			helpInline: true,
		});
		// Same wording as above, so the initial _setSourceType(&quot;citoid&quot;) rebuilds nothing.
		this._urlFieldIsFreeTextWording = false;

		// Shown right after a successful Citoid fetch (see _fillFromCitoid); hidden again on clear.
		this._citoidSuccessMsg = $(&quot;&lt;span class='add-example-citoid-success'&gt;&lt;/span&gt;&quot;).text(msg.citoidFilled).hide();
		// Shown when Citoid found nothing and a form was opened to be filled by hand.
		this._citoidFallbackMsg = $(&quot;&lt;span class='add-example-citoid-fallback'&gt;&lt;/span&gt;&quot;).hide();

		// Clears the URL field and any filled jêder-* fields without touching the example text/translation.
		this._citoidClearButton = new OO.ui.ButtonWidget({
			label: &quot;Vala bike&quot;,
			icon: &quot;trash&quot;,
			framed: false,
			title: &quot;Lînkê û qadên jêder-* yên vê beşê vala bike&quot;,
			classes: [&quot;add-example-citoid-clear&quot;],
		});
		this._citoidClearButton.on(&quot;click&quot;, function() {
			self._sourceURLInput.setValue(&quot;&quot;);
			self._citoidSuccessMsg.hide();
			self._citoidFallbackMsg.hide();
			Object.keys(self._jederFieldWidgets).forEach(function(key) {
				self._jederFieldWidgets[key].setValue(&quot;&quot;);
			});
		});

		// Plain div (not OO.ui.FieldsetLayout) so the grid CSS class applies directly to the field items.
		this._jederFieldsFieldset = $(&quot;&lt;div class='add-example-jeder-fields'&gt;&quot;);

		// Header and clear button above the fields grid. Only meaningful once a real jêder-* template is
		// active, so the whole section toggles together in _setSourceType().
		this._jederSection = $(&quot;&lt;div class='add-example-jeder-section'&gt;&quot;).append(
			$(&quot;&lt;div class='add-example-jeder-header'&gt;&quot;)
				.append($(&quot;&lt;span class='add-example-jeder-header-label'&gt;Malûmatên çavkaniyê&lt;/span&gt;&quot;))
				.append(this._citoidClearButton.$element),
			this._jederFieldsFieldset
		);

		// wikt.cite's picker, the one the wizard and DefSideBoxes show. Sits under the source-type
		// dropdown, not in the fields section, and is built once so switching modes keeps its handlers.
		var categoryPicker = cite.buildCategoryTemplateSearch({
			describe: true,
			onPick: function (entry) {
				self._selectCategoryTemplate(entry);
			}
		});
		this._categoryTemplateInput = categoryPicker.$input;
		this._categoryTemplateStatus = categoryPicker.$status;
		this._categoryTemplateSearchRow = categoryPicker.$element
			.addClass(&quot;add-example-cat-tpl-search-row&quot;).hide();

		this._translationInput = new OO.ui.MultilineTextInputWidget({ rows: 4 });
		var translationInputLayout = new OO.ui.FieldLayout(this._translationInput, {
			// A Kurmancî example gets an explanation rather than a translation.
			label: language === &quot;ku&quot; ? &quot;Îzaheke kurmancî ya nimûneyê&quot; : &quot;Tercimeya kurmancî ya nimûneyê&quot;,
			align: &quot;top&quot;,
		});
		watchForLinebreaks(this._translationInput);

		this._transcriptionInput = new OO.ui.MultilineTextInputWidget({ rows: 4 });
		var transcriptionInputLayout = new OO.ui.FieldLayout(this._transcriptionInput, {
			label: &quot;Translîterasyona nimûneyê&quot;,
			align: &quot;top&quot;,
			help: &quot;Tenê lê zêde bike eger metna di nimûneyê de bi alfabeya latînî nehatibe nivîsandin.&quot;,
			helpInline: true,
		});
		watchForLinebreaks(this._transcriptionInput);

		this._applyButton = new OO.ui.ButtonWidget({
			label: &quot;Qeyd bike&quot;,
			icon: &quot;check&quot;,
			title: &quot;Nimûneyê ji bo vê tarîfê nimûneyê lê zêde bike&quot;,
			flags: [&quot;progressive&quot;, &quot;primary&quot;],
			disabled: true,
		});
		this._applyButton.on(&quot;click&quot;, this.submit.bind(this));

		// Reactive &quot;ready to submit&quot; hint next to Qeyd bike: no text yet, text but no source (still submittable
		// as a bare {{nimûne}}), or fully ready -- kept in sync by _updateReadyHint(), wired to every field below.
		this._readyHint = $(&quot;&lt;span class='add-example-ready-hint'&gt;&lt;/span&gt;&quot;).text(&quot;Metna nimûneyê lazim e.&quot;);
		// True while a Citoid-eligible URL is typed but unfetched and no jêder field has been filled by
		// hand -- the &quot;looks done but isn't&quot; case.
		this._citoidPending = function() {
			return self._currentJederKey !== &quot;&quot; &amp;&amp;
				self._currentJederKey !== CATEGORY_TEMPLATE_KEY &amp;&amp;
				self._currentJederKey !== RAW_TEMPLATE_KEY &amp;&amp;
				!!self._sourceURLInput.getValue().trim() &amp;&amp;
				!self._citoidSuccessMsg.is(&quot;:visible&quot;) &amp;&amp;
				!Object.keys(self._jederFieldWidgets).some(function(key) {
					return self._jederFieldWidgets[key].getValue().trim();
				});
		};
		// A Kurmancî jêgirtin takes no translation or explanation, only a {{nimûne}} does. An edited line
		// that already has one keeps its box.
		this._syncTranslationBox = function() {
			if (self._language !== &quot;ku&quot;) {
				return;
			}
			var key = self._currentJederKey;
			var isQuote = key === RAW_TEMPLATE_KEY || key === CATEGORY_TEMPLATE_KEY || !!jederDefs[key] ||
				!!self._sourceInput.getValue().trim() || !!self._sourceURLInput.getValue().trim();
			translationInputLayout.toggle(!isQuote ||
				!!(self._editing &amp;&amp; self._translationInput.getValue().trim()));
		};
		this._updateReadyHint = function() {
			self._syncTranslationBox();
			if (!self._textInput.getValue()) {
				self._readyHint.text(&quot;Metna nimûneyê lazim e.&quot;);
				return;
			}
			if (self._citoidPending()) {
				self._readyHint.text(&quot;Pêşî '&quot; + msg.citoidFill + &quot;' bitikîne.&quot;);
				return;
			}
			// Raw mode carries its own source inside the pasted template, so there is nothing else to ask for.
			if (self._currentJederKey === RAW_TEMPLATE_KEY) {
				self._readyHint.text(&quot;Hazir e.&quot;);
				return;
			}
			var hasSource = self._sourceInput.getValue().trim() || self._sourceURLInput.getValue().trim() ||
				Object.keys(self._jederFieldWidgets).some(function(key) {
					return self._jederFieldWidgets[key].getValue().trim();
				});
			self._readyHint.text(hasSource ? &quot;Hazir e.&quot; : &quot;Çavkanî nehatiye dayîn.&quot;);
		};

		// Prefills Dem from the URL's own &quot;t=&quot; once jêder-vîdeo is active; never overwrites typed text.
		this._autofillVideoTimestamp = function() {
			var demWidget = self._jederFieldWidgets.dem;
			if (self._currentJederKey !== &quot;jêder-vîdeo&quot; || !demWidget || demWidget.getValue().trim()) {
				return;
			}
			var dem = wikt.citoid.extractVideoTimestamp(self._sourceURLInput.getValue().trim());
			if (dem &amp;&amp; !demWidget.getValue().trim()) {
				demWidget.setValue(dem);
			}
		};

		// framed:false (+ the &quot;destructive&quot; flag for the red text/hover) matches the mockup's borderless
		// &quot;Betal bike&quot; -- a plain colored link rather than a boxed button, distinguishing it from Paqij bike.
		this._cancelButton = new OO.ui.ButtonWidget({
			label: &quot;Betal bike&quot;,
			icon: &quot;close&quot;,
			title: &quot;Formê bigire&quot;,
			flags: [&quot;destructive&quot;],
			framed: false,
		});
		this._cancelButton.on(&quot;click&quot;, function() {
			self.setVisible(false);
		});

		this._clearButton = new OO.ui.ButtonWidget({
			label: &quot;Paqij bike&quot;,
			icon: &quot;trash&quot;,
			title: &quot;Hemû qadan vala bike û pêşnûyisên hilanîbûyî jê bibe&quot;,
		});
		this._clearButton.on(&quot;click&quot;, function() {
			self.clear();
			self._clearDraft();
		});

		// Only while an example on the page is being edited.
		this._deleteButton = new OO.ui.ButtonWidget({
			label: &quot;Jê bibe&quot;,
			icon: &quot;trash&quot;,
			flags: [&quot;destructive&quot;],
		});
		this._deleteButton.toggle(false);
		this._deleteButton.on(&quot;click&quot;, function() {
			OO.ui.confirm(&quot;Ev nimûne dê were rakirin. Dewam bike?&quot;).done(function(ok) {
				if (ok) {
					self._submitDelete();
				}
			});
		});

		// A CSS spinner rather than a Commons GIF: no request, and it follows dark/light mode.
		this._loadingImage = new OO.ui.Widget({
			classes: [&quot;add-example-loading&quot;],
		});
		// The ring alone says nothing to a reader who has asked for less motion: MediaWiki's own
		// reduced-motion reset cuts every animation to 0.01ms, so it never turns for them. The words
		// beside it carry the state either way.
		this._loadingImage.$element.append(
			$('&lt;span class=&quot;add-example-spinner&quot; aria-hidden=&quot;true&quot;&gt;&lt;/span&gt;'),
			$('&lt;span class=&quot;add-example-loading-label&quot;&gt;&lt;/span&gt;').text(msg.loading)
		);
		this._loadingImage.toggle(false);

		// Two-column top: example text (with translation/transliteration for non-ku) on the left, source
		// type and link on the right. Plain divs, so the CSS can lay them out as a grid.
		// The translation box is there for Kurmancî too: {{nimûne}} takes one for every language.
		var $topLeft = $(&quot;&lt;div class='add-example-top-col'&gt;&quot;).append(textInputLayout.$element, this._textTools,
			translationInputLayout.$element);
		if (!pageTitleIsLatin) {
			$topLeft.append(transcriptionInputLayout.$element);
		}
		// Kept for _fill, which adds either box when an edited line already carries one.
		this._$topLeft = $topLeft;
		this._translationInputLayout = translationInputLayout;
		this._transcriptionInputLayout = transcriptionInputLayout;
		var $topRight = $(&quot;&lt;div class='add-example-top-col'&gt;&quot;).append(
			sourceTypeLayout.$element,
			this._categoryTemplateSearchRow,
			this._rawTemplateHint.$element,
			this._sourceInputLayout.$element,
			this._sourceURLInputLayout.$element,
			this._citoidSuccessMsg,
			this._citoidFallbackMsg
		);
		var $topGrid = $(&quot;&lt;div class='add-example-top-grid'&gt;&quot;).append($topLeft, $topRight);

		// Saved on the instance (not just a local var) so _setSourceType() can swap the URL field's label/help
		// wording in and out of it when switching to/from free text (see the FieldLayout replaceWith() there).
		this._fieldsLayout = $(&quot;&lt;div class='add-example-fieldset'&gt;&quot;).append($topGrid, this._jederSection);

		// Bottom action row: Qeyd bike (+ spinner and hint), a spacer, then Paqij bike and Betal bike. A
		// flex div rather than an OOUI layout, so the hint and spacer can sit among the widgets.
		var $buttonsRow = $(&quot;&lt;div class='add-example-main-buttons'&gt;&quot;).append(
			this._applyButton.$element,
			this._loadingImage.$element,
			this._readyHint,
			$(&quot;&lt;span class='add-example-buttons-spacer'&gt;&lt;/span&gt;&quot;),
			this._deleteButton.$element,
			this._clearButton.$element,
			this._cancelButton.$element
		);

		this._frame = new OO.ui.PanelLayout({
			id: &quot;add-example-definition-{0}-form&quot;.format(this._definitionLevel.join(&quot;-&quot;)),
			classes: [&quot;add-example-form&quot;],
			expanded: false,
		});
		this._frame.$element.append(this._fieldsLayout, $buttonsRow);

		// selectItemByData() does not fire &quot;choose&quot;, so the initial mode is set up by hand.
		this._sourceTypeDropdown.getMenu().selectItemByData(&quot;citoid&quot;);
		this._setSourceType(&quot;citoid&quot;);
		initManualResize(this._frame.$element);
	}

	Form.prototype = {
		// Returns the jQuery object for this form.
		get $element() {
			return this._frame.$element;
		},

		// Switches the source section between free text, Citoid auto-detect and a chosen jêder-* template,
		// rebuilding the field list. The URL field stays visible in every mode.
		_setSourceType: function(jederKey) {
			var self = this;
			this._currentJederKey = jederKey;
			this._citoidFallbackMsg.hide();
			this._jederFieldsFieldset.empty();
			this._jederFieldWidgets = {};
			this._categoryTemplateName = null;
			this._categoryTemplateLangParamKey = null;

			var isRealJederKey = jederKey &amp;&amp; jederDefs[jederKey];
			var isCategoryTemplateKey = jederKey === CATEGORY_TEMPLATE_KEY;
			var isRawTemplate = jederKey === RAW_TEMPLATE_KEY;
			if (isRealJederKey) {
				var def = jederDefs[jederKey];
				def.fields.forEach(function(field) {
					var widget = field.multiline
						? new OO.ui.MultilineTextInputWidget({ rows: 2, autosize: false })
						: new OO.ui.TextInputWidget();
					self._jederFieldWidgets[field.key] = widget;
					widget.on(&quot;change&quot;, function(value) {
						// sal and tarîx say the same thing twice and Modul:quote refuses both; filling one
						// clears the other rather than letting the citation break on save.
						var partner = value &amp;&amp; cite.exclusivePartner(field.key);
						if (partner &amp;&amp; self._jederFieldWidgets[partner]) {
							self._jederFieldWidgets[partner].setValue(&quot;&quot;);
						}
						self._updateReadyHint();
					});
					var layout = new OO.ui.FieldLayout(widget, {
						label: field.label,
						align: &quot;top&quot;,
						classes: [&quot;add-example-field-span-&quot; + (field.span || 4)],
					});
					self._jederFieldsFieldset.append(layout.$element);
				});
			}
			// The box lives in $topRight always; here it is only shown for this mode, and reset on the way out
			// so a stale query does not linger.
			this._categoryTemplateSearchRow.toggle(isCategoryTemplateKey);
			// Raw mode has no source fields of its own: the citation is already written out in full.
			this._rawTemplateHint.toggle(isRawTemplate);
			if (!isCategoryTemplateKey) {
				this._categoryTemplateInput.val(&quot;&quot;);
			}
			// The fields grid is for a real jêder-* template. The Kategorî:Çavkanî picker shows it only once a
			// template is picked (see _selectCategoryTemplate).
			this._jederSection.toggle(!!isRealJederKey);
			// Free text textarea only for &quot;&quot; (free text); hidden for &quot;citoid&quot; and any real jêder-* key.
			this._sourceInputLayout.toggle(jederKey === &quot;&quot;);
			// No Citoid button for free text (nothing to fill) or the Kategorî:Çavkanî picker (no mapping for
			// an arbitrary template); shown for auto-detect and any jêder-* key.
			this._citoidButton.toggle(jederKey !== &quot;&quot; &amp;&amp; !isCategoryTemplateKey &amp;&amp; !isRawTemplate);

			// Plain &quot;attach a link&quot; wording for free text, Citoid wording otherwise. Rebuilt only when crossing
			// that boundary.
			var isFreeText = jederKey === &quot;&quot;;
			if (this._urlFieldIsFreeTextWording !== isFreeText) {
				this._urlFieldIsFreeTextWording = isFreeText;
				// On the &lt;input&gt; itself: TextInputWidget has no setter for its placeholder.
				this._sourceURLInput.$input.attr(&quot;placeholder&quot;, isFreeText ? &quot;URLyeke wekî https://…&quot; : &quot;URLyek wekî https://… an jî DOI/ISBN&quot;);
				var $oldLayout = this._sourceURLInputLayout.$element;
				// Re-wraps the SAME _urlRowWidget (still holding _sourceURLInput + _citoidButton) in a new
				// FieldLayout with the new label/help; the widget's $element moves along with it.
				this._sourceURLInputLayout = new OO.ui.FieldLayout(this._urlRowWidget, isFreeText ? {
					label: &quot;Adresa webê ya nimûneyê&quot;,
					align: &quot;top&quot;,
					help: &quot;Tenê binivîse eger lînk jixwe di referansa çavkaniyê de tinebe.&quot;,
					helpInline: true,
				} : {
					label: &quot;Lînk, DOI an ISBNya çavkaniyê&quot;,
					align: &quot;top&quot;,
					help: &quot;Ev dibe lînka çavkaniyê (url=). Ji bo şablonên jêder-*, dikare bi Citoid an bi destan jî bên dagirtin.&quot;,
					helpInline: true,
				});
				$oldLayout.replaceWith(this._sourceURLInputLayout.$element);
			}
			// The URL/Citoid row is normally always visible (see the constructor comment), but Citoid has no
			// mapping for an arbitrary Kategorî:Çavkanî template, so it'd just be dead UI in that one mode.
			this._sourceURLInputLayout.toggle(!isCategoryTemplateKey &amp;&amp; !isRawTemplate);
			this._autofillVideoTimestamp();
			this._updateReadyHint();
			initManualResize(this._jederFieldsFieldset); // covers a freshly-rebuilt &quot;sernav&quot; field (jêder-*); the Kategorî:Çavkanî picker's own fields are resized separately once picked, see _renderCategoryTemplateFields
		},

		// Wires the search box's handlers and starts the template fetch. Called once: the box lives in
		// $topRight and is only shown or hidden by _setSourceType.
		// Records the picked template's canonical name -- a redirect resolves to its target -- and shows
		// its parameter fields.
		_selectCategoryTemplate: function(entry) {
			// Left as the plain label (not &quot;label → target&quot;) -- putting the arrow in the input's own value
			// would get re-used as the search query if the box is focused again to pick something else.
			this._categoryTemplateInput.val(entry.label);
			this._categoryTemplateName = entry.target;
			this._jederSection.toggle(true);
			return this._renderCategoryTemplateFields(entry.target);
		},

		// One text input per TemplateData param of `name`, into the shared &quot;Malûmatên çavkaniyê&quot; grid, or a
		// lone &quot;Rûpel&quot; box when the template has no TemplateData.
		_renderCategoryTemplateFields: function(name) {
			var self = this;
			this._jederFieldsFieldset.empty();
			this._jederFieldWidgets = {};
			this._categoryTemplateLangParamKey = null;
			return cite.templateParams(name).then(function(params) {
				// A param labeled &quot;koda zimanî&quot; is filled from the language dropdown: found before filtering, so
				// it is left out of the fields and emitted by _doSubmit.
				(params || []).forEach(function(p) {
					if ((p.label || &quot;&quot;).trim().toLowerCase() === CATEGORY_TEMPLATE_LANG_LABEL) {
						self._categoryTemplateLangParamKey = p.key;
					}
				});
				var filtered = (params || []).filter(function(p) {
					return CATEGORY_TEMPLATE_COVERED_PARAMS.indexOf(p.key) === -1 &amp;&amp; p.key !== self._categoryTemplateLangParamKey;
				});
				var list = filtered.length ? filtered : [{ key: &quot;rûpel&quot;, label: &quot;Rûpel&quot;, required: false }];
				list.forEach(function(p) {
					// Reuse the jêder-* field's own width and multiline when the key matches one (cite.fieldSize).
					var sizeHint = cite.fieldSize(p.key);
					var widget = (sizeHint &amp;&amp; sizeHint.multiline)
						? new OO.ui.MultilineTextInputWidget({ rows: 2, autosize: false })
						: new OO.ui.TextInputWidget();
					self._jederFieldWidgets[p.key] = widget;
					widget.on(&quot;change&quot;, function() {
						self._updateReadyHint();
					});
					var layout = new OO.ui.FieldLayout(widget, {
						label: p.label,
						align: &quot;top&quot;,
						classes: [&quot;add-example-field-span-&quot; + (sizeHint ? sizeHint.span : 4)],
					});
					self._jederFieldsFieldset.append(layout.$element);
				});
				self._updateReadyHint();
				initManualResize(self._jederFieldsFieldset); // matters now that a matched key like &quot;sernav&quot; can render multiline
			});
		},
		// Fetches data via wikt.citoid, picks the matching jêder-* template, and fills its empty fields.
		_fillFromCitoid: function() {
			var self = this;
			var query = this._sourceURLInput.getValue().trim();

			if (!query) {
				mw.notify(msg.citoidNeedsUrl);
				return;
			}

			this._citoidButton.setDisabled(true);
			this._loadingImage.toggle(true);

			cite.fetchFromCitoid(query).then(function(result) {
				// Citoid may pick the type only while none is chosen; a hand-picked one is kept.
				var wasAutoDetect = self._currentJederKey === &quot;citoid&quot;;
				if (wasAutoDetect) {
					var menu = self._sourceTypeDropdown.getMenu();
					var item = menu.findItemFromData(result.jederKey);
					if (item) {
						menu.chooseItem(item); // this calls _setSourceType(jederKey) automatically
					}
				}
				var targetJederKey = self._currentJederKey;

				// Citoid shaped its fields for the type it detected; re-derive them when the active template
				// differs.
				var fields = targetJederKey === result.jederKey ? result.fields
					: cite.citoidFieldsFor(targetJederKey, result.raw, query);

				Object.keys(fields).forEach(function(key) {
					var widget = self._jederFieldWidgets[key];
					if (widget &amp;&amp; !widget.getValue()) {
						widget.setValue(fields[key]);
					}
				});

				self._citoidFallbackMsg.hide();
				self._citoidSuccessMsg.show();
				self._updateReadyHint();
				mw.notify(&quot;Malûmat ji Citoid hatin barkirin.&quot;);
			}, function() {
				self._openFormForUnfound(query);
			}).always(function() {
				self._citoidButton.setDisabled(false);
				self._loadingImage.toggle(false);
			});
		},
		// Citoid found nothing: open the form the query points to (Kitêb for an ISBN, Kovar for a DOI,
		// Websîte for a link, free text otherwise) and say what is left to fill in by hand.
		_openFormForUnfound: function(query) {
			var menu = this._sourceTypeDropdown.getMenu();
			var id = wikt.citoid.identifierOf(query);
			var isLink = /^https?:\/\//i.test(query);
			var opened = this._currentJederKey === &quot;citoid&quot;;
			if (opened) {
				menu.chooseItem(menu.findItemFromData(id ? id.jederKey : isLink ? &quot;jêder-websîte&quot; : &quot;&quot;)); // calls _setSourceType()
			}
			var key = this._currentJederKey;
			var idWidget = id &amp;&amp; this._jederFieldWidgets[id.field];
			if (idWidget) {
				// The identifier now has its own field, so the link box would only repeat it as url=.
				if (!idWidget.getValue()) {
					idWidget.setValue(id.value);
				}
				this._sourceURLInput.setValue(&quot;&quot;);
			}
			var siteWidget = isLink &amp;&amp; this._jederFieldWidgets[&quot;websîte&quot;];
			if (siteWidget &amp;&amp; !siteWidget.getValue()) {
				siteWidget.setValue(wikt.citoid.websiteNameForUrl(query));
			}
			var text;
			if (key === &quot;&quot;) {
				if (!this._sourceInput.getValue().trim()) {
					this._sourceInput.setValue(query);
				}
				this._sourceURLInput.setValue(&quot;&quot;);
				text = &quot;Ev ne lînk, DOI an ISBN e. Çavkaniyê li qutiya «Çavkaniya nimûneyê» bi destê xwe binivîse.&quot;;
			} else {
				text = &quot;Citoid malûmat nedîtin. &quot; + (opened ? &quot;Forma «&quot; + jederDefs[key].label + &quot;» hate vekirin: qadên&quot; : &quot;Qadên&quot;) +
					&quot; mayî bi destê xwe tijî bike.&quot;;
			}
			this._citoidSuccessMsg.hide();
			this._citoidFallbackMsg.text(text).show();
			this._updateReadyHint();
		},
		// Shows or hides the form and restores any saved draft. The title takes the button's place while
		// open; the button stays put for when it closes.
		isVisible: function() {
			return this._frame.isVisible();
		},

		setVisible: function(visible) {
			this._$button.toggle(!visible);
			this._$title.toggle(visible);
			this._frame.toggle(visible);
			// Closing from the form's own &quot;Betal bike&quot; has to take the row away too, or the empty &lt;li&gt;
			// it lives in is left behind as a bullet with nothing after it.
			if (!visible &amp;&amp; typeof this.onHide === &quot;function&quot;) {
				this.onHide();
			}
			if (visible) {
				// Says what the button will actually do: publish now, or join whoever has taken the save
				// over. Set here rather than at build time, since the owner may install itself later.
				this._applyButton.setLabel(wikt.addExamples.submitHandler ? msg.add : &quot;Qeyd bike&quot;);
				alignFormToPage(this._frame.$element);
				// A draft belongs to a new example; an edited one opens with what its line says.
				var draft = this._editing ? {} : (draftStorage.Get() || {});
				if (!this._textInput.getValue() &amp;&amp; draft.text) {
					this._textInput.setValue(draft.text);
				}
				if (!this._sourceInput.getValue() &amp;&amp; draft.source) {
					this._sourceInput.setValue(draft.source);
				}
				if (!this._sourceURLInput.getValue() &amp;&amp; draft.sourceURL) {
					this._sourceURLInput.setValue(draft.sourceURL);
				}
				if (!this._translationInput.getValue() &amp;&amp; draft.translation) {
					this._translationInput.setValue(draft.translation);
				}
				if (!this._transcriptionInput.getValue() &amp;&amp; draft.transcription) {
					this._transcriptionInput.setValue(draft.transcription);
				}
			}
		},

		// Opens the form on the index-th example of this sense. drawnText is what the page shows for it: the
		// line found at that place has to say the same before anything from it is put in the form.
		beginEdit: function(index, drawnText) {
			var self = this;
			this.clear();
			this._editing = { index: index, original: null, example: null, key: null };
			if (this._addTitle === null) {
				this._addTitle = this._$title.text();
			}
			this._$title.text(&quot;Vê nimûneyê diguherînî.&quot;);
			this._frame.$element.prepend(this._$title);
			this._deleteButton.toggle(true);
			this.setVisible(true);
			this._applyButton.setDisabled(true);
			this._deleteButton.setDisabled(true);
			this._loadingImage.toggle(true);
			var sectionKeyParts = this._definitionLevel[0].split(&quot;|&quot;);
			api.get({
				action: &quot;query&quot;,
				prop: &quot;revisions&quot;,
				titles: mw.config.get(&quot;wgPageName&quot;),
				rvprop: &quot;content&quot;,
				rvslots: &quot;main&quot;,
				formatversion: 2
			}).then(function(data) {
				var editing = self._editing;
				if (!editing || editing.index !== index || editing.original !== null) {
					return; // closed, or opened on another example, while this was loading
				}
				var content = data.query.pages[0].revisions[0].slots.main.content;
				// The page as it will read once the queued changes are saved, so an example already edited
				// in the queue is found as it is drawn.
				if (typeof wikt.addExamples.pendingContent === &quot;function&quot;) {
					content = wikt.addExamples.pendingContent(content);
				}
				var loc = wt.locateSection(content, self._language, sectionKeyParts[0], parseInt(sectionKeyParts[1], 10));
				var def = wt.findDefinitionLine(loc.lines, loc.posLineIndex, self._definitionLevel);
				var block = cite.exampleBlocks(loc.lines, def).filter(function(b) {
					return b.example;
				})[index];
				if (!block || !cite.exampleMatches(drawnText, block.example)) {
					throw new edit.util.SubmitAbort(&quot;Ev nimûne di wîkîtextê de nehat dîtin — rûpelê nû bike û dîsa biceribîne.&quot;);
				}
				editing.original = block.text;
				editing.example = block.example;
				return self._fill(block.example).then(function(aliasMap) {
					editing.aliases = aliasMap;
					editing.key = self._currentJederKey;
					self._syncTranslationBox();
					self._deleteButton.setDisabled(false);
					self._loadingImage.toggle(false);
				});
			}).catch(function(err) {
				self._loadingImage.toggle(false);
				mw.notify(err instanceof edit.util.SubmitAbort ? err.message : &quot;Nikare muhtewaya heyî bixwîne.&quot;, { type: &quot;error&quot; });
				self.setVisible(false);
				self.endEdit();
			});
		},

		// Leaves edit mode: the next time the form opens, it adds a new example again.
		endEdit: function() {
			if (!this._editing) {
				return;
			}
			this._editing = null;
			this._deleteButton.toggle(false);
			if (this._addTitle !== null) {
				this._$title.text(this._addTitle);
			}
			this._$titleHome.append(this._$title);
			this.clear();
		},

		// Puts a line read by cite.parseCitationLine() into the form. A plain italic line and every
		// {{nimûne}} redirect read as {{nimûne}}, so saving writes them as that. Resolves once the fields
		// that depend on the template's own parameters -- a Kategorî:Çavkanî template's boxes, an alias
		// such as &quot;r=&quot; for &quot;rûpel=&quot; -- are drawn and filled.
		_fill: function(example) {
			var self = this;
			var key = example.mode === &quot;jeder&quot; ? example.template
				: example.mode === &quot;category&quot; ? CATEGORY_TEMPLATE_KEY
				: example.mode === &quot;raw&quot; ? RAW_TEMPLATE_KEY
				: &quot;&quot;;
			this._sourceTypeDropdown.getMenu().selectItemByData(key);
			this._setSourceType(key);
			this._sourceInput.setValue(example.source);
			this._sourceURLInput.setValue(example.sourceURL);
			this._transcriptionInput.setValue(example.transcription);
			var drawn = example.mode === &quot;category&quot;
				? this._selectCategoryTemplate({ label: example.template, target: example.template })
				: $.Deferred().resolve().promise();
			var aliasTemplate = example.mode === &quot;jeder&quot; || example.mode === &quot;category&quot; ? example.template
				: example.mode === &quot;nimune&quot; ? &quot;nimûne&quot;
				: example.mode === &quot;source&quot; ? &quot;jêder&quot;
				: null;
			var aliases = aliasTemplate ? cite.templateAliases(aliasTemplate) : $.Deferred().resolve({}).promise();
			return $.when(drawn, aliases).then(function(_, aliasMap) {
				cite.applyAliases(example, aliasMap || {}, Object.keys(self._jederFieldWidgets));
				// buildCitation() writes the language parameter itself.
				var langKey = self._categoryTemplateLangParamKey;
				if (langKey) {
					example.extra = example.extra.filter(function(param) {
						return $.trim(param.split(&quot;=&quot;)[0]) !== langKey;
					});
				}
				self._textInput.setValue(example.text);
				self._translationInput.setValue(example.translation);
				Object.keys(example.fields).forEach(function(field) {
					self._jederFieldWidgets[field].setValue(example.fields[field]);
				});
				// A box the form leaves out for this language still opens when the line already has something in it.
				[[example.translation, self._translationInputLayout], [example.transcription, self._transcriptionInputLayout]]
					.forEach(function(pair) {
						if (pair[0] &amp;&amp; !$.contains(self._$topLeft[0], pair[1].$element[0])) {
							self._$topLeft.append(pair[1].$element);
						}
					});
				// Kept for the save, which puts the rebuilt line's parameters back in the page's order.
				return aliasMap || {};
			});
		},

		// Removes the example being edited, through the same hand-over as a save.
		_submitDelete: function() {
			var self = this;
			function settle() {
				self._deleteButton.setDisabled(false);
				self._applyButton.setDisabled(!self._textInput.getValue());
			}
			this._applyButton.setDisabled(true);
			this._deleteButton.setDisabled(true);
			this._sendReplacement(null, &quot;−nimûneya bikaranînê bi amûra « {0} » (v{1}).&quot;.format(NAME, VERSION), settle, function(message) {
				mw.notify(message || msg.saveFailed, { type: &quot;error&quot; });
				settle();
			});
		},

		// Replaces the example being edited with code, or removes it when code is null: queued with
		// DefSideBoxes when it has taken the save over, published at once otherwise.
		_sendReplacement: function(code, summary, reenable, error) {
			var self = this;
			var editing = this._editing;
			var parts = this._definitionLevel[0].split(&quot;|&quot;);
			var language = this._language;
			var definitionLevel = this._definitionLevel;
			function transform(revision) {
				return {
					text: cite.replaceExample(revision.content, language, parts[0], parseInt(parts[1], 10),
						definitionLevel, editing.index, editing.original, code),
					summary: summary
				};
			}
			var handOver = wikt.addExamples.submitHandler;
			if (typeof handOver === &quot;function&quot;) {
				try {
					handOver({
					transform: transform,
					summary: summary,
					removes: code === null,
					// No key of its own: an example edited twice is two entries, applied in turn, the
					// second reading the line as the first left it.
					done: function() {
						self.setVisible(false);
						self.endEdit();
						reenable();
					},
					fail: function(message) {
						error(message || &quot;Nikare li rêza guhartinan zêde bike.&quot;);
					}
					});
				} catch (e) {
					error(&quot;Nikare li rêza guhartinan zêde bike: &quot; + (e &amp;&amp; e.message ? e.message : e));
				}
				return;
			}
			api.edit(mw.config.get(&quot;wgPageName&quot;), transform).then(function() {
				location.reload();
			}, function(codeOrAbort, result) {
				error(codeOrAbort instanceof edit.util.SubmitAbort ? codeOrAbort.message
					: msg.saveFailed + apiErrorMessage(codeOrAbort, result));
			});
		},

		// Drops the saved draft so it cannot resurface on another page.
		_clearDraft: function() {
			draftStorage.Set({});
		},

		// Clears all fields in this form.
		clear: function() {
			this._textInput.setValue(&quot;&quot;);
			this._sourceInput.setValue(&quot;&quot;);
			this._sourceURLInput.setValue(&quot;&quot;);
			this._translationInput.setValue(&quot;&quot;);
			this._transcriptionInput.setValue(&quot;&quot;);
			this._citoidSuccessMsg.hide();
			this._citoidFallbackMsg.hide();
			this._sourceTypeDropdown.getMenu().selectItemByData(&quot;citoid&quot;);
			this._setSourceType(&quot;citoid&quot;);
		},

		// A link, DOI or ISBN typed but never fetched is fetched first, and the filled form shown, rather than
		// saved as a bare url=. A name that cannot be bolded is reported under the text box, never blocking.
		submit: function() {
			if (this._citoidPending()) {
				this._fillFromCitoid();
				return;
			}
			this._doSubmit();
		},

		// Generates and submits the wikicode, then inserts the resulting HTML element if no errors occurred.
		_doSubmit: function() {
			var self = this;

			self._textInput.setDisabled(true);
			self._sourceInput.setDisabled(true);
			self._sourceURLInput.setDisabled(true);
			self._translationInput.setDisabled(true);
			self._transcriptionInput.setDisabled(true);
			self._sourceTypeDropdown.setDisabled(true);
			Object.keys(self._jederFieldWidgets).forEach(function(key) {
				self._jederFieldWidgets[key].setDisabled(true);
			});
			//      self._disableTranslationChk.setDisabled(true);
			this._applyButton.setDisabled(true);
			this._clearButton.setDisabled(true);
			this._loadingImage.toggle(true);

var source = this._sourceInput.getValue().trim();
			var sourceURL = this._sourceURLInput.getValue().trim();
			var text = this._textInput.getValue().trim();

			// The filled-in fields of the selected template. buildCitation() adds the language parameter and
			// the &quot;Ç:&quot; flag itself.
			var jederFields = {};
			var usingCategoryTemplate = this._currentJederKey === CATEGORY_TEMPLATE_KEY &amp;&amp; !!this._categoryTemplateName;
			if (usingCategoryTemplate) {
				Object.keys(self._jederFieldWidgets).forEach(function(key) {
					// A raw linebreak would break the single-line &quot;#*&quot; wikitext just like in the example text,
					// but these are plain param values (not display text), so collapse to a space, not &lt;br&gt;.
					var value = nlToSpace(self._jederFieldWidgets[key].getValue().trim());
					if (value) {
						jederFields[key] = value;
					}
				});
			} else if (this._currentJederKey &amp;&amp; jederDefs[this._currentJederKey]) {
				jederDefs[this._currentJederKey].fields.forEach(function(field) {
					var widget = self._jederFieldWidgets[field.key];
					var value = widget ? nlToSpace(widget.getValue().trim()) : &quot;&quot;;
					if (value) {
						jederFields[field.key] = value;
					}
				});
				cite.withLinkAsUrl(this._currentJederKey, jederFields, sourceURL);
			}
			// A Kategorî:Çavkanî template is used as soon as it's picked, even with every field left blank
			// (still submittable as a bare jêgirtin=); a jêder-* type only counts once a field is actually filled.
			var usingJederTemplate = usingCategoryTemplate || (this._currentJederKey &amp;&amp; Object.keys(jederFields).length &gt; 0);

			var usingRawTemplate = this._currentJederKey === RAW_TEMPLATE_KEY;

			var minakAnNa, sablon;
			if (usingRawTemplate) {
				// A citation, so &quot;#*&quot; like the others -- the line itself is built below, not assembled here.
				minakAnNa = &quot;*&quot;;
				sablon = &quot;&quot;;
			} else if (usingJederTemplate) {
				// The jêder-*/Kategorî:Çavkanî template itself is used as the template, not as the &quot;2=&quot; content.
				minakAnNa = &quot;*&quot;;
				sablon = usingCategoryTemplate ? this._categoryTemplateName : this._currentJederKey;
			} else if (source || sourceURL) {
				minakAnNa = &quot;*&quot;;
				sablon = &quot;jêder&quot;;
			} else {
				minakAnNa = &quot;:&quot;;
				sablon = &quot;nimûne&quot;;
			}

			var listMarker = &quot;&quot;.padStart(this._definitionLevel.length - 1, &quot;#&quot;) + minakAnNa;
			var title = mw.config.get('wgTitle');

			// One builder for every citation line here and in the wizard. Bolding the entry name, the language
			// parameter, the &quot;Ç:&quot; flag and &lt;br&gt; conversion all belong to it.
			var code = cite.buildCitation({
				mode: usingRawTemplate ? &quot;raw&quot;
					: usingCategoryTemplate ? &quot;category&quot;
					: usingJederTemplate ? &quot;jeder&quot;
					: &quot;plain&quot;,
				marker: listMarker,
				language: this._language,
				title: title,
				template: usingCategoryTemplate ? this._categoryTemplateName : this._currentJederKey,
				fields: jederFields,
				langParamKey: this._categoryTemplateLangParamKey,
				quote: text,
				source: source,
				sourceURL: sourceURL,
				translation: this._translationInput.getValue().trim(),
				transcription: this._transcriptionInput.getValue().trim(),
				// An edited line keeps its translation, and every parameter the form has no box for as long
				// as it is still the same kind of line.
				keepTranslation: !!this._editing,
				extra: this._editing &amp;&amp; this._editing.key === this._currentJederKey ? this._editing.example.extra : []
			});

			// definitionLevel[0] is &quot;type|ordinal&quot;: the section's position among same-type headings within its
			// language, resolved client-side, never MediaWiki's page-wide DOM id number.
			var sectionKeyParts = this._definitionLevel[0].split(&quot;|&quot;);
			var sectionType = sectionKeyParts[0];
			var sectionOrdinal = parseInt(sectionKeyParts[1], 10);

			if (this._editing) {
				// A citation written out by hand is saved exactly as typed, its list marker included.
				// Otherwise the rebuilt line keeps the page's own parameter order.
				var replacement = usingRawTemplate
					? (/^#/.test(text) ? text : this._editing.original.match(/^#+[:*]/)[0] + &quot; &quot; + text)
					: cite.keepOrder(code, this._editing.original, this._editing.aliases);
				this._sendReplacement(replacement, &quot;±nimûneya bikaranînê bi amûra « {0} » (v{1}).&quot;.format(NAME, VERSION), reenable, error);
				return;
			}

			// Read by the success handler below, which is a sibling of the transform, not nested in it.
			var emptyTemplate = false;

			// Thrown from inside an edit() transform to bail out with a specific message.
			var SubmitAbort = edit.util.SubmitAbort;

			// api.edit() fetches the revision it will conflict-check against and hands it here, so the
			// insertion runs on exactly that content. Named, so another gadget can run it instead.
			function buildEdit(revision) {
				var pageContent = revision.content;

				// Said here rather than left to the locator: which sections this tool does not work in is
				// this tool's own business, and the locator only knows that the key names no section.
				if (!sections.headingNamesFor(sectionType)) {
					throw new SubmitAbort('Navê beşê xelet e. Di beşên &quot;Ji wêjêyê&quot; û &quot;Ji wêjêya klasîk&quot; ev amûr nayê bikaranîn.');
				}

				// loc.lines covers the rest of the page from this language's heading on: the saved page is rebuilt
				// from it below (see &quot;text:&quot;).
				var loc = wt.locateSection(pageContent, self._language, sectionType, sectionOrdinal);
				var langSectionIndex = loc.langSectionIndex;
				var lines = loc.lines;
				var targetLineIndex = wt.findDefinitionLine(lines, loc.posLineIndex, self._definitionLevel);

				// Where to insert inside this definition's &quot;#:&quot;/&quot;#*&quot; block. findBlockEnd() keeps multi-line
				// templates whole; exampleTemplateNames tells a real example from an annotation.
				var insertionFound = false;
				var lastRelevantBlockEnd = -1;
				var isJederFamily = (sablon === &quot;jêder&quot; || Object.prototype.hasOwnProperty.call(jederDefs, sablon));
				var scanIndex = targetLineIndex + 1;
				// Read off the definition line, so a sub-sense's examples are matched at its own depth and
				// a deeper &quot;#&quot; line ends the block instead of being skipped past.
				var annotation = annotationRegex(lines[targetLineIndex]);
				var citation = citationRegex(lines[targetLineIndex]);

				for (; scanIndex &lt; lines.length; scanIndex++) {
					var scanLine = lines[scanIndex];

					if (!annotation.test(scanLine)) {
						// Left this definition's own block (a sub-sense, a new definition, a new section).
						break;
					}

					var blockEnd = findBlockEnd(lines, scanIndex);
					var templateName = getLineTemplateName(scanLine);
					var isExampleLine = templateName !== null &amp;&amp;
						exampleTemplateNames.indexOf(templateName) !== -1;

					if (isJederFamily) {
					// A jêder-family example goes after every &quot;#:&quot;/&quot;#*&quot; line of this definition.
						lastRelevantBlockEnd = blockEnd;
						insertionFound = true;
					} else if (sablon === &quot;nimûne&quot;) {
						// &quot;nimûne&quot; examples go before any &quot;#*&quot; line, but after &quot;#:&quot; lines.
						if (citation.test(scanLine)) {
							break;
						}
						lastRelevantBlockEnd = blockEnd;
						insertionFound = true;
					}

					scanIndex = blockEnd; // Skip past the whole (possibly multi-line) block
				}

				var insertAt = lastRelevantBlockEnd &gt;= 0 ? lastRelevantBlockEnd + 1 : scanIndex;

				// After the relevant block, or straight after the definition when it had no &quot;#:&quot;/&quot;#*&quot; lines.
				lines.splice(insertAt, 0, code);

				// The &quot;no example yet&quot; marker goes once a real one lands. The whole &quot;#:&quot;/&quot;#*&quot; block is swept, not
				// just its last line: the marker is often followed by other annotations.
				var sweepFrom = targetLineIndex + 1;
				for (var sweep = sweepFrom; sweep &lt; lines.length; sweep++) {
					if (!annotation.test(lines[sweep])) {
						break;
					}
					if (EMPTY_EXAMPLE_MARKER.test(lines[sweep])) {
						lines.splice(sweep, 1);
						emptyTemplate = true; // tells the DOM update below to replace the marker's &lt;li&gt;
						sweep--;
					}
				}

				return {
					text: pageContent.slice(0, langSectionIndex) + lines.join(&quot;\n&quot;),
					summary: &quot;+nimûneya bikaranînê bi amûra « {0} » (v{1}).&quot;.format(NAME, VERSION),
				};
			}

			// DefSideBoxes takes the save over when its panel opened this form: the edit joins that gadget's
			// queue instead of publishing now.
			var handOver = wikt.addExamples.submitHandler;
			if (typeof handOver === &quot;function&quot;) {
				try {
					handOver({
					transform: buildEdit,
					// The line on its own, for a caller that has nowhere to splice it yet: a sense still
					// in someone's queue has no line number to be found by (DefSideBoxes' new-sense row).
					line: code,
					summary: &quot;+nimûneya bikaranînê bi amûra « {0} » (v{1}).&quot;.format(NAME, VERSION),
					done: function() {
						self.setVisible(false);
						self.clear();
						self._clearDraft();
						reenable();
					},
					fail: function(message) {
						error(message || &quot;Nikare li rêza guhartinan zêde bike.&quot;);
					}
					});
				} catch (e) {
					error(&quot;Nikare li rêza guhartinan zêde bike: &quot; + (e &amp;&amp; e.message ? e.message : e));
				}
				return;
			}

			api.edit(mw.config.get(&quot;wgPageName&quot;), buildEdit).then(function() {
				api.parse(code).done(function(data) {
					var $renderedExample = $(data).find(&quot;ul &gt; li&quot;).html();
					var $item;
					// Insert rendered example into page
					if (emptyTemplate) {
						self._$lastExample.html($renderedExample);
						$item = self._$lastExample;
					} else {
						self._$lastExample.after($item = $(&quot;&lt;li&gt;&quot;).append($renderedExample));
					}
					$item.css(&quot;background-color&quot;, &quot;lightgreen&quot;);
					setTimeout(function() {
						$item.css(&quot;background-color&quot;, &quot;inherit&quot;);
					}, 1000);
					self._$lastExample = $item;
				});
				self.setVisible(false);
				self.clear();
				self._clearDraft();
				reenable();
			}, function(codeOrAbort, result) {
				if (codeOrAbort instanceof SubmitAbort) {
					error(codeOrAbort.message);
				} else {
					error(msg.saveFailed + apiErrorMessage(codeOrAbort, result));
				}
			});

			function error(errorMessage) {
				mw.notify(errorMessage || &quot;Nimûne nehat weşandin, îhtimalen rûpel hate guhartin. Ji kerema xwe re rûpelê dîsa bar bike û dîsa biceribîne.&quot;);
				// A draft is kept for a new example only: an edited one would come back on the next new one.
				if (!self._editing) {
					draftStorage.Set({
						text: self._textInput.getValue(),
						source: self._sourceInput.getValue(),
						sourceURL: self._sourceURLInput.getValue(),
						translation: self._translationInput.getValue(),
						transcription: self._transcriptionInput.getValue(),
					});
				}
				reenable();
			}

			function reenable() {
				self._textInput.setDisabled(false);
				self._sourceInput.setDisabled(false);
				self._sourceURLInput.setDisabled(false);
				self._translationInput.setDisabled(false);
				self._transcriptionInput.setDisabled(false);
				self._sourceTypeDropdown.setDisabled(false);
				Object.keys(self._jederFieldWidgets).forEach(function(key) {
					self._jederFieldWidgets[key].setDisabled(false);
				});
				//        self._disableTranslationChk.setDisabled(false);
				self._applyButton.setDisabled(false);
				self._cancelButton.setDisabled(false);
				self._clearButton.setDisabled(false);
				self._loadingImage.toggle(false);
			}
		},
	};
});
// &lt;/nowiki&gt;</text>
      <sha1>5lp6bg8x1kcbfpwypq0jybii6uqgunr</sha1>
    </revision>
  </page>
  <page>
    <title>Gotûbêj:şilêr</title>
    <ns>1</ns>
    <id>1356961</id>
    <revision>
      <id>6903099</id>
      <parentid>6232894</parentid>
      <timestamp>2026-11-10T20:34:00Z</timestamp>
      <contributor>
        <username>Ghybu</username>
        <id>1393</id>
      </contributor>
      <minor />
      <comment>/* Fritillaria kurdica an Fritillaria imperyalis ? */ format</comment>
      <origin>6903099</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="671" sha1="g9ypp0l81ypkdil4bwdivtj85g3uhcj" xml:space="preserve">== Fritillaria kurdica an Fritillaria imperyalis ? ==

[[Wêne:Nature of Buin va Miandasht County.jpg|thumb|''Fritillaria imperyalis'']]
[[Wêne:Fritillaria kurdica.jpg|thumb|''Fritillaria kurdica'']]

{{silav|Dûrzan}}. Şilêr an gulderxwîn navê kîjan gul e: ''Fritillaria imperyalis'' an ''Fritillaria kurdica'' ? [[Bikarhêner:Ghybu|Ghybu]] ([[Gotûbêja bikarhêner:Ghybu|gotûbêj]]) 01:34, 26 nîsan 2026 (UTC)
: Merheba, bi esasa xwe navê imperialis e. Lê bi a min be ji bo gişê fritillaria (stûxwar) mirov dikare weke navê cins bikarbîne. Mînak: Şilêr/gulderxwîna(stûxwarka) kurdan (fritillaria kurdica)--{{bêîmze|Dûrzan|11:00, 26 nîsan 2026}}</text>
      <sha1>g9ypp0l81ypkdil4bwdivtj85g3uhcj</sha1>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Gadget-citoid-helper.js</title>
    <ns>8</ns>
    <id>1358211</id>
    <revision>
      <id>6903102</id>
      <parentid>6414340</parentid>
      <timestamp>2026-11-10T21:26:18Z</timestamp>
      <contributor>
        <username>Wikihez</username>
        <id>7344</id>
      </contributor>
      <minor />
      <comment>Split the wizard's script pages under 100 KB; identifierOf shared from citoid-helper</comment>
      <origin>6903102</origin>
      <model>javascript</model>
      <format>text/javascript</format>
      <text bytes="12076" sha1="p9iya9qzf8cdvydgnxn3h3cn3i9o5gm" xml:space="preserve">// &lt;nowiki&gt;
/**
 * Gadget-citoid-helper.js
 *
 * Amûreke muşterek ji bo standina daneyên çavkaniyê ji Citoid û
 * veguherandina wan bo qadên şablonên jêder-* (jêder-kitêb, jêder-kovar, jêder-websîte, jêder-vîdeo).
 *
 * BIKARANÎN JI SCRIPTEKE DIN:
 *
 *   Vê rûpelê wek dependency lê zêde bike di eyarên gadgeta xwe de li ser
 *   [[Special:Gadgets]] (an jî MediaWiki:Gadgets-definition), paşê:
 *
 *       mw.loader.using(&quot;ext.gadget.citoid-helper&quot;).then(function () {
 *           wikt.citoid.fetchJederFields(url).then(function (result) {
 *               console.log(result.jederKey, result.fields);
 *           });
 *       });
 *
 * API ya `window.wikt.citoid`:
 *   - getRestUrl()                        → {string} URLya REST a Citoid a vê wîkiyê
 *   - yearFromDate(dateStr)                → {string} sala (4 reqem) ji rêzikeke tarîxê
 *   - formatAuthors(authors)               → {string} navên nivîskaran wek rêzikek yekane
 *   - typeToJederKey(itemType)             → {string} &quot;jêder-kitêb&quot; / &quot;jêder-kovar&quot; / &quot;jêder-websîte&quot; / &quot;jêder-vîdeo&quot;
 *   - dataToJederFields(jederKey, data, originalUrl) → {Object&lt;string,string&gt;} merheleyên şablona jêder-*
 *   - fetchData(query)                     → {jQuery.Promise&lt;Object&gt;} daneya xam a Citoid
 *   - fetchJederFields(query)              → {jQuery.Promise&lt;{jederKey, fields, raw}&gt;} hêsankirî
 *   - extractVideoTimestamp(urlStr)        → {string} a video URL's &quot;t=&quot; start time, as &quot;M:SS&quot;/&quot;H:MM:SS&quot;
 *   - isYouTubeUrl(urlStr)                 → {boolean} whether the URL is a youtube.com/youtu.be link
 *   - websiteNameForUrl(urlStr)            → {string} jêder-websîte &quot;websîte&quot; value: known-site wikilink, else the bare domain
 *   - TYPE_TO_JEDER                        → {Object} xerîteya itemType → jederKey
 */

window.wikt = window.wikt || {};

(function () {
	&quot;use strict&quot;;

	// Heke jixwe hatibe barkirin, dubare neke.
	if (window.wikt.citoid) {
		return;
	}

	// Xerîteya cureyên Citoid (itemType) li ser şablonên me yên jêder-*
	var CITOID_TYPE_TO_JEDER = {
		&quot;book&quot;: &quot;jêder-kitêb&quot;,
		&quot;bookSection&quot;: &quot;jêder-kitêb&quot;,
		&quot;thesis&quot;: &quot;jêder-kitêb&quot;,
		&quot;report&quot;: &quot;jêder-kitêb&quot;,
		&quot;manuscript&quot;: &quot;jêder-kitêb&quot;,
		&quot;journalArticle&quot;: &quot;jêder-kovar&quot;,
		&quot;magazineArticle&quot;: &quot;jêder-kovar&quot;,
		&quot;newspaperArticle&quot;: &quot;jêder-kovar&quot;,
		&quot;webpage&quot;: &quot;jêder-websîte&quot;,
		&quot;blogPost&quot;: &quot;jêder-websîte&quot;,
		&quot;forumPost&quot;: &quot;jêder-websîte&quot;,
		&quot;videoRecording&quot;: &quot;jêder-vîdeo&quot;,
		&quot;podcast&quot;: &quot;jêder-websîte&quot;,
		&quot;encyclopediaArticle&quot;: &quot;jêder-websîte&quot;
	};

	/**
	 * Ji mantiqa [[:en:w:User:BrandonXLF/Citoid.js]]
	 * Vedigere URLya REST a Citoid, li gorî eyarên vê wîkiyê.
	 * @return {string}
	 */
	function getRestUrl() {
		var cfg = mw.config.get(&quot;wgCitoidConfig&quot;);
		var vecfg = mw.config.get(&quot;wgVisualEditorConfig&quot;);
		return (cfg &amp;&amp; (cfg.fullRestbaseUrl || cfg.wbFullRestbaseUrl)) ? (cfg.fullRestbaseUrl || cfg.wbFullRestbaseUrl) + &quot;v1/data/citation/mediawiki/&quot;
			: (vecfg &amp;&amp; vecfg.fullRestbaseUrl) ? vecfg.fullRestbaseUrl + &quot;v1/data/citation/mediawiki/&quot;
			: (cfg &amp;&amp; cfg.citoidServiceUrl) ? cfg.citoidServiceUrl + &quot;/mediawiki/&quot;
			: &quot;https://ku.wiktionary.org/api/rest_v1/data/citation/mediawiki/&quot;;
	}

	/**
	 * Ji tarîxa Citoid (rêzik an tarîxeke ISO) sala wê (4 reqem) derdixe.
	 * @param dateStr {string}
	 * @return {string}
	 */
	function yearFromDate(dateStr) {
		if (!dateStr) {
			return &quot;&quot;;
		}
		var match = /\d{4}/.exec(dateStr);
		return match ? match[0] : &quot;&quot;;
	}

	/**
	 * Navên nivîskaran ên Citoid (rêzek [pêşnav, paşnav]) dike rêzikek yekane.
	 * @param authors {Array&lt;Array&lt;string&gt;&gt;}
	 * @return {string}
	 */
	function formatAuthors(authors) {
		if (!Array.isArray(authors)) {
			return &quot;&quot;;
		}
		return authors.map(function (pair) {
			return (pair || []).filter(function (part) {
				return !!part;
			}).join(&quot; &quot;);
		}).filter(function (name) {
			return !!name;
		}).join(&quot;; &quot;);
	}

	function formatEditors(editors) {
		if (!Array.isArray(editors)) {
			return &quot;&quot;;
		}
		return editors.map(function (pair) {
			return (pair || []).filter(function (part) {
				return !!part;
			}).join(&quot; &quot;);
		}).filter(function (name) {
			return !!name;
		}).join(&quot;; &quot;);
	}
	/**
	 * Li gorî itemType a Citoid, navê şablona jêder-* a munasib vedigerîne.
	 * @param itemType {string}
	 * @return {string} Yek ji &quot;jêder-kitêb&quot;, &quot;jêder-kovar&quot;, &quot;jêder-websîte&quot; an &quot;jêder-vîdeo&quot;.
	 */
	function typeToJederKey(itemType) {
		return CITOID_TYPE_TO_JEDER[itemType] || &quot;jêder-websîte&quot;;
	}

	/**
	 * Whether a URL is a youtube.com/youtu.be link -- used to force jêder-vîdeo regardless of
	 * Citoid's own itemType guess, and to pick the &quot;w:Youtube&quot; platform value.
	 * @param urlStr {string}
	 * @return {boolean}
	 */
	function isYouTubeUrl(urlStr) {
		return /^https?:\/\/(www\.|m\.)?(youtube\.com|youtu\.be)\//i.test(urlStr || &quot;&quot;);
	}

	// Known domains mapped to a nicer jêder-websîte &quot;websîte&quot; value (a wikilink where a Wikipedia article exists).
	var KNOWN_WEBSITE_NAMES = {
		&quot;x.com&quot;: &quot;w:Twitter&quot;,
		&quot;twitter.com&quot;: &quot;w:Twitter&quot;,
		&quot;Rudaw&quot;: &quot;w:Rûdaw&quot;,
		&quot;rudaw.net&quot;: &quot;w:Rûdaw&quot;
	};

	/**
	 * Bare domain of a URL (protocol and &quot;www.&quot; stripped), e.g. &quot;https://www.example.com/x&quot; -&gt; &quot;example.com&quot;.
	 * @param urlStr {string}
	 * @return {string} Lowercased domain, or an empty string if urlStr isn't an absolute http(s) URL.
	 */
	function bareDomainFromUrl(urlStr) {
		var match = /^https?:\/\/(?:www\.)?([^\/]+)/i.exec(urlStr || &quot;&quot;);
		return match ? match[1].toLowerCase() : &quot;&quot;;
	}

	/**
	 * A jêder-websîte &quot;websîte&quot; value for a URL: a known-site wikilink (KNOWN_WEBSITE_NAMES) if the domain
	 * matches one, else the bare domain itself as a plain fallback name.
	 * @param urlStr {string}
	 * @return {string} The site name, or an empty string if urlStr isn't an absolute http(s) URL.
	 */
	function websiteNameForUrl(urlStr) {
		var host = bareDomainFromUrl(urlStr);
		return host ? (KNOWN_WEBSITE_NAMES[host] || host) : &quot;&quot;;
	}

	/**
	 * Extracts a video's start time from its URL's &quot;t=&quot; param (YouTube-style: plain seconds like &quot;137&quot;,
	 * or &quot;2m17s&quot;/&quot;1h2m3s&quot;). Reads the caller-supplied URL directly, since Citoid's own resolved data.url
	 * usually strips this param.
	 * @param urlStr {string}
	 * @return {string} &quot;M:SS&quot; or &quot;H:MM:SS&quot;, or an empty string if absent/unrecognized.
	 */
	function extractVideoTimestamp(urlStr) {
		if (!urlStr) {
			return &quot;&quot;;
		}
		var match = /[?&amp;]t=([^&amp;]+)/.exec(urlStr);
		if (!match) {
			return &quot;&quot;;
		}
		var raw = decodeURIComponent(match[1]);
		var seconds;
		if (/^\d+s?$/.test(raw)) {
			seconds = parseInt(raw, 10);
		} else {
			var parts = /^(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s)?$/.exec(raw);
			if (!parts || (!parts[1] &amp;&amp; !parts[2] &amp;&amp; !parts[3])) {
				return &quot;&quot;;
			}
			seconds = (parseInt(parts[1] || &quot;0&quot;, 10) * 3600) + (parseInt(parts[2] || &quot;0&quot;, 10) * 60) + parseInt(parts[3] || &quot;0&quot;, 10);
		}
		var h = Math.floor(seconds / 3600);
		var m = Math.floor((seconds % 3600) / 60);
		var s = seconds % 60;
		var ss = s &lt; 10 ? &quot;0&quot; + s : String(s);
		return h &gt; 0 ? (h + &quot;:&quot; + (m &lt; 10 ? &quot;0&quot; + m : m) + &quot;:&quot; + ss) : (m + &quot;:&quot; + ss);
	}

	/**
	 * Daneyên Citoid vediguherîne tabloyeke parametreyên şablona jêder-* (li gorî cureyê wê).
	 * @param jederKey {string} Yek ji &quot;jêder-kitêb&quot;, &quot;jêder-kovar&quot;, &quot;jêder-websîte&quot; an &quot;jêder-vîdeo&quot;.
	 * @param data {Object} Netîceya Citoid.
	 * @param originalUrl {string} [optional] The URL/DOI/ISBN as originally typed/fetched -- preferred over
	 *   data.url for the &quot;url&quot; field when it's an absolute http(s) URL, since Citoid's own resolved data.url
	 *   strips query params (e.g. a video's &quot;t=&quot; timestamp) that the original URL still has.
	 * @return {Object&lt;string, string&gt;}
	 */
	function dataToJederFields(jederKey, data, originalUrl) {
		var out = {};
		var author = formatAuthors(data.author);
		var editor = formatEditors(data.editor);
		var url = (originalUrl &amp;&amp; /^https?:\/\//i.test(originalUrl)) ? originalUrl : data.url;

		if (author) { out[&quot;nivîskar&quot;] = author; }
		if (editor) { out[&quot;amadekar&quot;] = editor; }
		if (data.title) { out[&quot;sernav&quot;] = data.title; }
		if (url) { out.url = url; }

		if (jederKey === &quot;jêder-kitêb&quot;) {
			if (data.publisher) { out[&quot;weşanxane&quot;] = data.publisher; }
			if (data.place) { out.cih = data.place; }
			if (data.date) { out.sal = yearFromDate(data.date); }
			if (data.ISBN) { out.isbn = Array.isArray(data.ISBN) ? data.ISBN[0] : data.ISBN; }
			if (data.edition) { out[&quot;çap&quot;] = data.edition; }
			if (data.pages) { out[&quot;rûpel&quot;] = data.pages; }
		} else if (jederKey === &quot;jêder-kovar&quot;) {
			if (data.publicationTitle) { out.kovar = data.publicationTitle; }
			if (data.publisher) { out[&quot;weşanxane&quot;] = data.publisher; }
			if (data.volume) { out.cild = data.volume; }
			if (data.issue) { out.hejmar = data.issue; }
			if (data.pages) { out[&quot;rûpel&quot;] = data.pages; }
			if (data.date) { out.sal = yearFromDate(data.date); }
		} else if (jederKey === &quot;jêder-websîte&quot;) {
			var websiteName = data.websiteTitle || websiteNameForUrl(url);
			if (websiteName) { out[&quot;websîte&quot;] = websiteName; }
			if (data.date) {
				out[&quot;tarîx&quot;] = data.date;
			}
		} else if (jederKey === &quot;jêder-vîdeo&quot;) {
			delete out[&quot;nivîskar&quot;]; // &quot;hunermend&quot; is jêder-vîdeo's own performer/artist field
			if (author) { out.hunermend = author; }
			var platform = isYouTubeUrl(url) ? &quot;w:Youtube&quot; : (data.libraryCatalog || &quot;&quot;).toLowerCase();
			if (platform) { out.platform = platform; }
			// tarîx and sal are mutually exclusive -- prefer the full date, fall back to year-only otherwise.
			if (data.date) {
				out.tarîx = data.date;
			} else {
				var year = yearFromDate(data.date);
				if (year) { out.sal = year; }
			}
			var dem = extractVideoTimestamp(url);
			if (dem) { out.dem = dem; }
		}

		return out;
	}

	/**
	 * Ji Citoid daneyên çavkaniyekê tîne (li gorî URL, DOI an ISBNyê).
	 * @param query {string}
	 * @return {jQuery.Promise} Bi daneya ewil a Citoid (Object) tê safîkirin.
	 */
	function fetchData(query) {
		var url;
		try {
			url = encodeURIComponent(decodeURIComponent(query));
		} catch (e) {
			url = encodeURIComponent(query);
		}
		return $.get(getRestUrl() + url).then(function (res) {
			if (!res || !res[0]) {
				return $.Deferred().reject(&quot;Netîceya ji Citoidê vala ye.&quot;).promise();
			}
			return res[0];
		});
	}

	/**
	 * Fonksiyoneke hêsankirî: ji URL/DOI/ISBNyekê rasterast şablona jêder-* a munasib
	 * û merheleyên wê yên tijîkirî vedigerîne (fetchData + typeToJederKey + dataToJederFields
	 * bi hev re).
	 * @param query {string}
	 * @return {jQuery.Promise} Bi {jederKey: string, fields: Object&lt;string,string&gt;, raw: Object} tê safîkirin.
	 */
	function fetchJederFields(query) {
		return fetchData(query).then(function (data) {
			// YouTube links always use jêder-vîdeo, regardless of what itemType Citoid guessed.
			var jederKey = (isYouTubeUrl(query) || isYouTubeUrl(data.url)) ? &quot;jêder-vîdeo&quot; : typeToJederKey(data.itemType);
			return {
				jederKey: jederKey,
				fields: dataToJederFields(jederKey, data, query),
				raw: data
			};
		});
	}

	// The template and field an ISBN or DOI belongs in, or null for anything else.
	function identifierOf(query) {
		var isbn = query.replace(/^isbn:?\s*/i, &quot;&quot;);
		if (/^(\d{9}[\dX]|97[89]\d{10})$/i.test(isbn.replace(/[-\s]/g, &quot;&quot;))) {
			return { jederKey: &quot;jêder-kitêb&quot;, field: &quot;isbn&quot;, value: isbn };
		}
		var doi = /^(?:https?:\/\/(?:dx\.)?doi\.org\/|doi:\s*)?(10\.\d{4,9}\/\S+)$/i.exec(query);
		return doi ? { jederKey: &quot;jêder-kovar&quot;, field: &quot;doi&quot;, value: doi[1] } : null;
	}

	window.wikt.citoid = {
		identifierOf: identifierOf,
		getRestUrl: getRestUrl,
		yearFromDate: yearFromDate,
		formatAuthors: formatAuthors,
		typeToJederKey: typeToJederKey,
		dataToJederFields: dataToJederFields,
		fetchData: fetchData,
		fetchJederFields: fetchJederFields,
		extractVideoTimestamp: extractVideoTimestamp,
		isYouTubeUrl: isYouTubeUrl,
		websiteNameForUrl: websiteNameForUrl,
		TYPE_TO_JEDER: CITOID_TYPE_TO_JEDER
	};
})();
// &lt;/nowiki&gt;</text>
      <sha1>p9iya9qzf8cdvydgnxn3h3cn3i9o5gm</sha1>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Gadget-wikt.dsb.js</title>
    <ns>8</ns>
    <id>1359171</id>
    <revision>
      <id>6903107</id>
      <parentid>6865759</parentid>
      <timestamp>2026-11-10T21:29:15Z</timestamp>
      <contributor>
        <username>Wikihez</username>
        <id>7344</id>
      </contributor>
      <minor />
      <comment>Script pages under 100 KB: part of the code moved to a second file; shared code in one place</comment>
      <origin>6903107</origin>
      <model>javascript</model>
      <format>text/javascript</format>
      <text bytes="36523" sha1="s4lifbnocgn7283g4oljq1igyd6kima" xml:space="preserve">// &lt;nowiki&gt;
/*
 * Page: [[MediaWiki:Gadget-wikt.dsb.js]]
 *
 * The part of DefSideBoxes that runs on a page view: finds the definition lines and hangs a pencil on
 * each. Forms, dialogs and saves are in wikt.dsb-panels, fetched on the first click (never on hover).
 *
 * The &quot;Nimûne/jêgirtin&quot; item drives add-examples, which wikt.dsb-panels depends on -- so it is loaded by
 * the time any panel exists, and never on a plain page view.
 */
(function () {
	&quot;use strict&quot;;

	var core = require(&quot;ext.gadget.wikt.core&quot;);
	var sections = core.sections;
	var MANE_SECTION = sections.MANE_SECTION;
	var PAGE_SUBSECTIONS = sections.PAGE_SUBSECTIONS;
	var msg = core.msg;
	var headingOuter = sections.headingOuter;
	var headingDepth = sections.headingDepth;
	var headingText = sections.headingText;
	var isManeHeading = sections.isManeHeading;
	var sectionTypeOf = sections.sectionTypeOf;
	var sectionOrdinalWithinLanguage = sections.sectionOrdinalWithinLanguage;
	var headingTextOrdinalWithinLanguage = sections.headingTextOrdinalWithinLanguage;
	var languageCodeForOl = sections.languageCodeForOl;
	var eachLeafDefinition = sections.eachLeafDefinition;

	if (mw.config.get(&quot;wgAction&quot;) !== &quot;view&quot;) {
		return;
	}
	// An entry, a reconstruction, or a sandbox -- see sections.isEntryPage().
	if (!sections.isEntryPage()) {
		return;
	}
	if (/&amp;printable=yes|&amp;diff=|&amp;oldid=/.test(window.location.search)) {
		return;
	}

	window.wikt = window.wikt || {};
	if (window.wikt.defSideBoxesLoaded) {
		return;
	}
	window.wikt.defSideBoxesLoaded = true;

	// A save from the queue box reloads with core's post-edit flag set (see dsb-panels.js). Core loads the
	// module that reads the flag only after a form save, so it is loaded here; it shows the toast and clears the flag.
	if (mw.storage.session.get(&quot;mw-PostEdit&quot; + mw.config.get(&quot;wgPageName&quot;))) {
		mw.loader.load(&quot;mediawiki.action.view.postEdit&quot;);
	}

	// The panels never land on a page view: each module is fetched once, on the first click that needs it
	// -- never on hover -- and every later call reuses the same promise.
	var panelsApi = null;

	// A panel is built once and merely shown again after that, so the reveal cannot live in the builders.
	// Only click handlers call this -- hover must never pull the panels module.
	function revealQueue() {
		withPanels(function (panels) {
			panels.openQueueBox();
		});
	}

	// Each kind of panel is a module of its own, fetched the first time its kind of pencil is clicked; all of
	// them build on wikt.dsb-panels, which carries the queue and everything they share.
	var PANEL_MODULES = {
		sense: &quot;ext.gadget.wikt.dsb-sense&quot;,
		subsection: &quot;ext.gadget.wikt.dsb-subsection&quot;,
		pos: &quot;ext.gadget.wikt.dsb-pos&quot;
	};
	var panelsPromises = {};

	// fn gets wikt.dsb-panels' exports, plus those of the module for part (sense, subsection, pos) if given.
	function withPanels(part, fn) {
		if (typeof part === &quot;function&quot;) {
			fn = part;
			part = null;
		}
		var name = PANEL_MODULES[part] || &quot;ext.gadget.wikt.dsb-panels&quot;;
		if (!panelsPromises[name]) {
			panelsPromises[name] = mw.loader.using(name).then(function (require) {
				panelsApi = require(&quot;ext.gadget.wikt.dsb-panels&quot;);
				return name === &quot;ext.gadget.wikt.dsb-panels&quot; ? panelsApi : $.extend({}, panelsApi, require(name));
			});
		}
		panelsPromises[name].then(fn, function () {
			mw.notify(&quot;Nikare amûrên guhartinê bar bike.&quot;, { type: &quot;error&quot; });
		});
	}

	// The element holding an example's last line of text: a quotation's source line and its quote are
	// blocks, so a pencil after them would sit on a line of its own.
	function lastTextLine(el) {
		var last = el.lastElementChild;
		while (last &amp;&amp; /^(DIV|DL|DD|UL|OL|LI)$/.test(last.tagName)) {
			el = last;
			last = el.lastElementChild;
		}
		return el;
	}

	// A pencil on every example and quotation under a sense, opening add-examples' form on that one line.
	function attachExampleEditors($li, language, sectionType, sectionOrdinal, definitionLevel, $h3) {
		// A queued change redraws the sense (dsb-panels.js raises this); its examples get their pencils again.
		if (!$li.data(&quot;dsbExampleRedraw&quot;)) {
			$li.data(&quot;dsbExampleRedraw&quot;, true);
			$li.on(&quot;dsbSenseRedrawn&quot;, function () {
				attachExampleEditors($li, language, sectionType, sectionOrdinal, definitionLevel, $h3);
			});
		}
		sections.exampleItemsOf($li).each(function () {
			var item = this;
			if ($(item).hasClass(&quot;dsb-has-example-toolbar&quot;)) {
				return;
			}
			var $toggle = $(&quot;&lt;a href='#' class='dsb-toggle'&gt;&lt;/a&gt;&quot;).attr(&quot;title&quot;, &quot;Nimûneyê biguhêre&quot;);
			var $toolbar = $(&quot;&lt;span class='dsb-example-toolbar'&gt;&lt;/span&gt;&quot;).append($toggle);
			$toggle.on(&quot;click&quot;, function (e) {
				e.preventDefault();
				e.stopPropagation();
				withPanels(&quot;sense&quot;, function (panels) {
					panels.editExample($li, $h3, language, sectionType, sectionOrdinal, definitionLevel, item);
				});
			});
			// Touch has no hover: a tap on the example shows its pencil, as a tap on a sense does.
			$(lastTextLine(item)).append($toolbar);
			$(item).addClass(&quot;dsb-has-example-toolbar&quot;).on(&quot;click.dsbReveal&quot;, function () {
				$toolbar.addClass(&quot;dsb-revealed&quot;);
			});
		});
	}

	// How many rows the pencil is currently holding open. A pinned row means somebody is part-way through
	// an edit, and opening another one under the pointer moves the page: the content below shifts, the
	// pointer ends up over something else, that fires its own hover, and the page jumps back and forth.
	// So while anything is pinned, hovering opens nothing.
	var pinnedRows = 0;

	var canHover = !window.matchMedia || window.matchMedia(&quot;(hover: hover)&quot;).matches;

	// The first pencil clicked shows every pencil on the page, so any other part is one tap away. Capture
	// phase, as each pencil's own handler stops the click there.
	document.addEventListener(&quot;click&quot;, function (e) {
		if (e.target.closest &amp;&amp; e.target.closest(&quot;.dsb-toggle&quot;)) {
			document.body.classList.add(&quot;dsb-pencils-shown&quot;);
		}
	}, true);

	function attachToolbar($li, language, sectionType, sectionOrdinal, definitionLevel, $h3, isLastSense) {
		if ($li.children(&quot;.dsb-toolbar&quot;).length) {
			return;
		}

		var $toolbar = $(&quot;&lt;span class='dsb-toolbar'&gt;&lt;/span&gt;&quot;);
		// The real InterlanguageLinks pencil icon (same asset defEditButton uses); image swap is in the CSS.
		var $toggle = $(&quot;&lt;a href='#' class='dsb-toggle' title='Guhartina pêşketî'&gt;&lt;/a&gt;&quot;);
		// Revealed by $toggle -- an indented panel under the sense, not always visible. Built lazily on
		// first open rather than eagerly for every sense on the page.
		var $quickRow = $(&quot;&lt;div class='dsb-quick-row'&gt;&lt;/div&gt;&quot;).hide();

		var pinned = false; // the pencil pins the row open; hovering alone does not

		// Builds the row -- fetching the panels module the first time -- then calls back. Asynchronous now,
		// so the callback re-checks that the row is still wanted rather than showing it unconditionally.
		function ensureBuilt(then) {
			if ($quickRow.data(&quot;built&quot;)) {
				then();
				return;
			}
			withPanels(&quot;sense&quot;, function (panels) {
				if (!$quickRow.data(&quot;built&quot;)) {
					panels.buildAdvancedPanel($quickRow, $li, $h3, language, sectionType, sectionOrdinal, definitionLevel, isLastSense);
					$quickRow.data(&quot;built&quot;, true);
				}
				then();
			});
		}

		// Anything the user has started here: an open field box, the open dropdown, or focus inside the row.
		function engaged() {
			return pinned ||
				$quickRow.find(&quot;.dsb-open-boxes&quot;).children().length &gt; 0 ||
				$quickRow.find(&quot;.dsb-more-menu&quot;).is(&quot;:visible&quot;) ||
				$.contains($quickRow.get(0), document.activeElement);
		}

		function setPinned(next) {
			if (pinned === next) {
				return;
			}
			pinned = next;
			pinnedRows += next ? 1 : -1;
		}

		$toggle.on(&quot;click&quot;, function (e) {
			e.preventDefault();
			// Through their own cancel handler rather than a bare hide(), so a row this closes also drops
			// its pinned state -- hiding it alone would leave pinnedRows counting a row nobody can see.
			$(&quot;.dsb-quick-row&quot;).not($quickRow).trigger(&quot;dsbCancel&quot;);
			setPinned(!pinned);
			if (pinned) {
				ensureBuilt(function () {
					if (pinned) {
						$quickRow.show();
					}
				});
			} else {
				$quickRow.hide();
			}
		});

		// Hover reveals the row and takes it away again, the way en.wikt's does -- but never while something
		// on it is in use, or a half-typed box would vanish on the way to the mouse leaving.
		$li.on(&quot;mouseenter.dsbHover&quot;, function () {
			// iOS plays a tap as mouseenter first, and a row shown here would swallow that tap's click.
			if (!canHover) {
				return;
			}
			// A row the pencil is holding open is already open, and no row opens on hover while another
			// one is: that is the case where the page is being edited and must stay still.
			if (pinned || pinnedRows) {
				return;
			}
			// Hover reveals a row that already exists; it never fetches the panels module. Otherwise
			// simply moving the pointer across an entry would pull ~100 KB on every page view, which is
			// the whole cost the split exists to avoid. The pencil is what asks for it.
			if ($quickRow.data(&quot;built&quot;)) {
				$quickRow.show();
			}
		});
		// Raised by the panel's &quot;Betal bike&quot; (see dsb-panels.js): clear the pinned state as well as
		// hiding, so one click on the pencil opens it again.
		$quickRow.on(&quot;dsbCancel&quot;, function () {
			setPinned(false);
			$quickRow.hide();
		});

		$li.on(&quot;mouseleave.dsbHover&quot;, function () {
			if (!engaged()) {
				$quickRow.hide();
			}
		});

		$toolbar.append($toggle);
		// The class positions the &lt;li&gt;, so the toolbar's gutter slot is measured from the line itself and
		// not from wherever it happens to sit in the child order -- ShowIDs prepends its id pill to this
		// same &lt;li&gt;.
		$li.addClass(&quot;dsb-def&quot;).prepend($toolbar);

		// Touch has no :hover -- a tap anywhere on the line reveals the pencil the same way hovering does on
		// desktop (CSS gates this to touch devices; harmless if it also fires on a mouse click).
		$li.on(&quot;click.dsbReveal&quot;, function () {
			$toolbar.addClass(&quot;dsb-revealed&quot;);
		});

		// Land $quickRow right after the sense's own gloss text -- before any existing &quot;Hevmane: ...&quot; &lt;dl&gt;,
		// citation &lt;ul&gt;, or the Nimûne/jêgirtin proxy link's own &lt;ul&gt;, not appended after all of that.
		var $firstBlock = $li.children(&quot;dl, ul, ol&quot;).first();
		if ($firstBlock.length) {
			$firstBlock.before($quickRow);
		} else {
			$li.append($quickRow);
		}
	}

	// A heading's pencil: its toolbar, the pencil itself and the hidden panel it opens.
	function headingPencil(title, panelClass) {
		var $toggle = $(&quot;&lt;a href='#' class='dsb-toggle'&gt;&lt;/a&gt;&quot;).attr(&quot;title&quot;, title);
		return {
			$toolbar: $(&quot;&lt;span class='dsb-toolbar dsb-toolbar-heading'&gt;&lt;/span&gt;&quot;).append($toggle),
			$toggle: $toggle,
			$panel: $(&quot;&lt;div&gt;&lt;/div&gt;&quot;).addClass(panelClass || &quot;dsb-subsection-panel&quot;).hide()
		};
	}

	// Fills $panel the first time it is opened: build gets the exports of the module for part.
	function buildOnce($panel, part, build) {
		if ($panel.data(&quot;built&quot;)) {
			return;
		}
		$panel.data(&quot;built&quot;, true);
		$panel.text(msg.loading);
		withPanels(part, function (panels) {
			$panel.empty();
			build(panels);
		});
	}

	// A section the data marks hidden is left alone.
	function isHiddenSection(header) {
		return PAGE_SUBSECTIONS.some(function (s) {
			return s.hidden &amp;&amp; s.header === header;
		});
	}

	// The translation section, whose pencil opens the translation adder on its boxes.
	function isWergerSection(header) {
		return PAGE_SUBSECTIONS.some(function (s) {
			return s.kind === &quot;werger&quot; &amp;&amp; s.header === header;
		});
	}

	// The heading itself inside a skin's wrapper div, or the heading when there is no wrapper.
	function innerHeading($el) {
		return $el.is(&quot;h2, h3, h4, h5, h6&quot;) ? $el : $el.find(&quot;h2, h3, h4, h5, h6&quot;).first();
	}

	// &quot;===&quot; sections that sit beside the parts of speech: a Werger after one belongs above it, not under it.
	var BESIDE_POS = [&quot;Bilêvkirin&quot;, &quot;Etîmolojî&quot;, &quot;Çavkanî&quot;];

	// Why the translation adder cannot reach a Werger, or null when it can. {$heading, pos} when a heading
	// at part-of-speech level comes between it and its part of speech (&quot;=== Jê ===&quot; after &quot;=== Mane ===&quot;),
	// or when the Werger itself is not at h4; $heading is what belongs at h4. {beside, pos} when it sits
	// under a section like &quot;=== Çavkanî ===&quot; and has to move above it instead.
	function wergerBlocker($h) {
		var depth = headingDepth(headingOuter($h));
		var $top = depth === 3 ? $h : null;
		for (var $c = headingOuter($h).prev(); $c.length; $c = $c.prev()) {
			var d = headingDepth($c);
			if (!d || d &gt; 3) {
				continue;
			}
			if (d &lt; 3) {
				return null;
			}
			var $hh = innerHeading($c);
			var isPos = !!sections.sectionKeyOf($hh);
			if (!$top) {
				if (isPos) {
					return depth === 4 ? null : { $heading: $h, pos: headingText($hh) };
				}
				$top = $hh;
			} else if (isPos) {
				var name = headingText($top);
				return BESIDE_POS.indexOf(name) !== -1 ? { beside: name, pos: headingText($hh) }
					: { $heading: $top, pos: headingText($hh) };
			}
		}
		return null;
	}

	// Says why a Werger's panel has no translation adder, with a button that queues the fix when a
	// heading's depth is all that is wrong.
	function wergerBlockerNotice(language, blocker) {
		var $notice = $(&quot;&lt;div class='dsb-werger-blocked'&gt;&lt;/div&gt;&quot;);
		if (blocker.beside) {
			return $notice.text(&quot;Amûra tercimeyan li vir naxebite: ev beş di bin «&quot; + blocker.beside +
				&quot;» de ye. Wê bibe ser «&quot; + blocker.beside + &quot;», di bin «&quot; + blocker.pos + &quot;» de, û rûpelê nû bike.&quot;);
		}
		var name = headingText(blocker.$heading);
		var from = headingDepth(headingOuter(blocker.$heading));
		$notice.text(&quot;Amûra tercimeyan li vir naxebite: «&quot; + name + &quot;» bi h&quot; + from + &quot; hatiye nivîsandin, &quot; +
			&quot;loma ev beş ne rasterast di bin «&quot; + blocker.pos + &quot;» de ye. «&quot; + name + &quot;» bike h4, qeyd bike û rûpelê nû bike.&quot;);
		var $fix = $(&quot;&lt;button type='button' class='dsb-werger-blocked-fix'&gt;&lt;/button&gt;&quot;).text(&quot;«&quot; + name + &quot;» bike h4&quot;);
		$fix.on(&quot;click&quot;, function (e) {
			e.preventDefault();
			withPanels(function (panels) {
				panels.setDepth(language, blocker.$heading, 4);
			});
			revealQueue();
			$fix.prop(&quot;disabled&quot;, true);
		});
		return $notice.append(&quot; &quot;, $fix);
	}

	// Everything between a heading and the next heading at its level or above.
	function sectionBody($heading) {
		var depth = headingDepth($heading);
		var $body = $();
		for (var $cursor = $heading.next(); $cursor.length; $cursor = $cursor.next()) {
			var d = headingDepth($cursor);
			if (d &amp;&amp; d &lt;= depth) {
				break;
			}
			$body = $body.add($cursor);
		}
		return $body;
	}

	// An editor for the translation adder that fetches the panels only when a change is first made, so a
	// page view with translation boxes does not pull them.
	function lazyTranslationEditor($h3, language, sectionType) {
		var real = null;
		function withEditor(fn) {
			withPanels(function (panels) {
				real = real || panels.translationEditor($h3, language, sectionType);
				panels.openQueueBox();
				fn(real);
			});
		}
		return {
			withCurrentText: function (callback) {
				withEditor(function (ed) {
					ed.withCurrentText(callback);
				});
			},
			addEdit: function (edit, node) {
				withEditor(function (ed) {
					ed.addEdit(edit, node);
				});
			},
			error: function (message) {
				mw.notify(message, { type: &quot;error&quot; });
			},
			undo: function () {
				withEditor(function (ed) {
					ed.undo();
				});
			}
		};
	}

	// Under &quot;==== Werger ====&quot; every box gets the form for a new translation and a ± on its heading, from
	// [[MediaWiki:Gadget-wikt.translation-adder.js]]. The heading's pencil opens the boxes' own form (sense,
	// note, id of each box, and more boxes) and puts ✎ and × on the existing lines; &quot;+ Qutiyeke din zêde
	// bike&quot; under the boxes opens that form on a new box. All their changes join the save queue. False
	// when the section has no box the adder reads.
	function attachWergerEditor($hh, $heading, $h3, header, language, sectionType, sectionOrdinal) {
		var $body = sectionBody($heading);
		if (!$body.find(&quot;table.translations&quot;).length) {
			return false;
		}
		var editor = lazyTranslationEditor($h3, language, sectionType);
		var adder = mw.loader.using(&quot;ext.gadget.wikt.translation-adder&quot;).then(function (require) {
			var api = require(&quot;ext.gadget.wikt.translation-adder&quot;);
			return api.attach($body, editor).then(function () {
				return api;
			});
		});
		var pencil = headingPencil(header + &quot; biguhêre&quot;);
		var $toolbar = pencil.$toolbar;
		var $toggle = pencil.$toggle;
		var $panel = pencil.$panel;
		placeHeadingToolbar($hh, $toolbar);
		revealHeadingToolbarOnTap($hh, $toolbar);
		$heading.after($panel);

		function lineEditing(open) {
			if (open) {
				// Collapsed boxes are opened, so their lines are in sight.
				$body.find(&quot;.NavFrame&quot;).each(function () {
					if ($(this).children(&quot;.NavContent&quot;).is(&quot;:hidden&quot;)) {
						$(this).find(&quot;.NavToggle&quot;).first().trigger(&quot;click&quot;);
					}
				});
			}
			adder.then(function (api) {
				api.setLineEditing($body, editor, open);
			}, function () {
				mw.notify(&quot;Nikare amûra tercimeyan bar bike.&quot;, { type: &quot;error&quot; });
			});
		}

		function showPanel() {
			$panel.show();
			$toolbar.addClass(&quot;dsb-revealed dsb-werger-open&quot;);
			buildOnce($panel, &quot;subsection&quot;, function (panels) {
				panels.buildSubsectionPanel($panel, $h3, language, sectionType, sectionOrdinal, header);
			});
			revealQueue();
		}

		$toggle.on(&quot;click&quot;, function (e) {
			e.preventDefault();
			var open = !$panel.is(&quot;:visible&quot;);
			if (open) {
				showPanel();
			} else {
				$panel.hide();
				$toolbar.removeClass(&quot;dsb-revealed dsb-werger-open&quot;);
			}
			lineEditing(open);
		});
		// The panel's &quot;Betal bike&quot; closes it the way the pencil does.
		$panel.on(&quot;dsbPanelClosed&quot;, function () {
			$toolbar.removeClass(&quot;dsb-revealed dsb-werger-open&quot;);
			lineEditing(false);
		});

		var $add = $(&quot;&lt;a href='#' class='dsb-quick-link'&gt;+ Qutiyeke din zêde bike&lt;/a&gt;&quot;).on(&quot;click&quot;, function (e) {
			e.preventDefault();
			var addBox = $panel.data(&quot;dsbAddBox&quot;);
			if ($panel.is(&quot;:visible&quot;) &amp;&amp; addBox) {
				addBox();
				return;
			}
			$panel.data(&quot;dsbAddBoxPending&quot;, true);
			showPanel();
			// A form built before this click has its boxes already; the new one goes in now.
			if (addBox) {
				$panel.removeData(&quot;dsbAddBoxPending&quot;);
				addBox();
			}
		});
		$(&quot;&lt;div class='dsb-werger-add'&gt;&lt;/div&gt;&quot;).append($add).insertAfter($body.last());
		return true;
	}

	// Every subsection under a part of speech, whether or not the data knows the header: one it does not
	// know opens as wikitext, or as a word list when that is what it holds -- see buildSubsectionPanel.
	function attachSubsectionEditors($h3, language, sectionType, sectionOrdinal, posDepth) {
		posDepth = posDepth || 3;
		for (var $cursor = headingOuter($h3).next(); $cursor.length; $cursor = $cursor.next()) {
			var depth = headingDepth($cursor);
			if (depth &amp;&amp; depth &lt;= posDepth) {
				break;
			}
			if (depth !== posDepth + 1) {
				continue;
			}
			var $hh = $cursor.is(&quot;h2, h3, h4, h5, h6&quot;) ? $cursor : $cursor.find(&quot;h2, h3, h4, h5, h6&quot;).first();
			var header = headingText($hh);
			if (!header || $hh.data(&quot;dsbAttached&quot;)) {
				continue;
			}
			if (isWergerSection(header)) {
				$hh.data(&quot;dsbAttached&quot;, true);
				// A Werger heading with no box gets the section pencil, whose form adds one; old-style
				// boxes the translation adder cannot read are left alone.
				if (attachWergerEditor($hh, $cursor, $h3, header, language, sectionType, sectionOrdinal) ||
					sectionBody($cursor).find(&quot;.NavFrame&quot;).length) {
					continue;
				}
				attachSubsectionEditor($hh, $cursor, $h3, header, language, sectionType, sectionOrdinal);
				continue;
			}
			if (isHiddenSection(header)) {
				continue;
			}
			$hh.data(&quot;dsbAttached&quot;, true);
			attachSubsectionEditor($hh, $cursor, $h3, header, language, sectionType, sectionOrdinal);
		}
	}

	// Where the pencil goes depends on what the skin does with its own edit links. Desktop skins put
	// &quot;[biguhêre]&quot; right after the heading text, so the pencil follows it and the two read as one group.
	// Minerva parks its edit icon at the far right of the heading row instead, a screen-width away from the
	// text, so there the pencil goes inside the heading rather than chasing it.
	function placeHeadingToolbar($heading, $toolbar) {
		if (mw.config.get(&quot;skin&quot;) !== &quot;minerva&quot;) {
			var $editsection = headingOuter($heading).find(&quot;.mw-editsection&quot;).first();
			if ($editsection.length) {
				$editsection.after($toolbar);
				return;
			}
		}
		$heading.append($toolbar);
	}

	// Touch has no hover, so a heading's pencil is shown by tapping the heading itself. Taps that mean
	// something else are left alone: the skin's own edit links, and the pencil once it is showing.
	function revealHeadingToolbarOnTap($heading, $toolbar) {
		headingOuter($heading).on(&quot;click&quot;, function (e) {
			if ($(e.target).closest(&quot;a, .dsb-toolbar&quot;).length) {
				return;
			}
			$toolbar.toggleClass(&quot;dsb-revealed&quot;);
		});
	}

	// One pencil's worth of behaviour, shared by the &quot;====&quot; headings and by an image's own caption: the
	// panel is built the first time it is opened, never before, and the pencil stays visible while it is.
	// free, when given, pins the panel to a heading located by its own text rather than through a part of
	// speech: {header, ordinal}.
	function bindPanelToggle($toggle, $toolbar, $panel, $h3, header, language, sectionType, sectionOrdinal, free) {
		$toggle.on(&quot;click&quot;, function (e) {
			e.preventDefault();
			$panel.toggle();
			// Stays put while its panel is open, so it does not vanish from under the pointer.
			$toolbar.toggleClass(&quot;dsb-revealed&quot;, $panel.is(&quot;:visible&quot;));
			if (!$panel.is(&quot;:visible&quot;)) {
				return;
			}
			buildOnce($panel, &quot;subsection&quot;, function (panels) {
				panels.buildSubsectionPanel($panel, $h3, language, sectionType, sectionOrdinal, header, free);
				if (free &amp;&amp; free.blocker) {
					$panel.prepend(wergerBlockerNotice(language, free.blocker));
				}
			});
			revealQueue();
		});
		$panel.on(&quot;dsbPanelClosed&quot;, function () {
			$toolbar.removeClass(&quot;dsb-revealed&quot;);
		});
	}

	function attachSubsectionEditor($hh, $heading, $h3, header, language, sectionType, sectionOrdinal) {
		var pencil = headingPencil(header + &quot; biguhêre&quot;);
		var $toolbar = pencil.$toolbar;
		var $toggle = pencil.$toggle;
		var $panel = pencil.$panel;
		placeHeadingToolbar($hh, $toolbar);
		revealHeadingToolbarOnTap($hh, $toolbar);
		$heading.after($panel);
		bindPanelToggle($toggle, $toolbar, $panel, $h3, header, language, sectionType, sectionOrdinal);
	}

	// The &quot;place&quot; subsection that owns the thumbnails under a part-of-speech heading -- named in the data,
	// not spelled out here, so renaming it there renames it everywhere.
	var IMAGE_HEADER = (function () {
		var found = null;
		PAGE_SUBSECTIONS.forEach(function (s) {
			if (s.place === &quot;pos-top&quot;) {
				found = s.header;
			}
		});
		return found;
	}());

	// A pencil on the image's own caption. A wrong caption is noticed while looking at the picture, and
	// this is where the writer reaches for it -- the same editor the section's own list offers, opened on
	// the image that is already there.
	// Every thumbnail between the heading and the first subsection, which is the run &quot;pos-top&quot; covers.
	// Anything else in that run is stepped over: a headword line, a declension table or the stylesheet a
	// template brings with it all sit before the pictures on plenty of entries.
	function attachImageEditors($h3, language, sectionType, sectionOrdinal) {
		if (!IMAGE_HEADER) {
			return;
		}
		for (var $cursor = headingOuter($h3).next(); $cursor.length; $cursor = $cursor.next()) {
			if (headingDepth($cursor)) {
				break;
			}
			if ($cursor.is(&quot;.thumb, figure, .floatright, .floatleft&quot;)) {
				attachImageEditor($cursor, $h3, language, sectionType, sectionOrdinal);
			}
		}
	}

	// A &quot;===&quot; section that is not a part of speech but is one of ours: Bilêvkirin, which sits above the
	// part-of-speech blocks and belongs to the whole language.
	function placeSubsectionFor($h3) {
		var text = headingText($h3);
		var found = null;
		PAGE_SUBSECTIONS.forEach(function (s) {
			if (s.place === &quot;pron&quot; &amp;&amp; s.header === text) {
				found = s;
			}
		});
		return found;
	}

	// The first part-of-speech heading under the same language. The writer works from a section, so
	// without one there is nothing to anchor the box to.
	function firstPosHeadingAfter($h3) {
		for (var $cursor = headingOuter($h3).next(); $cursor.length; $cursor = $cursor.next()) {
			if ($cursor.is(&quot;.mw-heading2, h2&quot;)) {
				return null; // the next language starts
			}
			var depth = headingDepth($cursor);
			if (depth !== 3 &amp;&amp; depth !== 4) {
				continue;
			}
			var $hh = $cursor.is(&quot;h3, h4&quot;) ? $cursor : $cursor.find(&quot;h3, h4&quot;).first();
			if (sectionTypeOf($hh) || isManeHeading($hh)) {
				return $hh;
			}
		}
		return null;
	}

	// Its own pencil, opening the same box the section list offers -- a heading nobody can edit from the
	// page is a heading people edit by hand.
	function attachPlaceHeadingEditor($h3, subsection) {
		if ($h3.data(&quot;dsbAttached&quot;)) {
			return;
		}
		var $pos = firstPosHeadingAfter($h3);
		if (!$pos) {
			return;
		}
		var $ol = null;
		for (var $cursor = headingOuter($pos).next(); $cursor.length; $cursor = $cursor.next()) {
			if ($cursor.is(&quot;ol&quot;)) {
				$ol = $cursor;
				break;
			}
			if ($cursor.is(&quot;.mw-heading2, .mw-heading3, h2, h3&quot;)) {
				break;
			}
		}
		var language = $ol &amp;&amp; languageCodeForOl($ol);
		if (!language) {
			return;
		}
		$h3.data(&quot;dsbAttached&quot;, true);
		var pencil = headingPencil(subsection.header + &quot; &quot; + msg.edit);
		var $toolbar = pencil.$toolbar;
		var $toggle = pencil.$toggle;
		var $panel = pencil.$panel;
		placeHeadingToolbar($h3, $toolbar);
		revealHeadingToolbarOnTap($h3, $toolbar);
		headingOuter($h3).after($panel);
		bindPanelToggle($toggle, $toolbar, $panel, $pos, subsection.header, language,
			sectionTypeOf($pos) || MANE_SECTION, sectionOrdinalWithinLanguage($pos));
	}

	// Every other heading inside a language: the ones that sit beside the parts of speech rather than
	// under one (&quot;=== Etîmolojî ===&quot;, &quot;=== Çavkanî ===&quot;), and the ones nobody planned for. Each opens
	// the wikitext under its own heading, or the {{kol3}} form when that is what it holds.
	function attachFreeSectionEditors() {
		$(&quot;#mw-content-text&quot;).find(&quot;h3, h4, h5, h6&quot;).each(function () {
			var $h = $(this);
			// A heading that already carries one of this gadget's pencils is spoken for.
			if ($h.data(&quot;dsbAttached&quot;) || headingOuter($h).find(&quot;.dsb-toolbar&quot;).length) {
				return;
			}
			var header = headingText($h);
			if (!header || isHiddenSection(header)) {
				return;
			}
			var language = languageCodeForOl($h);
			if (!language) {
				return;
			}
			$h.data(&quot;dsbAttached&quot;, true);
			attachFreeSectionEditor($h, header, language);
		});
	}

	function attachFreeSectionEditor($h, header, language) {
		var free = { header: header, ordinal: headingTextOrdinalWithinLanguage($h),
			blocker: isWergerSection(header) ? wergerBlocker($h) : null };
		var pencil = headingPencil(header + &quot; &quot; + msg.edit);
		var $toolbar = pencil.$toolbar;
		var $toggle = pencil.$toggle;
		var $panel = pencil.$panel;
		placeHeadingToolbar($h, $toolbar);
		revealHeadingToolbarOnTap($h, $toolbar);
		headingOuter($h).after($panel);
		bindPanelToggle($toggle, $toolbar, $panel, $h, header, language, null, 0, free);
	}

	function attachImageEditor($fig, $h3, language, sectionType, sectionOrdinal) {
		if ($fig.data(&quot;dsbAttached&quot;)) {
			return;
		}
		var $caption = $fig.find(&quot;figcaption, .thumbcaption&quot;).first();
		if (!$caption.length) {
			return;
		}
		$fig.data(&quot;dsbAttached&quot;, true);
		var $toolbar = $(&quot;&lt;span class='dsb-toolbar dsb-toolbar-caption'&gt;&lt;/span&gt;&quot;);
		var $toggle = $(&quot;&lt;a href='#' class='dsb-toggle'&gt;&lt;/a&gt;&quot;).attr(&quot;title&quot;, IMAGE_HEADER + &quot; biguhêre&quot;);
		// After the figure, not inside it: the panel is full width, and a floated thumbnail is not.
		var $panel = $(&quot;&lt;div class='dsb-subsection-panel dsb-panel-after-image'&gt;&lt;/div&gt;&quot;).hide();
		$toolbar.append($toggle);
		$caption.append($toolbar);
		revealHeadingToolbarOnTap($caption, $toolbar);
		$fig.after($panel);
		bindPanelToggle($toggle, $toolbar, $panel, $h3, IMAGE_HEADER, language, sectionType, sectionOrdinal);
	}

	function attachSubsectionTrigger($h3, $ol, language, sectionType, sectionOrdinal) {
		if ($h3.data(&quot;dsbAttached&quot;)) {
			return;
		}
		$h3.data(&quot;dsbAttached&quot;, true);

		var $anchor = $ol;
		for (var $cursor = $ol.next(); $cursor.length; $cursor = $cursor.next()) {
			if ($cursor.is(&quot;.mw-heading2, .mw-heading3, .mw-heading4, .mw-heading5, .mw-heading6, h2, h3, h4, h5, h6&quot;)) {
				break;
			}
			$anchor = $cursor;
		}

		var $trigger = $(&quot;&lt;a href='#' class='dsb-add-subsection'&gt;+ Binebeşekê lê zêde bike&lt;/a&gt;&quot;);
		var $panel = $(&quot;&lt;div class='dsb-subsection-panel'&gt;&lt;/div&gt;&quot;).hide();
		$trigger.on(&quot;click&quot;, function (e) {
			e.preventDefault();
			$panel.toggle();
			if (!$panel.is(&quot;:visible&quot;)) {
				return;
			}
			buildOnce($panel, &quot;subsection&quot;, function (panels) {
				panels.buildSubsectionPanel($panel, $h3, language, sectionType, sectionOrdinal);
			});
			revealQueue();
		});

		$anchor.after($panel);
		$anchor.after($trigger);
	}

	// Attaches the &quot;choose a part of speech&quot; trigger under a heading whose part of speech is unsettled: an
	// unclassified &quot;=== Mane ===&quot; placeholder, or a &quot;=== Biwêj ===&quot; that is really a noun, verb, ... .
	function attachConvertPosTrigger($h3, sectionType) {
		if ($h3.data(&quot;dsbConvertAttached&quot;)) {
			return;
		}
		$h3.data(&quot;dsbConvertAttached&quot;, true);

		// languageCodeForOl() is really just &quot;nearest preceding .besazimani[id] before this element in
		// document order&quot; -- nothing ol-specific about it, so it works unchanged for a heading too.
		var language = languageCodeForOl($h3);
		if (!language) {
			return;
		}
		var sectionOrdinal = sectionOrdinalWithinLanguage($h3);

		// The same pencil the &quot;====&quot; subsections get, so reclassifying reads as an edit affordance rather
		// than a line of body text.
		var pencil = headingPencil(&quot;Cureyê rêzimanî hilbijêre&quot;, &quot;dsb-convert-pos-panel&quot;);
		var $toolbar = pencil.$toolbar;
		var $toggle = pencil.$toggle;
		var $panel = pencil.$panel;
		$toggle.on(&quot;click&quot;, function (e) {
			e.preventDefault();
			$panel.toggle();
			// Stays put while its panel is open, so it does not vanish from under the pointer.
			$toolbar.toggleClass(&quot;dsb-revealed&quot;, $panel.is(&quot;:visible&quot;));
			if (!$panel.is(&quot;:visible&quot;)) {
				return;
			}
			buildOnce($panel, &quot;pos&quot;, function (panels) {
				panels.buildConvertPosPanel($panel, $h3, language, sectionType, sectionOrdinal);
			});
			revealQueue();
		});
		// Raised by the panel's &quot;Betal bike&quot;: closes it and drops what was typed, so the pencil reopens it fresh.
		$panel.on(&quot;dsbCancel&quot;, function () {
			$panel.hide().empty().data(&quot;built&quot;, false);
			$toolbar.removeClass(&quot;dsb-revealed&quot;);
		});

		placeHeadingToolbar($h3, $toolbar);
		revealHeadingToolbarOnTap($h3, $toolbar);
		headingOuter($h3).after($panel);
	}

	// ---- driver ----

	function init() {
		$(&quot;h3, h4&quot;).each(function () {
			var $h3 = $(this);
			var posDepth = headingDepth($h3) || 3;
			var sectionType = sectionTypeOf($h3);
			if (!sectionType) {
				var place = placeSubsectionFor($h3);
				if (place) {
					attachPlaceHeadingEditor($h3, place);
					return;
				}
				if (!isManeHeading($h3)) {
					return; // not a recognized word-sense section (Etîmolojî, Çavkanî, ...)
				}
				// An unclassified placeholder: offer the POS picker, then carry on and wire up the same
				// per-sense pencils, so the POS choice and the sense edits can be queued and saved together.
				sectionType = MANE_SECTION;
				attachConvertPosTrigger($h3, sectionType);
			} else {
				// Every part of speech, not just the ones most often mistaken: any section can turn out to
				// be another, and the picker is what changes it.
				attachConvertPosTrigger($h3, sectionType);
			}
			var sectionOrdinal = sectionOrdinalWithinLanguage($h3);

			var $ol = null;
			for (var $cursor = headingOuter($h3).next(); $cursor.length; $cursor = $cursor.next()) {
				if ($cursor.is(&quot;ol&quot;)) {
					$ol = $cursor;
					break;
				}
				if (headingDepth($cursor)) {
					break;
				}
			}
			if (!$ol) {
				return;
			}

			var language = languageCodeForOl($ol);
			if (!language) {
				return;
			}

			var lastTopIndex = $ol.children(&quot;li&quot;).not(&quot;.mw-empty-elt&quot;).length - 1;
			eachLeafDefinition($ol, function ($li) {
				var definitionLevel = [];
				var $definitionItem = $li;
				while ($definitionItem.prop(&quot;tagName&quot;) === &quot;LI&quot;) {
					definitionLevel.splice(0, 0, $definitionItem.prevAll(&quot;li:not(.mw-empty-elt)&quot;).length);
					$definitionItem = $definitionItem.parent().parent();
				}
				definitionLevel.splice(0, 0, sectionType + &quot;|&quot; + sectionOrdinal);
				var isLastSense = definitionLevel.length === 2 &amp;&amp; definitionLevel[1] === lastTopIndex;
				attachToolbar($li, language, sectionType, sectionOrdinal, definitionLevel, $h3, isLastSense);
				attachExampleEditors($li, language, sectionType, sectionOrdinal, definitionLevel, $h3);
			});

			attachSubsectionTrigger($h3, $ol, language, sectionType, sectionOrdinal, posDepth);
			attachSubsectionEditors($h3, language, sectionType, sectionOrdinal, posDepth);
			attachImageEditors($h3, language, sectionType, sectionOrdinal);
		});

		// Last, so a heading one of the walks above claimed keeps the pencil that knows more about it.
		attachFreeSectionEditors();
		attachHeadingTools();
	}

	// Beside each heading's pencil: ▲ ▼ to move an &quot;===&quot; section within its language, and its depth
	// (h3, h4, h5) for any heading from &quot;===&quot; to &quot;=====&quot;. Both go into the save queue.
	function attachHeadingTools() {
		$(&quot;#mw-content-text&quot;).find(&quot;h3, h4, h5&quot;).each(function () {
			var $h = $(this);
			var depth = headingDepth($h);
			var language = languageCodeForOl($h);
			if (depth &lt; 3 || depth &gt; 5 || !language || !headingText($h) || $h.data(&quot;dsbHeadingTools&quot;)) {
				return;
			}
			$h.data(&quot;dsbHeadingTools&quot;, true);
			var $toolbar = headingOuter($h).find(&quot;.dsb-toolbar-heading&quot;).first();
			if (!$toolbar.length) {
				$toolbar = $(&quot;&lt;span class='dsb-toolbar dsb-toolbar-heading'&gt;&lt;/span&gt;&quot;);
				placeHeadingToolbar($h, $toolbar);
				revealHeadingToolbarOnTap($h, $toolbar);
			}
			var $tools = $(&quot;&lt;span class='dsb-heading-tools'&gt;&lt;/span&gt;&quot;);
			if (depth === 3) {
				[[-1, &quot;▲&quot;, &quot;Vê beşê bibe jor&quot;], [1, &quot;▼&quot;, &quot;Vê beşê bibe jêr&quot;]].forEach(function (b) {
					$(&quot;&lt;button type='button' class='dsb-heading-move'&gt;&lt;/button&gt;&quot;).text(b[1]).attr(&quot;title&quot;, b[2])
						.on(&quot;click&quot;, function (e) {
							e.preventDefault();
							withPanels(function (panels) {
								panels.moveH3(language, $h, b[0]);
							});
							revealQueue();
						})
						.appendTo($tools);
				});
			}
			var $depth = $(&quot;&lt;select class='dsb-heading-depth'&gt;&lt;/select&gt;&quot;).attr(&quot;title&quot;, &quot;Dereceya sernavê&quot;);
			[3, 4, 5].forEach(function (d) {
				$depth.append($(&quot;&lt;option&gt;&lt;/option&gt;&quot;).val(d).text(&quot;h&quot; + d));
			});
			$depth.val(depth).on(&quot;change&quot;, function () {
				var to = Number($depth.val());
				withPanels(function (panels) {
					panels.setDepth(language, $h, to);
				});
				revealQueue();
			});
			$tools.append($depth);
			$toolbar.append($tools);
		});
	}

	// One listener for every &quot;Hevmane û Bêhtir&quot; dropdown on the page.
	$(document).on(&quot;click.dsbMoreMenu&quot;, function (e) {
		$(&quot;.dsb-more-menu:visible&quot;).each(function () {
			var $menu = $(this);
			if ($(e.target).closest($menu).length || $(e.target).closest($menu.prev(&quot;.dsb-more-toggle&quot;)).length) {
				return;
			}
			$menu.slideUp();
			var $arrow = $menu.data(&quot;dsbArrow&quot;);
			if ($arrow) {
				$arrow.text(&quot;▸&quot;);
			}
		});
	});

	// Closes every open panel/preview this gadget can leave in the DOM, so bfcache never freezes one mid-open.
	function closeAllOpenUi() {
		if (panelsApi) {
			panelsApi.clearQueue();
			panelsApi.closeAllPanels();
			return;
		}
		// Before the panels arrive there is nothing built to tear down, only the view-path rows.
		$(&quot;.dsb-quick-row, .dsb-more-menu, .dsb-preview-inline, .dsb-preview-block&quot;).hide();
	}
	$(window).on(&quot;pagehide&quot;, closeAllOpenUi);
	// Belt-and-suspenders: also close on restore-from-bfcache, in case pagehide's own hide didn't stick.
	$(window).on(&quot;pageshow&quot;, function (e) {
		if (e.originalEvent &amp;&amp; e.originalEvent.persisted) {
			closeAllOpenUi();
		}
	});

	$(init);
	// &lt;/nowiki&gt;
}());
// &lt;/nowiki&gt;</text>
      <sha1>s4lifbnocgn7283g4oljq1igyd6kima</sha1>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Gadget-wikt.start-wizard.js</title>
    <ns>8</ns>
    <id>1359175</id>
    <revision>
      <id>6903105</id>
      <parentid>6865630</parentid>
      <timestamp>2026-11-10T21:29:06Z</timestamp>
      <contributor>
        <username>Wikihez</username>
        <id>7344</id>
      </contributor>
      <minor />
      <comment>Script pages under 100 KB: part of the code moved to a second file; shared code in one place</comment>
      <origin>6903105</origin>
      <model>javascript</model>
      <format>text/javascript</format>
      <text bytes="89546" sha1="djoeuga2tvtqag73ejvh5gqnrr77ogq" xml:space="preserve">// &lt;nowiki&gt;
/*
 * Page: [[MediaWiki:Gadget-wikt.start-wizard.js]]
 */
// Li ser [[vi:MediaWiki:Gadget-start.js]] hatiye refaktorkirin.
// implicit dependencies: StorageUtils (ObjectStorage), Gadget-citoid-helper.js (wikt.citoid)
/* global ObjectStorage, wikt */

$(function () {
	if (window.location.href.includes(&quot;editintro=User:Wikihez/creation/intro&quot;)) {
		return; // Do not run the script wextê WF:Bilez dişuxile
	}

	// The same gate DefSideBoxes, add-examples and this wizard's own launcher use, so a page one of them
	// works on is never a page this one quietly refuses to open on.
	var ns = mw.config.get(&quot;wgNamespaceNumber&quot;);
	if (!require(&quot;ext.gadget.wikt.core&quot;).sections.isEntryPage()) {
		return;
	}
	// Reconstructed entries (ns 108) are unattested proto-forms: there is no recorded usage to give an
	// example of or quote, and no dialects to mark, so the sense block leaves out Nimûne, Jêgirtin and
	// Dever/Şîwe there.
	var isReconstruction = ns === 108;

	var addLangMode = mw.util.getParamValue(&quot;wiktkuaddlang&quot;) === &quot;1&quot;;

	// ── Tercîh (user settings) panel stored via mw.storage (localStorage), globally
	// Defaults and storage live in wikt.core/prefs.js, because the launcher reads them on every page view.
	var wiktkuPrefsApi = require(&quot;ext.gadget.wikt.core&quot;).prefs;
	function wiktkuLoadPrefs() { return wiktkuPrefsApi.load(); }
	function wiktkuSavePrefs(prefs) { return wiktkuPrefsApi.save(prefs); }

	var wiktkuPrefs = wiktkuLoadPrefs();

	// Routine/informational notices go through here so &quot;quiet mode&quot; can
	// suppress them; errors and explicit-action confirmations (like the
	// Tercîh save toast) call mw.notify directly instead, and always show.
	function wiktkuNotify(message, options) {
		if (wiktkuPrefs.quiet) return;
		mw.notify(message, options);
	}

	// The launcher gadget adds the portlet link and decides whether this page wants the wizard before
	// loading it at all. Both are repeated here only when this file was loaded on its own.
	var wiktkuLaunched = !!(window.wikt &amp;&amp; window.wikt.start &amp;&amp; window.wikt.start.launched);

	if (!wiktkuLaunched &amp;&amp; !document.getElementById(&quot;ca-wiktku-addlang&quot;)) {
		wiktkuPrefsApi.addLauncherLink(wiktkuPrefs);

		// If &quot;onlyOnClick&quot; is set, the wizard should ONLY ever open via the
		// &quot;+Ziman/beşeke din&quot; link — never automatically
		var wiktkuNewPageDetected = $(&quot;.mw-newarticletext, .mw-newarticletextanon&quot;).length &gt; 0;
		if (wiktkuPrefs.onlyOnClick ? !addLangMode : (!addLangMode &amp;&amp; !wiktkuNewPageDetected)) {
			return;
		}
	}

	// ── Shared helpers ───────────────────────────────────────────────────
	// Generic text/UI utilities live in their own package file now — see the
	// header of util.js for why. Aliased to bare names here so the ~400 call
	// sites below read exactly as they did when these were local functions.
	var wiktkuEdit = require(&quot;ext.gadget.wikt.edit&quot;);
	var wiktkuUtil = wiktkuEdit.util;
	var wiktkuWikitext = wiktkuEdit.wt;
	var wiktkuLangs = wiktkuEdit.langs;
	// Citations (jêder-*, Kategorî:Çavkanî, Citoid) all go through one module -- see wikt.cite.js.
	var wiktkuCite = require(&quot;ext.gadget.wikt.cite&quot;);
	var wiktkuPosparams = wiktkuEdit.posparams;
	// Assigned once data-main.json is in: re-merges the language choices, and is called a second time if the
	// full language list has to be fetched. Declared here so the step renderer can reach it.
	var wiktkuMergeLanguages = null;
	var capitalize        = wiktkuUtil.capitalize;
	var decapitalize      = wiktkuUtil.decapitalize;
	var escapeRegExp      = wiktkuUtil.escapeRegExp;
	var stripWikilinks    = wiktkuUtil.stripWikilinks;
	var splitTercimeIzah  = wiktkuUtil.splitTercimeIzah;
	var insertAtCursor    = wiktkuUtil.insertAtCursor;
	var wrapNativeSelect  = wiktkuUtil.wrapNativeSelect;
	var initSelects       = wiktkuUtil.initSelects;
	var wiktkuInitManualResize = wiktkuUtil.initManualResize;
	var langHeaderSource  = wiktkuWikitext.langHeaderSource;

	// Inserts a line-style template snippet (&quot;* {{…}}&quot;) at the cursor,
	// prefixing it with a newline unless it's going at the very start of the
	// box or right after one already — otherwise picking a second template
	// from the pron dropdown right after the first lands them both on the
	// same line: &quot;* {{ku-IPA}}* {{ku-kîte}}&quot;.
	function insertLineSnippet(el, snippet) {
		var before = el.value.slice(0, el.selectionStart);
		if (before &amp;&amp; !/\n$/.test(before)) snippet = &quot;\n&quot; + snippet;
		insertAtCursor(el, snippet);
	}

	// One delete button per tab bar, acting on the tab in view. The trash glyph
	// (oojs-ui.styles.icons-moderation) is fetched here rather than at startup: it is only needed once a
	// second Mane or Beş exists. The button is built immediately and the icon appears when the CSS lands.
	function makeTrashButton(title) {
		mw.loader.using(&quot;oojs-ui.styles.icons-moderation&quot;);
		return new OO.ui.ButtonWidget({
			icon: &quot;trash&quot;,
			flags: [&quot;destructive&quot;],
			framed: false,
			invisibleLabel: true,
			label: title,
			title: title,
			classes: [&quot;wiktku-trash-btn&quot;]
		});
	}

	function findLangHeader(text, code) {
		var m = new RegExp(&quot;\n?&quot; + langHeaderSource(escapeRegExp(code))).exec(text);
		return m ? { index: m.index, match: m[0] } : null;
	}

	// The category's members come from wikt.cite, which also lists each template's redirects so it can be
	// found by any of its names. Entries are {label, target}: label is what was typed/shown, target the
	// canonical template to transclude.
	var catSrcTemplates = null;
	function fetchCatSrcTemplates() {
		return wiktkuCite.fetchCategoryTemplates().then(function (list) {
			catSrcTemplates = list;
			return list;
		});
	}

	var pageName = mw.config.get(&quot;wgPageName&quot;).replaceAll(/_/g, &quot; &quot;);
	if (ns) pageName = pageName.replace(/.*\//, &quot;&quot;);
	var userLang = mw.config.get(&quot;wgUserLanguage&quot;);

	var formCache = new ObjectStorage(&quot;wiktku_start_draft_&quot; + mw.config.get(&quot;wgPageName&quot;), 1);

	var langsByCode = {};

	// Looks up the display label for a language code, falling back to the
	// code itself if it isn't known yet (e.g. langsByCode not loaded).
	function getLangLabel(code) {
		var entry = langsByCode[code];
		return entry ? entry.label : code;
	}

	// The mane box holds a Kurdish definition for a Kurdish entry, and a direct translation for every
	// other language -- the {{îzah}} box under it carries the explanation.
	function manePlaceholder(code) {
		return code &amp;&amp; code !== &quot;ku&quot; ? wiktkuUtil.msg.tercimePrompt : &quot;Maneya vê kelîmeyê binivîse…&quot;;
	}

	// A Kurmancî example gets an explanation, any other a translation.
	function nimuneTranslationPrompt(code) {
		return code === &quot;ku&quot; ? &quot;Îzaheke nimûneyê bi kurmancî…&quot; : &quot;Tercimeya nimûneyê bi kurmancî…&quot;;
	}

	// Populated from data-main.json at runtime.
	var metadata = {};

	var ZARAVA_LANG_CODES = [&quot;ckb&quot;, &quot;sdh&quot;, &quot;lki&quot;, &quot;hac&quot;, &quot;zza&quot;];

	// Converts a {code: label} object (langChoices, posChoices)
	// into the {code, label[, sortKey]} array the rest of the script uses.
	// isLang: true adds a sortKey and shows &quot;(code)&quot; after the label —
	// language choices only.
	function choicesFromObject(obj, isLang) {
		var result = [];
		$.each(obj || {}, function (code, label) {
			var choice = { code: code, label: label };
			if (isLang) choice.sortKey = label;
			result.push(choice);
		});
		return result;
	}

	function getZaravaKeys(choices) {
		var byCode = {};
		$.each(choices || [], function (_, c) { byCode[c.code] = c; });
		var result = [];
		$.each(ZARAVA_LANG_CODES, function (_, code) {
			if (byCode[code]) result.push(byCode[code]);
		});
		return result;
	}

	var needsTransliteration = wiktkuPosparams.needsTransliteration;

	// metadata[lang].sc is either a single script string or an array of
	// several — only the latter means the language is actually written in
	// more than one script.
	function langHasMultipleScripts(langCode) {
		var meta = metadata[langCode];
		return !!(meta &amp;&amp; Array.isArray(meta.sc) &amp;&amp; meta.sc.length &gt; 1);
	}

	// Kodên cinsiyetê yên di metadata.g de — ji data-main.json tê dagirtin
	var GENDER_BASE_LABELS = {};

	var SENSE_GROUPS = [];
	var WORDLIST_TEMPLATE = &quot;kol3&quot;; // replaced by data-main.json's first wordlistTemplates entry
	// The pills the Dever/Şîwe picker opens with; everything else comes from Modul:labels by typing.
	var DEVER_QUICK_PICKS = [];
	// ── Template explanations ────────────────────────────────────────────
	// Every place a template can be picked shows the same row: a status
	// dot, the name, a link to the template page, and an ⓘ. This is the ⓘ.
	//
	// Text comes from the template's own TemplateData where it has any, so
	// the explanation stays right without anyone maintaining a second copy
	// by hand — with the desc already in data-main.json as the fallback for
	// templates that have none.
	// {desc, params} for the ⓘ popup, from wikt.edit -- the fetch, the shaping and the cache are all
	// there, shared with wikt.cite and DefSideBoxes, so a template is asked for once however many pickers
	// show it. Null for a template with no TemplateData, and that answer is kept too, so clicking ⓘ on
	// an undocumented template twice is one request.
	var fetchTemplateData = wiktkuEdit.wt.templateDoc;
	var prefetchTemplateData = wiktkuEdit.wt.templateDocBatch;

	/** Rewrites each tagged &lt;option&gt; in `sel` as &quot;name — description&quot;, using
	 *  TemplateData. Only fills rows that have no description yet, so the
	 *  hand-written ones in data-main.json (which carry usage examples the API
	 *  does not) are left exactly as they are. */
	function applyTplDescriptions(sel) {
		if (!sel || !sel.length) return;
		var changed = false;
		sel.find(&quot;option[data-tpl]&quot;).each(function () {
			var opt = $(this);
			var name = opt.attr(&quot;data-tpl&quot;);
			if (opt.text().indexOf(&quot; — &quot;) !== -1) return;   // already described
			var td = wiktkuEdit.wt.templateDocNow(name);
			var desc = (td &amp;&amp; td.desc) || localTplDesc(name);
			if (!desc) return;
			opt.text(name + &quot; — &quot; + wiktkuEdit.wt.shortDesc(desc));
			changed = true;
		});
		// The picker caches option text for searching, so it has to re-read.
		if (changed) sel.trigger(&quot;wiktku:refresh&quot;);
	}

	/** Description from data-main.json's &quot;desc&quot;, for templates with no TemplateData on the wiki. Works for any
	 *  pool: pronTpls, etymTpls, tplDefs, jederDefs. */
	function localTplDesc(name) {
		var pools = [steps.pron.pronTpls, steps.etym.etymTpls, steps.dfn.tplDefs, steps.dfn.jederDefs];
		var found = &quot;&quot;;
		$.each(pools, function (_, pool) {
			if (pool &amp;&amp; pool[name] &amp;&amp; pool[name].desc) { found = pool[name].desc; return false; }
		});
		return found;
	}

	// Under the ⓘ it was opened from, kept inside the viewport, and flipped above it when there is no
	// room below. Narrow screens get the width they have rather than a fixed card off the edge.
	//
	// box is where that ⓘ was when it was clicked. The row it sits in is closed by then, so it can no
	// longer be measured; the last known box is kept for the re-placements after the text arrives.
	function positionTplInfo(panel, anchor, box) {
		var el = $(anchor).get(0);
		var rect = box || (el &amp;&amp; el.getBoundingClientRect ? el.getBoundingClientRect() : null);
		if (rect &amp;&amp; !rect.width &amp;&amp; !rect.height) {
			rect = null;
		}
		if (rect) {
			panel.data(&quot;wiktkuAnchorBox&quot;, rect);
		} else {
			rect = panel.data(&quot;wiktkuAnchorBox&quot;) || null;
		}
		var margin = 8;
		var arrow = 8;
		var width = Math.min(360, $(window).width() - margin * 2);
		panel.css({ width: width + &quot;px&quot;, top: &quot;0px&quot;, left: &quot;0px&quot; });
		var height = panel.outerHeight();
		// Above the dropdown, pointing down at it, the way MediaWiki's own filter tips sit; below it only
		// when there is no room above.
		var above = !rect || rect.top - height - arrow &gt;= margin;
		var top = !rect ? margin : (above ? rect.top - height - arrow : rect.bottom + arrow);
		var left = rect ? Math.min(Math.max(margin, rect.left), $(window).width() - width - margin) : margin;
		// The arrow points at the start of the box it explains, kept clear of the tip's corners.
		var arrowX = rect ? Math.min(Math.max(16, rect.left + 24 - left), width - 16) : 16;
		panel.toggleClass(&quot;wiktku-tpl-info-above&quot;, above).toggleClass(&quot;wiktku-tpl-info-below&quot;, !above);
		panel.css({ top: top + &quot;px&quot;, left: left + &quot;px&quot; });
		panel.get(0).style.setProperty(&quot;--wiktku-arrow-x&quot;, arrowX + &quot;px&quot;);
	}

	/** Opens the explanation for `name` as a tip above the dropdown it was asked from. */
	function showTemplateInfo(name, anchorWrap, anchorEl, anchorBox) {
		$(&quot;.wiktku-tpl-info&quot;).remove();

		var panel = $(&quot;&lt;div class='wiktku-tpl-info'&gt;&lt;/div&gt;&quot;);
		panel.append($(&quot;&lt;div class='wiktku-tpl-info-name'&gt;&lt;/div&gt;&quot;).text(&quot;{{&quot; + name + &quot;}}&quot;));
		var body = $(&quot;&lt;div class='wiktku-tpl-info-desc'&gt;&lt;/div&gt;&quot;).text(wiktkuUtil.msg.loading);
		panel.append(body);
		var params = $(&quot;&lt;div class='wiktku-tpl-info-params'&gt;&lt;/div&gt;&quot;);
		panel.append(params);
		panel.append($(&quot;&lt;a class='wiktku-tpl-info-link' target='_blank' rel='noopener'&gt;&lt;/a&gt;&quot;)
			.attr(&quot;href&quot;, wiktkuUtil.tplPageUrl(name))
			.text(wiktkuUtil.msg.openTemplatePage + &quot; →&quot;));
		function closePanel() {
			panel.remove();
			$(document).off(&quot;.wiktkuTplInfo&quot;);
			$(window).off(&quot;.wiktkuTplInfo&quot;);
		}
		var close = $(&quot;&lt;button type='button' class='wiktku-tpl-info-close' title='Bigire'&gt;✕&lt;/button&gt;&quot;);
		close.on(&quot;click&quot;, closePanel);
		panel.prepend(close);
		$(document).on(&quot;keydown.wiktkuTplInfo&quot;, function (e) {
			if (e.which === 27) {
				closePanel();
			}
		});
		$(document).on(&quot;mousedown.wiktkuTplInfo&quot;, function (e) {
			if (!$(e.target).closest(&quot;.wiktku-tpl-info&quot;).length) {
				closePanel();
			}
		});
		// A panel that stayed put while the page moved under it would point at nothing.
		$(window).on(&quot;resize.wiktkuTplInfo scroll.wiktkuTplInfo&quot;, function () {
			positionTplInfo(panel, anchorWrap);
		});

		// Over the form, not inside it: as a block in the flow it pushed every field below it down the
		// page for as long as it was open, and the picker it explains moved with them.
		$(document.body).append(panel);
		positionTplInfo(panel, anchorWrap);

		fetchTemplateData(name).then(function (td) {
			var desc = (td &amp;&amp; td.desc) || localTplDesc(name);
			body.text(desc || &quot;Ji bo vê şablonê îzahek nehatiye nivîsandin.&quot;);
			if (td &amp;&amp; td.params &amp;&amp; td.params.length) {
				params.append($(&quot;&lt;div class='wiktku-tpl-info-params-title'&gt;&lt;/div&gt;&quot;).text(&quot;Parametre:&quot;));
				var listEl = $(&quot;&lt;ul&gt;&lt;/ul&gt;&quot;);
				$.each(td.params, function (_, p) {
					var line = p.key + (p.label ? &quot; — &quot; + p.label : &quot;&quot;) + (p.required ? &quot; (mecbûrî)&quot; : &quot;&quot;);
					listEl.append($(&quot;&lt;li&gt;&lt;/li&gt;&quot;).text(line));
				});
				params.append(listEl);
			}
			// The panel is as tall as its text, which only arrives now.
			positionTplInfo(panel, anchorWrap);
		});
	}

	/** Marks a picker's &lt;option&gt;s as template rows so the searchable widget
	 *  renders them with the dot / 🔗 / ⓘ affordances, and wires the ⓘ
	 *  handler for that picker. `nameOf` maps an &lt;option&gt; to a template
	 *  name — the pickers store different things in value= (a snippet for
	 *  the insert dropdowns, the bare name for the sense selector). */
	function markTemplateOptions(sel, nameOf) {
		if (!sel || !sel.length) return;
		var names = [];
		sel.find(&quot;option&quot;).each(function () {
			var opt = $(this);
			var name = nameOf(opt);
			if (!name) return;
			opt.attr(&quot;data-tpl&quot;, name);
			// Deprecated/typo templates are the &quot;special cases only&quot; ones.
			opt.attr(&quot;data-tpl-status&quot;, /kevnbûyî|şaşnivîs|kêmpeyda/i.test(opt.text()) ? &quot;yellow&quot; : &quot;green&quot;);
			names.push(name);
		});
		sel.data(&quot;wiktkuTplInfo&quot;, showTemplateInfo);

		// Fill in the descriptions. Matters most for the Mane picker, whose
		// entries in data-main.json are names with no desc at all — &quot;rastnivîs&quot;,
		// &quot;ku-Latn&quot;, &quot;guharto&quot; on their own. One request covers every
		// template in the picker, cached for the per-row ⓘ as well.
		prefetchTemplateData(names).always(function () {
			applyTplDescriptions(sel);
		});
	}

	/** Pulls the template name out of a snippet like &quot;* {{ku-IPA}}&quot; or
	 *  &quot;{{ji|SOURCELANG|CODE|…}}&quot;. */
	function tplNameFromSnippet(snippet) {
		var m = /\{\{\s*([^|}\n]+)/.exec(snippet || &quot;&quot;);
		return m ? $.trim(m[1]) : &quot;&quot;;
	}

	// True if a sense has content beyond mane worth keeping (etîket, word
	// lists, nimûne, jêder) — so it's still emitted with {{mane?}} if empty.
	function senseHasExtraContent(s) {
		if (s.maneid) return true;
		if (s.etiket &amp;&amp; $.grep(s.etiket, function (e) { return $.trim(e) !== &quot;&quot;; }).length) return true;
		if (s.kategori &amp;&amp; $.grep(s.kategori, function (k) { return $.trim(k) !== &quot;&quot;; }).length) return true;
		var anyWords = false;
		$.each(wordGroups(), function (_, g) {
			if ((s[g.field] || []).length) anyWords = true;
		});
		if (anyWords || (s.dever &amp;&amp; s.dever.length)) return true;
		if (s.nimune &amp;&amp; $.grep(s.nimune, function (n) {
			return (typeof n === &quot;object&quot; ? n.text : n) !== &quot;&quot;;
		}).length &gt; 0) return true;
		if (senseHasJeder(s)) return true;
		return false;
	}

	// A technically-&quot;complete&quot; entry (Ziman + Cureyê rêzimanî filled) with
	// nothing in Mane, Bi zaravayên din or Werger is still meaningfully
	// empty, so this is checked separately at submit-click time with its
	// own message.

	// Line breaks in a field save as &quot;&lt;br&gt;&quot;; this marks them so that is visible while typing.
	var highlightLinebreak = wiktkuUtil.makeLinebreakHighlighter({ prefix: &quot;wiktku&quot; });

	// Each nimûne item can be { text, tr, t }: text, transliteration, translation.
	function formatNimune(nimunes, lang) {
		var hasNimune = nimunes &amp;&amp; $.grep(nimunes, function (n) {
			return (typeof n === &quot;object&quot; ? n.text : n) !== &quot;&quot;;
		}).length &gt; 0;

		if (!hasNimune) {
			// A sense with no example is left as it is, with no &quot;{{nimûne?}}&quot; placeholder.
			return &quot;&quot;;
		}

		return $.map(nimunes, function (n) {
			var text = typeof n === &quot;object&quot; ? n.text : n;
			if (!text) return undefined;
			// The builder DefSideBoxes and add-examples use: the translation in slot 3, rêz=1 for a short pair.
			return &quot;\n&quot; + wiktkuCite.buildCitation({
				mode: &quot;plain&quot;,
				marker: &quot;#:&quot;,
				language: lang,
				title: pageName,
				quote: text,
				translation: typeof n === &quot;object&quot; ? n.t : &quot;&quot;,
				transcription: typeof n === &quot;object&quot; ? n.tr : &quot;&quot;
			});
		}).join(&quot;&quot;);
	}

	// Formats jêder (citation) entries into &quot;#* {{jêder…|…}}&quot; lines; skips
	// entries with no quote text. Falls back to the generic {{jêder}}
	// template when no specific template was chosen.
	function formatJeder(jederList, lang) {
		if (!jederList || !jederList.length) return &quot;&quot;;
		return $.map(jederList, function (jeder) {
			if (!jeder || !jeder.quote) return undefined;

			var mode = jeder.raw ? &quot;raw&quot;
				: jeder.jederTpl ? &quot;jeder&quot;
				: jeder.jederCatTpl ? &quot;category&quot;
				: &quot;plain&quot;;
			return &quot;\n&quot; + wiktkuCite.buildCitation({
				mode: mode,
				marker: &quot;#*&quot;,
				language: lang,
				template: jeder.jederTpl || jeder.jederCatTpl,
				fields: jeder.jederTpl ? (jeder.jêderFields || {}) : (jeder.jederCatFields || {}),
				langParamKey: jeder.jederCatLangParam,
				quote: jeder.quote,
				transcription: jeder.quoteTr,
				translation: jeder.quoteT,
				source: jeder.jederManual || (mode === &quot;plain&quot; &amp;&amp; !jeder.url ? &quot;çavkanî?&quot; : &quot;&quot;),
				sourceURL: jeder.url
			});
		}).join(&quot;&quot;);
	}

	// True if a sense has at least one jêder entry with quote text.
	function senseHasJeder(sense) {
		return !!(sense.jeder &amp;&amp; $.grep(sense.jeder, function (j) {
			return j &amp;&amp; j.quote;
		}).length &gt; 0);
	}

	// Builds &quot;{{tplName|lang|part1|part2|…}}&quot; from a sense field (kategori,
	// etiket), wrapped inline (&quot; {{…}} &quot;) or on its own line (&quot;\n#: {{…}}&quot;).
	function buildSenseTpl(sense, field, lang, tplName) {
		if (!sense[field] || !sense[field].length) return &quot;&quot;;
		var parts = sense[field].map(function (p) { return $.trim(p); })
			.filter(function (p) { return p !== &quot;&quot;; });
		if (!parts.length) return &quot;&quot;;
		var call = &quot;{{&quot; + tplName + &quot;|&quot; + lang + &quot;|&quot; + parts.join(&quot;|&quot;) + &quot;}}&quot;;
		return call
	}

	// Dever/Şîwe values only ever get their own {{dever|…}} call for ku —
	// no |lang| param, since the template is Kurdish-dialect-specific. For
	// every other language there's no dever template at all; see
	// buildEtiketTpl() below, which folds them into {{e|}} instead.
	function buildDeverTpl(sense, lang) {
		if (lang !== &quot;ku&quot; || !sense.dever || !sense.dever.length) return &quot;&quot;;
		var parts = sense.dever.map(function (p) { return $.trim(p); })
			.filter(function (p) { return p !== &quot;&quot;; });
		if (!parts.length) return &quot;&quot;;
		return &quot;{{dever|&quot; + parts.join(&quot;|&quot;) + &quot;}}&quot;;
	}

	// Builds the {{e|lang|…}} etîket call. For non-ku senses, Dever/Şîwe
	// values are appended after the regular etîket values instead of going
	// into their own {{dever|}} call (see buildDeverTpl() above).
	function buildEtiketTpl(sense, lang) {
		var etiket = (sense.etiket || []).slice();
		if (lang !== &quot;ku&quot; &amp;&amp; sense.dever &amp;&amp; sense.dever.length) {
			etiket = etiket.concat(sense.dever);
		}
		return buildSenseTpl({ etiket: etiket }, &quot;etiket&quot;, lang, &quot;e&quot;);
	}

	/**
	 * Assembles the nimûne + jêder wikitext block for a sense. Shared by
	 * both the template-sense and normal-mane-sense branches below.
	 */
	function buildCite(sense, lang) {
		return formatNimune(sense.nimune, lang) +
			formatJeder(sense.jeder, lang);
	}

	// ── Inline modifier system ───────────────────────────────────────────────
	// &quot;{{maneid|lang|x}}&quot;, the anchor id a sense can be linked by. First of the leading calls, which is
	// data-main.json's leadingTplOrder.
	function buildManeidTpl(sense, lang) {
		var id = $.trim(sense.maneid || &quot;&quot;);
		return id ? &quot;{{maneid|&quot; + lang + &quot;|&quot; + id + &quot;}}&quot; : &quot;&quot;;
	}

	// Quick-pick suggestions for the Dever/Şîwe, Etîket and Kategorî chip pickers on each sense, taken
	// from [[Modul:labels]] rather than kept by hand here. Free text is still always accepted; this only
	// saves typing, and keeps the lists honest as the module changes.
	//
	// Fetched on the first time one of the three panels is opened, never on load: the wizard opens on
	// pages that never touch these fields. Once it lands, the open panel re-renders itself.
	var wiktkuLabelSets = null;
	var wiktkuLabelsPending = null;
	var wiktkuLabelListeners = [];

	function wiktkuEnsureLabels() {
		if (wiktkuLabelSets || wiktkuLabelsPending) return;
		wiktkuLabelsPending = wiktkuEdit.labels.load().then(function (sets) {
			wiktkuLabelSets = sets;
			wiktkuLabelsPending = null;
			$.each(wiktkuLabelListeners, function (_, fn) { fn(); });
		}, function () {
			wiktkuLabelsPending = null;
		});
	}

	// Which list each picker shows. Dever/Şîwe is the regions of the language being edited; Etîket adds
	// the qualifiers and subject labels on top; Kategorî is the subject labels alone.
	function wiktkuLabelSuggestions(which) {
		if (!wiktkuLabelSets) return [];
		var lang = (getValues().lang || &quot;ku&quot;);
		if (which === &quot;dever&quot;)  return wiktkuEdit.labels.regionalFor(wiktkuLabelSets, lang);
		if (which === &quot;etiket&quot;) return wiktkuEdit.labels.etiketFor(wiktkuLabelSets, lang);
		return wiktkuEdit.labels.kategoriNames(wiktkuLabelSets);
	}

	// Lower-cased alias -&gt; canonical label, so typing a name the module lists as an alias still finds it.
	// Built once per label load rather than per keystroke.
	var wiktkuAliasCache = null;
	function wiktkuLabelAliases() {
		if (!wiktkuLabelSets) return {};
		if (!wiktkuAliasCache) {
			wiktkuAliasCache = wiktkuEdit.labels.aliasIndex(wiktkuLabelSets);
		}
		return wiktkuAliasCache;
	}

	// Appends a ⊕ button to a word input &lt;li&gt;. Clicking it shows a compact
	// modifier picker; selecting one prompts for the value and appends
	// &lt;modifier:value&gt; to the textarea's current content.

	// Sub-groups (inside a sense/definition block) that get the same ⊕
	// modifier button as makeWordListStep fields.
	/**
	 * The word lists (Hevmane, Dijmane, Formên alternatîv, Termên koordîne, Jornav, Jêrnav), taken from
	 * data-main.json's senseGroups so the wizard, DefSideBoxes and the wikitext writer all name them once.
	 * That array's own order is the order the &quot;#:&quot; lines are written to the page in; &quot;order&quot; is the
	 * order they are shown in, which is not the same. cls is how each one's box is found in the DOM.
	 */
	function wordGroups() {
		return SENSE_GROUPS.slice().sort(function (a, b) {
			return (a.order || 0) - (b.order || 0);
		}).map(function (g) {
			return { cls: &quot;wiktku-dfn-&quot; + g.field, label: g.label, field: g.field, izah: g.hint || &quot;&quot; };
		});
	}

	/** True for the six word lists, which get the ⊕-modifier row; Nimûne and Jêgirtin do not. */
	function isWordGroupCls(cls) {
		var found = false;
		$.each(SENSE_GROUPS, function (_, g) {
			if (&quot;wiktku-dfn-&quot; + g.field === cls) found = true;
		});
		return found;
	}

	/**
	 * Wraps a textarea in a &lt;li&gt; with a ⊕ modifier button and returns the &lt;li&gt;.
	 *
	 * `ta` stays hidden and holds the raw &quot;word&lt;key:value&gt;…&quot; text every reader and writer expects. What
	 * is typed into is a plain word box, with one pill per modifier above it; clicking a pill edits its
	 * value, ⊕ adds another.
	 */
	function makeModifierLi(ta) {
		var narrow = (ta.attr(&quot;class&quot;) || &quot;&quot;).split(/\s+/).indexOf(&quot;wiktku-start-narrow&quot;) !== -1;
		// Not ta's own classes: code elsewhere counts elements by those, so a second matching textarea
		// would skew the counts. wiktku-word-input carries the same look.
		var wordInput = $(&quot;&lt;textarea&gt;&lt;/textarea&gt;&quot;)
			.attr(&quot;rows&quot;, ta.attr(&quot;rows&quot;) || 1)
			.addClass(&quot;wiktku-word-input&quot; + (narrow ? &quot; wiktku-start-narrow&quot; : &quot;&quot;))
			.attr(&quot;placeholder&quot;, ta.attr(&quot;placeholder&quot;) || &quot;&quot;);
		ta.hide();
		// Placeholders on the (hidden) canonical field are set by shared code that has no reason to know
		// wordInput exists -- mirror them instead of touching every call site.
		if (window.MutationObserver) {
			new MutationObserver(function () {
				wordInput.attr(&quot;placeholder&quot;, ta.attr(&quot;placeholder&quot;) || &quot;&quot;);
			}).observe(ta[0], { attributes: true, attributeFilter: [&quot;placeholder&quot;] });
		}

		// ta stays the source of truth: the row writes back to it, and the caller's growth listener is
		// bound to ta's &quot;input&quot; event.
		var row = wiktkuUtil.makeModifierRow({
			prefix: &quot;wiktku-&quot;,
			wordInput: wordInput,
			modTitle: &quot;Modifiyerê lê zêde bike&quot;,
			removeTitle: wiktkuUtil.msg.removeWord,
			removeModTitle: wiktkuUtil.msg.removeModifier,
			onChange: function (raw) {
				if (raw === null) return; // the row removed itself; ta goes with it
				ta.val(raw);
				ta.trigger(&quot;input&quot;);
			},
			// &quot;bixe qutiyan&quot; puts each comma-separated word in a row of its own. The list grows off the
			// hidden field's own &quot;input&quot; event, so filling the trailing row is what makes the next one
			// appear; the caret ends up in the empty row at the bottom. One word per row is also one
			// word per template parameter, which both {{hevmane}} and {{kol3}} read the same way -- a
			// comma left inside a parameter would not be.
			onSplit: function (rest) {
				// A tick later, not now: the row writes its own value to the hidden field after this
				// call returns, and it is that field's &quot;input&quot; that grows the list -- so the empty row
				// to put the next word in does not exist yet.
				setTimeout(function () {
					var $list = row.$li.closest(&quot;ol, ul&quot;);
					rest.forEach(function (raw) {
						if (!raw) return;
						var setRaw = $list.children(&quot;li&quot;).last().data(&quot;setRawValue&quot;);
						if (setRaw) setRaw(raw);
					});
					$list.children(&quot;li&quot;).last().find(&quot;.wiktku-word-input&quot;).focus();
				}, 0);
			}
		});
		row.setRaw(ta.val());

		var li = row.$li;
		// restoreSubList's &quot;fill an existing row&quot; path sets a raw &quot;word&lt;key:value&gt;&quot; value here.
		li.data(&quot;setRawValue&quot;, function (raw) {
			row.setRaw(raw);
			ta.val(row.getRaw());
			ta.trigger(&quot;input&quot;);
		});
		li.prepend(ta);
		return li;
	}

	/**
	 * A &quot;chip + toggle&quot; field: values render as removable chips, and a &quot;+ &lt;label&gt;&quot; toggle opens a panel
	 * with quick-pick pills plus free text. panel is returned apart from wrap so callers can group all
	 * toggles in one row and all panels below, keeping toggles from shifting when one opens.
	 *
	 * Pills carry a × as well: hiding a built-in one, or typing a new value, is remembered per wrapCls
	 * in mw.storage.
	 *
	 * opts: { wrapCls, toggleLabel, hint, suggestions (array or function), placeholder, onOpen }
	 * Returns { wrap, panel, addChip, values, setOpenDefault, close }.
	 */
	var WIKTKU_SUGGESTIONS_KEY_PREFIX = &quot;wiktku_suggestions_&quot;;

	function loadSuggestionOverrides(wrapCls) {
		if (!(window.mw &amp;&amp; mw.storage)) return { removed: [], added: [] };
		var raw;
		try { raw = mw.storage.get(WIKTKU_SUGGESTIONS_KEY_PREFIX + wrapCls); } catch (e) { raw = null; }
		var parsed = {};
		if (raw) { try { parsed = JSON.parse(raw); } catch (e) { parsed = {}; } }
		return { removed: parsed.removed || [], added: parsed.added || [] };
	}

	function saveSuggestionOverrides(wrapCls, overrides) {
		if (!(window.mw &amp;&amp; mw.storage)) return;
		try { mw.storage.set(WIKTKU_SUGGESTIONS_KEY_PREFIX + wrapCls, JSON.stringify(overrides)); } catch (e) { /* storage unavailable — override just won't persist */ }
	}

	// One document listener for every sense's &quot;Hevmane û Bêhtir&quot; menu, not one per sense: a long entry can hold a
	// dozen senses and each would otherwise bind its own.
	var moreMenuCloserBound = false;
	function bindMoreMenuCloser() {
		if (moreMenuCloserBound) return;
		moreMenuCloserBound = true;
		$(document).on(&quot;click.wiktkuMore&quot;, function (e) {
			if ($(e.target).closest(&quot;.wiktku-dfn-more-wrap&quot;).length) return;
			$(&quot;.wiktku-dfn-more-menu&quot;).hide();
			$(&quot;.wiktku-dfn-more-arrow&quot;).html(&quot;&amp;#9656;&quot;);
		});
	}

	function buildChipField(opts) {
		var wrap = $(&quot;&lt;div&gt;&lt;/div&gt;&quot;).addClass(&quot;wiktku-dfn-chipfield-wrap &quot; + opts.wrapCls + &quot;-wrap&quot;);
		var chipsRow = $(&quot;&lt;span class='wiktku-dfn-chipfield-chips'&gt;&lt;/span&gt;&quot;);
		var toggle = $(&quot;&lt;button type='button' class='wiktku-dfn-chipfield-toggle'&gt;&lt;/button&gt;&quot;).text(opts.toggleLabel);
		var panel = $(&quot;&lt;div class='wiktku-dfn-chipfield-panel'&gt;&lt;/div&gt;&quot;).hide();
		var suggestRow = $(&quot;&lt;div class='wiktku-dfn-chipfield-suggest'&gt;&lt;/div&gt;&quot;);
		var input = $(&quot;&lt;input type='text' class='wiktku-dfn-chipfield-input'&gt;&quot;)
			.attr(&quot;placeholder&quot;, opts.placeholder || ((opts.suggestions &amp;&amp; opts.suggestions.length) ? &quot;An ya nû binivîse…&quot; : &quot;Binivîse…&quot;));
		var addBtn = $(&quot;&lt;button type='button' class='wiktku-dfn-chipfield-add'&gt;Qeyd bike&lt;/button&gt;&quot;);
		// Once the person opens/closes the panel themselves, lang-driven
		// syncing (see setOpenDefault) backs off rather than fighting them.
		var userToggled = false;

		// The pick list shown is opts.suggestions with the person's own
		// edits layered on top — see loadSuggestionOverrides above.
		var overrides = loadSuggestionOverrides(opts.wrapCls);
		var removedSuggestions = overrides.removed;
		var addedSuggestions = overrides.added;
		function persistOverrides() {
			saveSuggestionOverrides(opts.wrapCls, { removed: removedSuggestions, added: addedSuggestions });
		}
		// opts.suggestions is either a fixed array or a function returning one -- the label-driven
		// pickers depend on the language being edited, and on data that arrives from Modul:labels after
		// the field is built, so they cannot be a snapshot taken here.
		function baseSuggestions() {
			var list = typeof opts.suggestions === &quot;function&quot; ? opts.suggestions() : opts.suggestions;
			return list || [];
		}
		function allSuggestions() {
			return $.grep(baseSuggestions(), function (s) { return removedSuggestions.indexOf(s) === -1; })
				.concat(addedSuggestions);
		}
		function learnSuggestion(val) {
			if (!val || allSuggestions().indexOf(val) !== -1) return;
			addedSuggestions.push(val);
			persistOverrides();
		}
		function forgetSuggestion(name) {
			var idx = addedSuggestions.indexOf(name);
			if (idx !== -1) addedSuggestions.splice(idx, 1);
			else if (removedSuggestions.indexOf(name) === -1) removedSuggestions.push(name);
			persistOverrides();
			renderSuggest();
			// renderSuggest() just destroyed the pill's × button the click
			// came from — which was focused — dropping focus outside the
			// panel entirely. Left alone, that reads as &quot;focus left the
			// widget&quot; to the focusout handler below and closes the whole
			// panel. Move focus back inside before that check runs.
			input.focus();
		}

		function values() {
			var vals = [];
			chipsRow.find(&quot;.wiktku-dfn-chipfield-chip&quot;).each(function () {
				vals.push($(this).attr(&quot;data-value&quot;));
			});
			return vals;
		}

		// Label-driven pickers are built before Modul:labels has been read, so re-render once it lands.
		if (typeof opts.suggestions === &quot;function&quot;) {
			wiktkuLabelListeners.push(function () {
				if (panel.is(&quot;:visible&quot;)) renderSuggest();
			});
		}

		// At most this many pills at once. Modul:labels offers 87 regions, 362 etîket and 209 kategorî;
		// drawing them all was a wall of pills nobody reads and the field it belonged to scrolled away.
		var MAX_PILLS = 24;

		// What shows with an empty box: the short hand-picked list if the caller gave one, otherwise the
		// full set (capped) as before, for pickers whose lists are small enough to browse.
		function restingSuggestions() {
			var quick = typeof opts.quickPicks === &quot;function&quot; ? opts.quickPicks() : opts.quickPicks;
			if (!quick || !quick.length) {
				return allSuggestions();
			}
			// A value the person added themselves outranks the hand-picked list -- it is theirs.
			return quick.concat($.grep(addedSuggestions, function (s) { return quick.indexOf(s) === -1; }));
		}

		// Typed text searches the WHOLE set, not just the pills on screen, and matches the module's own
		// aliases too, so &quot;Behdînanî&quot; finds Badînî and &quot;USA&quot; finds DYA.
		function matching(query) {
			var q = $.trim(query).toLowerCase();
			if (!q) {
				return restingSuggestions();
			}
			var aliases = wiktkuLabelAliases();
			var hits = $.grep(allSuggestions(), function (name) {
				return name.toLowerCase().indexOf(q) !== -1;
			});
			$.each(aliases, function (alias, canonical) {
				if (alias.indexOf(q) !== -1 &amp;&amp; hits.indexOf(canonical) === -1 &amp;&amp;
					allSuggestions().indexOf(canonical) !== -1) {
					hits.push(canonical);
				}
			});
			return hits;
		}

		function renderSuggest(query) {
			var taken = values();
			suggestRow.empty();
			var shown = 0;
			$.each(matching(query || &quot;&quot;), function (_, name) {
				if (taken.indexOf(name) !== -1 || shown &gt;= MAX_PILLS) return;
				shown++;
				var pill = $(&quot;&lt;span role='button' class='wiktku-dfn-chipfield-pill'&gt;&lt;/span&gt;&quot;).text(name);
				pill.on(&quot;click&quot;, function () { addChip(name); input.val(&quot;&quot;); renderSuggest(&quot;&quot;); input.focus(); });
				var pillRemove = $(&quot;&lt;button type='button' class='wiktku-dfn-chipfield-pill-remove' title='Vê tewsiyeyê veşêre'&gt;×&lt;/button&gt;&quot;);
				pillRemove.on(&quot;click&quot;, function (e) {
					e.stopPropagation(); // don't also trigger the pill's own add-chip click
					forgetSuggestion(name);
				});
				pill.append(pillRemove);
				suggestRow.append(pill);
			});
			suggestRow.toggle(!!suggestRow.children().length);
		}

		function addChip(val) {
			val = $.trim(val || &quot;&quot;);
			if (!val || values().indexOf(val) !== -1) return;
			var chip = $(&quot;&lt;span class='wiktku-dfn-chipfield-chip'&gt;&lt;/span&gt;&quot;).attr(&quot;data-value&quot;, val).text(val);
			var remove = $(&quot;&lt;button type='button' class='wiktku-dfn-chipfield-remove' title='Jê bibe'&gt;×&lt;/button&gt;&quot;);
			// Same focus-loss hazard as forgetSuggestion() below — refocus
			// the input so removing a chip while the panel is open doesn't
			// also close the panel.
			remove.on(&quot;click&quot;, function () { chip.remove(); renderSuggest(); input.focus(); });
			chip.append(remove);
			chip.insertBefore(toggle); // chips in insertion order, toggle stays last
			renderSuggest();
		}

		toggle.on(&quot;click&quot;, function () {
			userToggled = true;
			if (panel.is(&quot;:visible&quot;)) { panel.hide(); return; }
			if (opts.onOpen) opts.onOpen();
			renderSuggest();
			panel.show();
			input.focus();
		});

		// Anything typed and committed by hand joins the pick list too, not
		// just the current sense's chips.
		function commitInput() {
			var val = $.trim(input.val() || &quot;&quot;);
			if (val) {
				addChip(val);
				learnSuggestion(val);
			}
			input.val(&quot;&quot;).focus();
		}
		addBtn.on(&quot;click&quot;, commitInput);
		input.on(&quot;keydown&quot;, function (e) {
			if (e.which === 13) { e.preventDefault(); commitInput(); }
		});
		// Typing searches the whole list, so a value that is not among the pills is still one keystroke
		// from being found rather than something you have to know by heart and type out in full.
		input.on(&quot;input&quot;, function () {
			renderSuggest(input.val());
		});

		// Close the panel once focus leaves toggle+panel together — they're
		// siblings in the DOM (not nested), so both must be checked.
		function focusStillInside() {
			return $.contains(wrap[0], document.activeElement) || $.contains(panel[0], document.activeElement);
		}
		wrap.add(panel).on(&quot;focusout&quot;, function () {
			setTimeout(function () {
				if (!focusStillInside()) panel.hide();
			}, 150);
		});

		if (opts.hint) panel.append($(&quot;&lt;div class='wiktku-dfn-chipfield-hint'&gt;&lt;/div&gt;&quot;).text(opts.hint));
		// Box first, pills under it. The other way round, every keystroke re-filtered the pills above the
		// box and the box itself jumped up and down the page as the list grew and shrank.
		panel.append(
			$(&quot;&lt;div class='wiktku-dfn-chipfield-input-row'&gt;&lt;/div&gt;&quot;).append(input).append(addBtn)
		).append(suggestRow);
		chipsRow.append(toggle);
		wrap.append(chipsRow);

		return {
			wrap: wrap,
			panel: panel,
			addChip: addChip,
			values: values,
			/** Sets the panel's default open/closed state — a no-op once
			 *  the person has manually toggled it themselves this session. */
			setOpenDefault: function (open) {
				if (userToggled) return;
				// Same as the toggle click handler: (re)build the suggestion
				// pills whenever the panel opens, not just on a manual click —
				// otherwise a panel opened by this default-state sync (e.g.
				// Dever/Şîwe starting open for ku) shows an empty pill row
				// until the person closes and reopens it themselves.
				if (open) {
					if (opts.onOpen) opts.onOpen();
					renderSuggest();
				}
				panel.toggle(!!open);
			},
			/** Force-closes the panel as though the person had done it
			 *  themselves, so a later setOpenDefault() doesn't reopen it out
			 *  from under them — used by onOpen to keep only one of these
			 *  fields' panels open at a time (see the call site). */
			close: function () {
				userToggled = true;
				panel.hide();
			},
			/** Opens the panel from somewhere other than the toggle — the
			 *  &quot;Hevmane û Bêhtir&quot; menu, which is where Etîket and Kategorî are asked
			 *  for now. Counts as a manual toggle for the same reason close()
			 *  does. */
			open: function () {
				userToggled = true;
				if (opts.onOpen) opts.onOpen();
				renderSuggest();
				panel.show();
				input.focus();
			}
		};
	}

	/**
	 * One page-level word list (Formên alternatîv, Hevmane, … Herwiha binêre): a &quot;====&quot; section holding
	 * the words for the whole entry rather than for one sense.
	 *
	 * Only the question is passed in. The heading and the step's own name come from data-sections.json's
	 * pageSubsections, filled in below once the data lands — the same table DefSideBoxes reads to find
	 * these sections, so the wizard cannot write a heading the panels then fail to recognise.
	 */
	function makeWordListStep(id, question_fmt) {
		return {
			id: id,
			name: id,
			question_fmt: question_fmt,
			multiple: true,
			narrow: true,
			modifiers: true,
			// Function instead of a plain string so it can name the current
			// language — computed fresh at build time and re-applied by
			// refresh() whenever the language changes.
			placeholder: function () {
				var lang = getValues().lang || &quot;&quot;;
				var langLabel = lang ? getLangLabel(lang) : &quot;&quot;;
				return &quot;Kelîme&quot; + (langLabel ? &quot; bi &quot; + langLabel : &quot;&quot;) + &quot;…&quot;;
			},
			visible: function (values) {
				return values.lang &amp;&amp; values.pos;
			},
			output: function (values) {
				var words = $.grep(values[id] || [], function (w) { return !!w; });
				if (!words.length) return &quot;&quot;;
				var header = steps[id].header || capitalize(steps[id].name);

				var lang = values.lang;
				var section = &quot;\n==== &quot; + header + &quot; ====\n&quot;;
				var params = &quot;cure=&quot; + header + &quot;\n&quot; +
					$.map(words, function (w) {
						return &quot;|&quot; + w;
					}).join(&quot;\n&quot;);
				return section +
					&quot;{{&quot; + WORDLIST_TEMPLATE + &quot;|&quot; + lang + &quot;|&quot; + params + &quot;\n}}\n&quot;;
			} };
	}

	// The helpers and settings the step definitions use, for wikt.start-wizard-steps. DEVER_QUICK_PICKS,
	// SENSE_GROUPS, catSrcTemplates, pageName and wiktkuLabelSets change after loading, so they are passed as
	// getters and setters on this same closure rather than as copies.
	function wizardContext() {
		var ctx = {
			GENDER_BASE_LABELS: GENDER_BASE_LABELS,
			ZARAVA_LANG_CODES: ZARAVA_LANG_CODES,
			addLangMode: addLangMode,
			applyTplDescriptions: applyTplDescriptions,
			bindMoreMenuCloser: bindMoreMenuCloser,
			buildChipField: buildChipField,
			buildCite: buildCite,
			buildDeverTpl: buildDeverTpl,
			buildEtiketTpl: buildEtiketTpl,
			buildManeidTpl: buildManeidTpl,
			buildSenseTpl: buildSenseTpl,
			capitalize: capitalize,
			decapitalize: decapitalize,
			fetchCatSrcTemplates: fetchCatSrcTemplates,
			findLangHeader: findLangHeader,
			getLangLabel: getLangLabel,
			getValues: getValues,
			highlightLinebreak: highlightLinebreak,
			initSelects: initSelects,
			insertAtCursor: insertAtCursor,
			insertLineSnippet: insertLineSnippet,
			isReconstruction: isReconstruction,
			isWordGroupCls: isWordGroupCls,
			langHasMultipleScripts: langHasMultipleScripts,
			langsByCode: langsByCode,
			makeModifierLi: makeModifierLi,
			makeTrashButton: makeTrashButton,
			makeWordListStep: makeWordListStep,
			manePlaceholder: manePlaceholder,
			markTemplateOptions: markTemplateOptions,
			needsTransliteration: needsTransliteration,
			nimuneTranslationPrompt: nimuneTranslationPrompt,
			populateMenus: populateMenus,
			refresh: refresh,
			senseHasExtraContent: senseHasExtraContent,
			splitTercimeIzah: splitTercimeIzah,
			stripWikilinks: stripWikilinks,
			tplNameFromSnippet: tplNameFromSnippet,
			wiktkuCite: wiktkuCite,
			wiktkuEdit: wiktkuEdit,
			wiktkuEnsureLabels: wiktkuEnsureLabels,
			wiktkuLabelListeners: wiktkuLabelListeners,
			wiktkuLabelSuggestions: wiktkuLabelSuggestions,
			wiktkuPosparams: wiktkuPosparams,
			wiktkuUtil: wiktkuUtil,
			wiktkuWikitext: wiktkuWikitext,
			wordGroups: wordGroups
		};
		Object.defineProperties(ctx, {
			DEVER_QUICK_PICKS: { get: function () { return DEVER_QUICK_PICKS; }, set: function (value) { DEVER_QUICK_PICKS = value; } },
			SENSE_GROUPS: { get: function () { return SENSE_GROUPS; }, set: function (value) { SENSE_GROUPS = value; } },
			catSrcTemplates: { get: function () { return catSrcTemplates; }, set: function (value) { catSrcTemplates = value; } },
			pageName: { get: function () { return pageName; }, set: function (value) { pageName = value; } },
			wiktkuLabelSets: { get: function () { return wiktkuLabelSets; }, set: function (value) { wiktkuLabelSets = value; } }
		});
		return ctx;
	}

	// What each step asks, offers and writes: [[MediaWiki:Gadget-wikt.start-wizard-steps.js]].
	var steps = require(&quot;ext.gadget.wikt.start-wizard-steps&quot;)(wizardContext());
	steps.trans.keys = steps.lang.choices;
	steps.dunde.keys = steps.lang.choices;
	steps.zarava.keys = getZaravaKeys(steps.lang.choices);
	// This array only controls DOM build order — nothing else keys off it
	// (see the comment above stepIdToGroup). Mane tab order: Mane (senses,
	// with malûmatên pêşketî nested inside each, see steps.dfn.build) →
	// Wêne → Bi zaravayên din → Werger, so dfn/resim/zarava/trans sit
	// adjacent to each other in that order.
	var ordered_steps = [
		steps.lang, steps.pos, steps.posparams,
		steps.cinsiyet, steps.jimar, steps.lektur, steps.tr,
		// Reading order: the senses, then what belongs to the entry as a whole. Etîmolojî follows
		// &quot;Bi alfabeyên din&quot; and keeps a permanent slot; dunde and the three &quot;eleqedar&quot; lists are
		// reached through the Beşên din picker like every other optional section.
		steps.dfn, steps.tewandin, steps.alfabeyendin, steps.etym, steps.zarava, steps.trans,
		steps.dunde, steps.je, steps.tekildar, steps.binereherwiha,
		// Bilêvkirin isn't part of any STEP_GROUPS tab, but still needs a
		// slot here because this array is what builds the DOM.
		steps.pron,
		// Beşên din fields — behind the picker.
		steps.resim,
		steps.bnrh, steps.bikaranin, steps.formalt, steps.hevmane, steps.dijmane, steps.jornav, steps.jernav,
		steps.cavkani, steps.xwendin];

	// ── Sections ─────────────────────────────────────────────────────────────
	// One group, no tab bar. What is always on screen: the senses (whose own blocks carry Nimûne,
	// Jêgirtin, Hevmane and Dijmane — see steps.dfn.allGroups), Tewandin, alfabeyendin, zarava, trans
	// and Etîmolojî. Everything else is added from the &quot;Beşên din&quot; picker, which sits at the top of the
	// form; a newly-picked section is inserted directly under it (see renderBesenDinPicker()), so the
	// most recently added one is always the one nearest the picker.
	//
	// Tewandin keeps its own free-text {{ku-tewîn-nav}} field and does NOT absorb the Cins/zayend form
	// parameters (m=/n=/p=), which stay on the headword template.
	// Behind the &quot;Beşên din&quot; picker: shown only after an explicit open, the way DefSideBoxes' own
	// &quot;+ Beşek lê zêde bike&quot; works -- nothing is on screen until it is asked for.
	var BESENDIN_STEP_IDS = [&quot;resim&quot;, &quot;formalt&quot;, &quot;hevmane&quot;, &quot;dijmane&quot;, &quot;jornav&quot;, &quot;jernav&quot;, &quot;bikaranin&quot;,
		&quot;cavkani&quot;, &quot;xwendin&quot;, &quot;bnrh&quot;, &quot;dunde&quot;, &quot;je&quot;, &quot;tekildar&quot;, &quot;binereherwiha&quot;];
	// One group, so no tab bar: the senses, the fields that go with them, and Etîmolojî, which is common
	// enough to keep a permanent slot. Everything else is reached through the picker above.
	var STEP_GROUPS = [
		{ id: &quot;mane&quot;, label: &quot;Mane&quot;, steps: [&quot;dfn&quot;, &quot;tewandin&quot;, &quot;alfabeyendin&quot;, &quot;zarava&quot;, &quot;trans&quot;, &quot;etym&quot;] }
	];
	// Step id -&gt; index into STEP_GROUPS; undefined for the always-visible ungrouped steps.
	var stepIdToGroup = {};
	$.each(STEP_GROUPS, function (gi, g) {
		$.each(g.steps, function (_, sid) { stepIdToGroup[sid] = gi; });
	});

	// Step ids that belong to each section (not shared across sections).
	var PER_SECTION_STEP_IDS = [
		&quot;pos&quot;, &quot;posparams&quot;, &quot;cinsiyet&quot;, &quot;jimar&quot;, &quot;lektur&quot;, &quot;tr&quot;,
		&quot;resim&quot;, &quot;dfn&quot;, &quot;tewandin&quot;, &quot;formalt&quot;, &quot;bikaranin&quot;, &quot;alfabeyendin&quot;, &quot;hevmane&quot;, &quot;dijmane&quot;, &quot;jornav&quot;, &quot;jernav&quot;, &quot;je&quot;, &quot;tekildar&quot;, &quot;etym&quot;, &quot;dunde&quot;, &quot;binereherwiha&quot;, &quot;zarava&quot;, &quot;trans&quot;, &quot;cavkani&quot;, &quot;xwendin&quot;
	];

	// ── Multi-section state ──────────────────────────────────────────────────
	// Each entry is a plain snapshot: { pos, cinsiyet, lektur, tr, dfn (senses[]),
	// je, tekildar, binereherwiha, trans (rows[]) }.
	var sections = [{}];   // section 0 starts empty (DOM is the truth)
	var activeSection = 0;

	// ── Bilêvkirin as a standalone section ───────────────────────────────
	// Pronunciation belongs to the word, not to one part of speech, so it
	// sits beside Navdêr/Lêker in the tab bar rather than inside any of them.
	// Modelled as a flag rather than an entry in `sections` since
	// activeSection is used as an array index in many places — viewing
	// Bilêvkirin leaves activeSection pointing at the POS section you were on.
	var viewingPron = false;        // is it the tab currently on screen

	// Which STEP_GROUPS tab is currently shown. Lives out here (like
	// activeSection above) so refresh() — which is not nested inside build()
	// — can read it and so renderGroupTabs()/updateGroupTabIndicators() below
	// can be called from refresh() too. Both operate on the tab bar via its
	// #wiktku-group-tabs id rather than a closured element reference, for the
	// same reason.
	var activeGroup = 0;

	// Unsaved-changes / autosave state. Lives out here (same reason as
	// activeGroup above) so destroy() — which runs on final submit and on
	// switching to the source editor, and is not nested inside build() —
	// can clear the timers and the beforeunload warning. build() assigns
	// into these; it doesn't re-declare them.
	var formDirty = false;
	var autosaveDebounceTimer = null;
	var autosaveInterval = null;

	/** Re-renders the step-group tab bar to reflect the current activeGroup. */
	// Scrolls the given tab bar to the top of the viewport, below the sticky offset, so a switched-to tab
	// does not open off-screen. Deferred one frame: switching can shorten the page, and the browser may
	// clamp the scroll position before the measurement runs.
	function scrollTabBarIntoView(barId) {
		window.requestAnimationFrame(function () {
			var bar = document.getElementById(barId);
			if (!bar) return;
			var form = document.getElementById(&quot;wiktku-start-form&quot;);
			var stabsH = form ? (parseFloat(form.style.getPropertyValue(&quot;--wiktku-stabs-h&quot;)) || 0) : 0;
			var siteHeaderH = form ? (parseFloat(form.style.getPropertyValue(&quot;--wiktku-siteheader-h&quot;)) || 0) : 0;
			var top = bar.getBoundingClientRect().top + window.pageYOffset - stabsH - siteHeaderH;
			$(&quot;html, body&quot;).animate({ scrollTop: Math.max(0, top) }, 200);
		});
	}

	function renderGroupTabs() {
		var groupTabsDiv = $(&quot;#wiktku-group-tabs&quot;);
		if (!groupTabsDiv.length) return;
		// One group is nothing to switch between. Done here rather than only where the bar is built,
		// because the form is rebuilt on language/part-of-speech changes and a bar left over from an
		// earlier build would otherwise sit there until refresh() next got round to hiding it.
		if (STEP_GROUPS.length &lt; 2) {
			groupTabsDiv.remove();
			return;
		}
		groupTabsDiv.empty();
		$.each(STEP_GROUPS, function (i, g) {
			var tab = $(&quot;&lt;span&gt;&lt;/span&gt;&quot;)
				.addClass(&quot;wiktku-group-tab&quot;)
				.attr(&quot;data-group-idx&quot;, i)
				.text(g.label)
				.toggleClass(&quot;wiktku-tab-active&quot;, i === activeGroup);
			(function (idx) {
				tab.on(&quot;click&quot;, function () {
					if (idx === activeGroup) return;
					activeGroup = idx;
					renderGroupTabs();
					renderBesenDinPicker();
					refresh();
					scrollTabBarIntoView(&quot;wiktku-group-tabs&quot;);
				});
			}(i));
			groupTabsDiv.append(tab);
		});
	}

	/**
	 * Toggles a &quot;needs attention&quot; dot on any group tab that still has a
	 * required, unfilled field hidden inside it — so switching tabs doesn't
	 * leave the person wondering why &quot;Bişîne&quot; stays disabled.
	 */
	function updateGroupTabIndicators(values) {
		var tabs = $(&quot;#wiktku-group-tabs .wiktku-group-tab&quot;);
		if (!tabs.length) return;
		$.each(STEP_GROUPS, function (i, g) {
			var missing = false;
			$.each(g.steps, function (_, sid) {
				var step = steps[sid];
				if (!step || !step.required) return;
				var val = values[sid];
				if (val === &quot;&quot; || (step.multiple &amp;&amp; $.isArray(val) &amp;&amp; val.join(&quot;&quot;) === &quot;&quot;)) {
					missing = true;
				}
			});
			tabs.eq(i).toggleClass(&quot;wiktku-tab-missing&quot;, missing &amp;&amp; i !== activeGroup);
		});
	}

	// &quot;Beşên din&quot; reveals one field at a time via a picker rather than
	// stacking them all. Per-section state, snapshotted in
	// saveCurrentSection() and restored in restoreSection() below, and
	// auto-seeded from any field that already has content (so a returning
	// draft doesn't hide something already filled in).
	var openedOtherSections = {};
	var BESENDIN_SET = {};
	$.each(BESENDIN_STEP_IDS, function (_, sid) { BESENDIN_SET[sid] = true; });
	// The picker sits at the top of the form, above the senses, and is on screen whenever the form is.

	/** Re-renders the &quot;Beşên din&quot; picker to list only the not-yet-opened sections. */
	function renderBesenDinPicker() {
		var wrap = $(&quot;#wiktku-besendin-picker&quot;);
		if (!wrap.length) return;
		wrap.empty();
		var pickerValues = getValues();
		// Every section it offers belongs to a part-of-speech section, so there is nothing to add until
		// one is chosen. Checked here rather than only in refresh(): this function is also called on form
		// build and on section changes, and each of those would otherwise show the picker on its own.
		if (!pickerValues.pos) {
			wrap.hide();
			return;
		}
		var unopened = $.grep(BESENDIN_STEP_IDS, function (sid) {
			if (openedOtherSections[sid]) return false;
			// Don't offer a section that would open onto nothing: several of
			// these are gated (Bi zaravayên din / Werger need lang=ku, most
			// need a pos). refresh() would hide it again straight away, so
			// picking it would read as a broken dropdown.
			var step = steps[sid];
			if (step &amp;&amp; typeof step.visible === &quot;function&quot;) {
				try {
					if (!step.visible(pickerValues)) return false;
				} catch (e) { /* a step whose visible() needs DOM we lack yet — offer it */ }
			}
			return true;
		});
		if (!unopened.length) {
			wrap.hide(); // everything's open — nothing left to pick
			return;
		}
		// Same voice and styling as a step's own question line, not a section heading -- this picker sits
		// between cards rather than being one.
		wrap.append($(&quot;&lt;label class='wiktku-start-step-question'&gt;&lt;/label&gt;&quot;).text(&quot;Binebeşek lê zêde bike&quot;));
		var sel = $(&quot;&lt;select class='wiktku-besendin-select'&gt;&lt;/select&gt;&quot;);
		sel.attr(&quot;data-placeholder&quot;, &quot;— binebeşên din hilbijêre —&quot;);
		sel.append($(&quot;&lt;option value=''&gt;— binebeşên din hilbijêre —&lt;/option&gt;&quot;));
		$.each(unopened, function (_, sid) {
			var step = steps[sid];
			if (!step) return;
			sel.append($(&quot;&lt;option&gt;&lt;/option&gt;&quot;).val(sid).text(capitalize(step.name)));
		});
		sel.on(&quot;change&quot;, function () {
			var sid = $(this).val();
			if (!sid) return;
			openedOtherSections[sid] = true;
			// Newly opened section moves right under the picker, ahead of
			// whatever's already open, instead of wherever it happened to
			// sit in the fixed step order.
			$(&quot;#wiktku-start-&quot; + sid).insertAfter(wrap);
			renderBesenDinPicker();
			refresh();
		});
		wrap.append(sel);
		initSelects(wrap);
		wrap.show();
	}

	/** Marks any BESENDIN_STEP_IDS field that already has real content as
	 *  &quot;opened&quot;, so restoring a draft doesn't bury filled-in sections behind
	 *  the picker. Reuses each step's own output() as the emptiness check —
	 *  it already knows what &quot;empty&quot; means per field, and it reads the DOM
	 *  the restore just populated. Call this AFTER the DOM has the restored
	 *  values in it. */
	function seedOpenedFromContent() {
		var values = getValues();
		$.each(BESENDIN_STEP_IDS, function (_, sid) {
			if (openedOtherSections[sid]) return;
			var step = steps[sid];
			if (!step || typeof step.output !== &quot;function&quot;) return;
			try {
				if (step.output(values)) openedOtherSections[sid] = true;
			} catch (e) { /* a step whose output() needs more state than we have yet — skip it */ }
		});
	}

	function snapshotDfn() {
		return steps.dfn.getSenses($(&quot;#wiktku-start-dfn&quot;));
	}

	function getWikitextForCurrentSection(callback) {
		var values = getValues();

		var entry = steps.pos.output(values);
		// Bilêvkirin is NOT emitted here — it is one shared field for the
		// whole word, so emitting it per section duplicated it. getWikitext()
		// prints it once, above the POS sections.
		steps.dfn.getOutput(values, function (output) {
			entry += output;
			entry += steps.tewandin.output(values);
			entry += steps.bikaranin.output(values);
			entry += steps.alfabeyendin.output(values);
			entry += steps.formalt.output(values);
			entry += steps.hevmane.output(values);
			entry += steps.dijmane.output(values);
			entry += steps.jornav.output(values);
			entry += steps.jernav.output(values);
			entry += steps.je.output(values);
			entry += steps.tekildar.output(values);
			entry += steps.etym.output(values);
			entry += steps.dunde.output(values);
			entry += steps.binereherwiha.output(values);
			entry += steps.zarava.output(values);
			entry += steps.trans.output(values);
			entry += steps.cavkani.output(values);
			entry += steps.xwendin.output(values);
			callback(entry, values);
		});
	}

	// Two sections of the same part of speech would otherwise both be &quot;=== Rengdêr ===&quot;, which makes them
	// indistinguishable on the page, in the table of contents and in every link that targets one. Run over
	// the finished sections rather than guessed from the pos alone, so &quot;Rengdêr&quot; and &quot;Formeke rengdêrê&quot;
	// -- different headings from the same pos -- are correctly left alone.
	function numberRepeatedHeadings(results) {
		var headingRE = /^(===\s*)([^=\n]+?)(\s*===)$/m;
		var counts = {};
		$.each(results, function (_, text) {
			var m = headingRE.exec(text || &quot;&quot;);
			if (m) counts[m[2]] = (counts[m[2]] || 0) + 1;
		});
		var seen = {};
		$.each(results, function (i, text) {
			var m = headingRE.exec(text || &quot;&quot;);
			if (!m || counts[m[2]] &lt; 2) {
				return;
			}
			seen[m[2]] = (seen[m[2]] || 0) + 1;
			results[i] = text.replace(headingRE, m[1] + m[2] + &quot; &quot; + seen[m[2]] + m[3]);
		});
	}

	function getWikitextAllSections(callback) {
		saveCurrentSection();

		var results = new Array(sections.length);
		var sharedValues = getValues(); // lang/pron are shared

		function processSection(i) {
			// Each hop through here can be reached asynchronously: the dfn
			// step waits on mw.loader.using(&quot;ext.gadget.linkify&quot;) before
			// calling back, so from that point on the submit handler's own
			// try/catch is no longer on the stack. Guard every hop instead,
			// or a throw after linkify loads vanishes into an unhandled
			// rejection and the form just sits there looking busy.
			try {
				if (i &gt;= sections.length) {
					// All done — restore original active section.
					restoreSection(sections[activeSection]);
					refresh();
					numberRepeatedHeadings(results);
					callback(results, sharedValues);
					return;
				}
				restoreSection(sections[i]);
				refresh();
				getWikitextForCurrentSection(function (sectionText) {
					results[i] = sectionText;
					processSection(i + 1);
				});
			} catch (e) {
				if (typeof onSubmitError === &quot;function&quot;) onSubmitError(e);
				else throw e;
			}
		}
		processSection(0);
	}

	// Assembles wikitext for all sections plus the shared lang header.
	function getWikitext(callback) {
		getWikitextAllSections(function (sectionTexts, sharedValues) {
			var bnrh   = steps.bnrh.output(sharedValues);
			var entry  = steps.lang.output(sharedValues);
			// One pronunciation per word, printed once between the language
			// header and the POS sections — see steps.pron.output.
			entry += steps.pron.output(sharedValues);
			entry += sectionTexts.join(&quot;\n&quot;);
			// Reconstruction-namespace pages (ns 108) mark the language
			// section with {{jinûvesazkirî|langcode}} directly above it —
			// only prepended when generating fresh wikitext, same as h-bnr
			// below (addLangMode handles an existing page separately).
			if (!addLangMode &amp;&amp; ns === 108) entry = &quot;{{jinûvesazkirî|&quot; + sharedValues.lang + &quot;}}\n&quot; + entry;
			// h-bnr goes before the language section — only prepended when
			// generating fresh wikitext (not addLangMode, which handles it separately).
			if (!addLangMode &amp;&amp; bnrh) entry = bnrh + entry;

			// Edit summary uses section 0's values. Read from the saved snapshot
			// (not the live DOM) so it doesn't mix section 0's pos with whichever
			// section happens to be active/restored at this point.
			var dfnSenses = (sections[0] &amp;&amp; sections[0].dfn) || [];
			var dfnSummary = dfnSenses.map(function (s) {
				if (s.mane) return s.mane;
				// Template sense (e.g. {{guharto|ku|somepage}}) — same
				// construction as the tplCall built in getOutput, so the
				// summary shows what actually gets written to the entry
				// instead of going blank.
				if (s.tpl &amp;&amp; s.tplTitle) {
					return s.tplNoLang
						? &quot;{{&quot; + s.tpl + &quot;|&quot; + s.tplTitle + &quot;}}&quot;
						: &quot;{{&quot; + s.tpl + &quot;|&quot; + sharedValues.lang + &quot;|&quot; + s.tplTitle + &quot;}}&quot;;
				}
				return &quot;&quot;;
			}).filter(Boolean).join(&quot;; &quot;);
			var summary = &quot;([[Mediawiki:Gadget-start.js|WF:NÛ]] v.2.0) +&quot; +
				sharedValues.lang + &quot;:&quot; + sections[0].pos + &quot;:&quot; + dfnSummary;
			var summaryField = document.getElementById(&quot;wpSummary&quot;);
			if (addLangMode &amp;&amp; summaryField.value) {
				summary = summaryField.value + &quot; &quot; + summary;
			}
			summaryField.value = summary;

			callback(entry);
		});
	}

	var continueBtn;
	// Set by build() to its submitFailed(). Lives out here because the
	// wikitext-assembly functions below are outside build()'s closure but
	// still need a way to report a failure to the person rather than dying
	// silently in the console.
	var onSubmitError = null;
	// Whether Mane/Bi zaravayên din/Werger has anything in it — kept
	// outside refresh() so the click handler can read the latest value.

	function getValuesForStep(stepId) {
		var fields = $(&quot;#wiktku-start-&quot; + stepId + &quot; .wiktku-start-step-field&quot;);
		var step = steps[stepId];
		if (step.keys) {
			var values = {};
			fields.each(function (i, field) {
				var key = $(field).prevAll(&quot;.wiktku-start-step-keyfield&quot;).val();
				if (key) values[key] = $(field).val();
			});
			return values;
		}
		else if (step.multiple) {
			return fields.map(function () {
				return $(this).val();
			}).get();
		}
		return fields.val();
	}

	function getValues() {
		var values = {};
		$.each(steps, function (stepId) {
			values[stepId] = getValuesForStep(stepId);
		});
		return values;
	}

	function populateMenus(inputs, choices, disabledValues, placeholderText) {
		if (!disabledValues) disabledValues = {};
		var vals = inputs.map(function (i, input) {
			return $(input).val();
		});
		inputs.empty();
		inputs.append($(&quot;&lt;option&gt;&lt;/option&gt;&quot;).text(placeholderText || &quot;&quot;));
		$.each(choices, function (j, choice) {
			// Append the language code in parentheses so that typing a code
			// (e.g. &quot;ku&quot;) in the search box still finds the language name.
			var displayText = capitalize(choice.label);
			if (choice.sortKey !== undefined) {
				// This is a language choice {code, label, sortKey} — show code.
				displayText = capitalize(choice.label) + &quot; (&quot; + choice.code + &quot;)&quot;;
			}
			var option = $(mw.html.element(&quot;option&quot;, {
				value: choice.code }, displayText));
			if (disabledValues[choice.code]) option.prop(&quot;disabled&quot;, true);
			inputs.append(option);
		});
		inputs.val(function (i) {
			return vals[i];
		});
	}

	// Keys to disable for a key menu: already-taken or explicitly disabled.
	function getDisabledKeys(step) {
		var occupiedKeys = {};
		$(&quot;#wiktku-start-&quot; + step.id + &quot; .wiktku-start-step-keyfield&quot;).each(function () {
			occupiedKeys[$(this).val()] = true;
		});
		if (step.disabledKeys) $.extend(occupiedKeys, step.disabledKeys);
		return occupiedKeys;
	}

	function buildKeyInput(step) {
		if (!step.keys) return undefined;

		var input = $(mw.html.element(&quot;select&quot;, {
			&quot;class&quot;: &quot;wiktku-start-step-keyfield wiktku-start-narrow&quot; }));
		input.attr(&quot;data-placeholder&quot;, &quot;Hilbijêre &quot; + step.keyName);

		populateMenus(input, step.keys, getDisabledKeys(step));

		// Keep the key menus mutually exclusive: whatever one row selects is
		// disabled in every other row. Recomputed from the DOM on each change.
		input.on(&quot;change&quot;, function () {
			var all = $(&quot;#wiktku-start-&quot; + step.id + &quot; .wiktku-start-step-keyfield&quot;);
			var taken = {};
			all.each(function () {
				var v = $(this).val();
				if (v) taken[v] = true;
			});
			all.not(this).each(function () {
				var self = $(this), own = self.val();
				self.find(&quot;option&quot;).each(function () {
					var code = $(this).val();
					if (code) $(this).prop(&quot;disabled&quot;, !!taken[code] &amp;&amp; code !== own);
				});
				self.trigger(&quot;wiktku:refresh&quot;);
			});
		});

		// Return the wrapper; the select lives inside it and still fires change.
		return wrapNativeSelect(input);
	}

	// Adds another text field to the list if the last one now has text.
	function refreshForTextField(currentInput, step) {
		currentInput = $(currentInput);
		var value = currentInput.val();
		var item = currentInput.parent();
		if (value &amp;&amp; !item.next(&quot;li&quot;).length) {
			var nextInput = $(&quot;&lt;textarea&gt;&lt;/textarea&gt;&quot;)
				.attr(&quot;name&quot;, &quot;wiktku-field-&quot; + $.now() + &quot;-&quot; + Math.random().toString(36).substr(2, 9))
				.attr(&quot;class&quot;, currentInput.attr(&quot;class&quot;))
				.attr(&quot;rows&quot;, currentInput.attr(&quot;rows&quot;) || 1);
			if (step.placeholder) {
				nextInput.attr(&quot;placeholder&quot;, typeof step.placeholder === &quot;function&quot; ? step.placeholder() : step.placeholder);
			}
			nextInput.on(&quot;input&quot;, function (evt) {
				refreshForTextField(evt.target, step);
			});

			var nextKeyInput = buildKeyInput(step);
			var nextItem = step.modifiers
				? makeModifierLi(nextInput).prepend(nextKeyInput || &quot;&quot;)
				: $(&quot;&lt;li&gt;&lt;/li&gt;&quot;).append(nextKeyInput).append(nextInput);
			item.parent().append(nextItem);

			if (nextKeyInput) initSelects(nextItem);
		}

		var canContinue = !continueBtn.isDisabled();
		if ((value &amp;&amp; !canContinue) || (!value &amp;&amp; canContinue)) {
			refresh(step);
		}
	}

	function prepareInput(input, step) {
		if (!input) return;
		if (step.required) input.prop('required', true);
		input.change(step, refresh);
	}

	// Shows/hides steps based on whether their prerequisites are met, and
	// updates placeholders where applicable.
	function refresh(evt) {
		var values = getValues();
		var changedStep = evt &amp;&amp; evt.data;
		var canContinue = true;

		// Re-filter template options in every sense block whenever lang changes.
		$(&quot;#wiktku-start-dfn .wiktku-dfn-tpl-select&quot;).each(function () {
			var fn = $(this).data(&quot;updateOptions&quot;);
			if (typeof fn === &quot;function&quot;) fn();
		});

		// Re-filter the pronunciation template dropdown when language changes -- etym/cavkani's lists don't depend on lang, so they're only built once at data load instead of on every refresh().
		steps.pron.refreshTplSelect();

		// Re-render any step's question label that depends on current values
		// (e.g. dfn's Werger-section reminder, which only applies to ku).
		$.each(steps, function (stepId, step) {
			if (typeof step.question_fmt === &quot;function&quot;) {
				$(&quot;#wiktku-start-&quot; + stepId + &quot; .wiktku-start-step-question&quot;)
					.text(step.question_fmt(values));
			}
		});
		// Pos's definition/example text, right under its dropdown — see
		// steps.pos.example and the .wiktku-start-pos-example build above.
		$(&quot;#wiktku-start-pos .wiktku-start-pos-example&quot;).text(steps.pos.example(values));

		// Sync every sense block's mane-box mode (plain mane vs tercime+îzah)
		// to the current language, in case lang changes after blocks exist.
		// Same pass also re-syncs Dever/Şîwe's default open/closed state
		// (open for ku, closed otherwise — see updateDeverOpenState) and
		// reveals any sub-field group that has ended up with content in it
		// while still behind the chip row (a draft, a restore).
		$(&quot;#wiktku-start-dfn li.wiktku-dfn-sense&quot;).each(function () {
			var updateMane = $(this).data(&quot;updateManeMode&quot;);
			if (updateMane) updateMane();
			var updateDeverOpen = $(this).data(&quot;updateDeverOpenState&quot;);
			if (updateDeverOpen) updateDeverOpen();
			var syncPicks = $(this).data(&quot;syncSensePicks&quot;);
			if (syncPicks) syncPicks();
		});

		// Sync tr/t sub-fields in every nimûne item to the current language.
		// tr shown when language needs transliteration; t once a language is chosen.
		(function () {
			var lang = values.lang || &quot;&quot;;
			var showTr = needsTransliteration(lang);
			var showT  = !!lang;
			$(&quot;#wiktku-start-dfn .wiktku-dfn-nimune-list li.wiktku-dfn-nimune-li&quot;).each(function () {
				var li = $(this);

				// Ensure the sub-wrapper exists when we need it.
				var subWrap = li.find(&quot;.wiktku-dfn-nimune-sub&quot;);

				// tr field
				var trTa = li.find(&quot;.wiktku-dfn-nimune-tr&quot;);
				if (showTr &amp;&amp; !trTa.length) {
					if (!subWrap.length) {
						subWrap = $(&quot;&lt;div&gt;&lt;/div&gt;&quot;).addClass(&quot;wiktku-dfn-nimune-sub&quot;);
						li.append(subWrap);
					}
					trTa = $(&quot;&lt;textarea&gt;&lt;/textarea&gt;&quot;)
						.attr(&quot;name&quot;, &quot;wiktku-dfn-nimune-tr-&quot; + $.now() + &quot;-&quot; + Math.random().toString(36).substr(2, 9))
						.attr(&quot;rows&quot;, 5)
						.attr(&quot;class&quot;, &quot;wiktku-dfn-subfield wiktku-dfn-nimune-tr&quot;)
						.attr(&quot;placeholder&quot;, &quot;Transliterasyon…&quot;);
					subWrap.prepend(trTa);
				} else if (!showTr &amp;&amp; trTa.length) {
					trTa.remove();
				}

				// t field
				var tTa = li.find(&quot;.wiktku-dfn-nimune-t&quot;);
				if (showT &amp;&amp; !tTa.length) {
					if (!subWrap.length) {
						subWrap = $(&quot;&lt;div&gt;&lt;/div&gt;&quot;).addClass(&quot;wiktku-dfn-nimune-sub&quot;);
						li.append(subWrap);
					}
					tTa = $(&quot;&lt;textarea&gt;&lt;/textarea&gt;&quot;)
						.attr(&quot;name&quot;, &quot;wiktku-dfn-nimune-t-&quot; + $.now() + &quot;-&quot; + Math.random().toString(36).substr(2, 9))
						.attr(&quot;rows&quot;, 5)
						.attr(&quot;class&quot;, &quot;wiktku-dfn-subfield wiktku-dfn-nimune-t&quot;);
					subWrap.append(tTa);
				} else if (!showT &amp;&amp; tTa.length) {
					tTa.remove();
				}
				tTa.attr(&quot;placeholder&quot;, nimuneTranslationPrompt(lang));

				// Remove the wrapper if it ended up empty.
				subWrap = li.find(&quot;.wiktku-dfn-nimune-sub&quot;);
				if (subWrap.length &amp;&amp; !subWrap.children().length) subWrap.remove();
			});
		}());

		// Re-sync the &quot;&lt;label&gt; bi &lt;ziman&gt;…&quot; placeholder on every always-visible
		// sub-field list (etîket, kategorî, hevmane, …), since the language may
		// not have been chosen yet when these lists were first built, or may
		// have changed since.
		$(&quot;#wiktku-start-dfn .wiktku-dfn-sublist&quot;).each(function () {
			var upd = $(this).data(&quot;updatePlaceholders&quot;);
			if (typeof upd === &quot;function&quot;) upd();
		});

		// Same idea for word-list steps (jê, têkildar, binêre herwiha, …)
		// whose placeholder is a function of the current language.
		$.each(steps, function (stepId, step) {
			if (typeof step.placeholder === &quot;function&quot;) {
				$(&quot;#wiktku-start-&quot; + stepId + &quot; textarea.wiktku-start-step-field&quot;)
					.attr(&quot;placeholder&quot;, step.placeholder());
			}
		});

		// Sync tr/t sub-fields in every jêder citation to the current language.
		// tr shown when language needs transliteration; t shown when lang !== &quot;ku&quot;.
		(function () {
			var lang = values.lang || &quot;&quot;;
			var showTr = needsTransliteration(lang);
			var showT  = lang &amp;&amp; lang !== &quot;ku&quot;;
			$(&quot;#wiktku-start-dfn .wiktku-dfn-jeder-list li.wiktku-dfn-jeder-li&quot;).each(function () {
				var li = $(this);

				// Ensure the sub-wrapper exists when we need it. It must sit right
				// after the quote textarea and before the source selector.
				var subWrap = li.find(&quot;.wiktku-dfn-quote-sub&quot;);

				// tr field
				var trTa = li.find(&quot;.wiktku-dfn-nimune-quote-tr&quot;);
				if (showTr &amp;&amp; !trTa.length) {
					if (!subWrap.length) {
						subWrap = $(&quot;&lt;div&gt;&lt;/div&gt;&quot;).addClass(&quot;wiktku-dfn-quote-sub&quot;);
						// Insert after the quote textarea's resize-wrap (if the manual
						// resize handle has already been attached to it), not after the
						// bare textarea -- otherwise this lands *inside* that wrap,
						// between the textarea and its own grip, breaking jêgirtin's
						// handle and nesting the tr/t boxes inside it.
						var quoteTa = li.find(&quot;.wiktku-dfn-nimune-quote&quot;);
						var quoteResizeWrap = quoteTa.closest(&quot;.wiktku-resize-wrap&quot;);
						(quoteResizeWrap.length ? quoteResizeWrap : quoteTa).after(subWrap);
					}
					trTa = $(&quot;&lt;textarea&gt;&lt;/textarea&gt;&quot;)
						.attr(&quot;name&quot;, &quot;wiktku-dfn-nimune-quote-tr-&quot; + $.now() + &quot;-&quot; + Math.random().toString(36).substr(2, 9))
						.attr(&quot;rows&quot;, 2)
						.attr(&quot;class&quot;, &quot;wiktku-dfn-subfield wiktku-dfn-nimune-quote-tr&quot;)
						.attr(&quot;placeholder&quot;, &quot;Transliterasyona jêgirtinê…&quot;);
					subWrap.prepend(trTa);
				} else if (!showTr &amp;&amp; trTa.length) {
					trTa.remove();
				}

				// t field
				var tTa = li.find(&quot;.wiktku-dfn-nimune-quote-t&quot;);
				if (showT &amp;&amp; !tTa.length) {
					if (!subWrap.length) {
						subWrap = $(&quot;&lt;div&gt;&lt;/div&gt;&quot;).addClass(&quot;wiktku-dfn-quote-sub&quot;);
						// See the tr-field branch above for why this targets the
						// resize-wrap instead of the bare textarea.
						var quoteTa2 = li.find(&quot;.wiktku-dfn-nimune-quote&quot;);
						var quoteResizeWrap2 = quoteTa2.closest(&quot;.wiktku-resize-wrap&quot;);
						(quoteResizeWrap2.length ? quoteResizeWrap2 : quoteTa2).after(subWrap);
					}
					tTa = $(&quot;&lt;textarea&gt;&lt;/textarea&gt;&quot;)
						.attr(&quot;name&quot;, &quot;wiktku-dfn-nimune-quote-t-&quot; + $.now() + &quot;-&quot; + Math.random().toString(36).substr(2, 9))
						.attr(&quot;rows&quot;, 2)
						.attr(&quot;class&quot;, &quot;wiktku-dfn-subfield wiktku-dfn-nimune-quote-t&quot;)
						.attr(&quot;placeholder&quot;, &quot;Tercimeya jêgirtinê bi kurmancî…&quot;);
					subWrap.append(tTa);
				} else if (!showT &amp;&amp; tTa.length) {
					tTa.remove();
				}

				// Remove the wrapper if it ended up empty.
				subWrap = li.find(&quot;.wiktku-dfn-quote-sub&quot;);
				if (subWrap.length &amp;&amp; !subWrap.children().length) subWrap.remove();
			});
		}());

		$.each(steps, function (stepId, step) {
			var groupIdx = stepIdToGroup[stepId];
			var hiddenByTab = (groupIdx !== undefined &amp;&amp; groupIdx !== activeGroup) ||
				// Beşên din picker: stays hidden even while its tab is
				// active until explicitly opened from the dropdown.
				(BESENDIN_SET[stepId] &amp;&amp; !openedOtherSections[stepId]);

			// Bilêvkirin is its own section now, so the two views are
			// mutually exclusive: on it, only pron shows (plus Ziman, which
			// is shared and stays above every section); off it, pron is
			// hidden no matter which tab is active. pron is deliberately
			// ungrouped — stepIdToGroup has no entry for it — so without
			// this branch it would show on all four tabs at once.
			if (stepId === &quot;pron&quot;) {
				hiddenByTab = hiddenByTab || !viewingPron;
			} else if (viewingPron &amp;&amp; stepId !== &quot;lang&quot;) {
				hiddenByTab = true;
			}
			if (hiddenByTab || (typeof(step.visible) === &quot;function&quot; &amp;&amp; !step.visible(values))) {
				$(&quot;#wiktku-start-&quot; + stepId).hide();
			}
			else {
				var stepDiv = $(&quot;#wiktku-start-&quot; + stepId);

				if (changedStep !== step &amp;&amp; typeof(step.build) === &quot;function&quot;) {
					prepareInput(step.build(stepDiv, values), step);
				}

				// After build, sync the posparams helper widgets whenever pos or lang changes.
				if (step.id === &quot;posparams&quot; &amp;&amp; typeof step.syncHelpers === &quot;function&quot;) {
					step.syncHelpers(stepDiv);
				}

				var input = stepDiv.find(&quot;.wiktku-start-step-field&quot;);
				if (typeof(step.example) === &quot;function&quot;) {
					// .find() above already reaches nested fields (e.g. the dfn
					// step's mane textareas inside each sense block), so one
					// assignment covers every step; dfn keeps its own fallback.
					var exampleText = step.example(values) || (step.id === &quot;dfn&quot; ? &quot;Mane…&quot; : &quot;&quot;);
					input.attr(&quot;placeholder&quot;, exampleText);
				}

				stepDiv.slideDown();
			}

			if (step.required &amp;&amp;
				(values[stepId] === &quot;&quot; ||
				(step.multiple &amp;&amp; values[stepId].join(&quot;&quot;) === &quot;&quot;))) {
				canContinue = false;
			}
		});

		// One group means no bar to show; it only appears again if STEP_GROUPS ever grows back.
		$(&quot;#wiktku-group-tabs&quot;).toggle(STEP_GROUPS.length &gt; 1 &amp;&amp; !!values.pos &amp;&amp; !viewingPron);
		// Bilêvkirin hides the picker outright; otherwise renderBesenDinPicker() decides, showing itself
		// only once a part of speech is chosen and there are sections left to offer. The decision lives
		// there rather than here because that function has other callers, which would each need the same
		// test.
		var besenDinActive = !viewingPron;
		if (!besenDinActive) {
			$(&quot;#wiktku-besendin-picker&quot;).hide();
		}
		// The option list is filtered by each step's visible(), which depends
		// on lang/pos — so it has to be rebuilt when those change, not just
		// when a section is opened. Safe to call from here: rendering the
		// picker doesn't itself call refresh(), only picking an option does.
		if (besenDinActive) renderBesenDinPicker();

		updateGroupTabIndicators(values);
		// Ziman and Cureyê rêzimanî are all it takes: an entry with a heading and a template but no
		// definition yet is a skeleton somebody means to come back to, not a mistake to be blocked.
		continueBtn.setDisabled(!canContinue);
	}

	function destroy() {
		if (autosaveDebounceTimer) clearTimeout(autosaveDebounceTimer);
		if (autosaveInterval) clearInterval(autosaveInterval);
		formDirty = false;
		$(window).off(&quot;beforeunload.wiktkuUnsaved&quot;);

		$(&quot;#wiktku-start-form, .noafterwizard&quot;).slideUp(function () {
			$(this).remove();
		});
		$(&quot;.noarticletext .nowizard&quot;).slideDown();

		// #editform was kept laid-out but off-screen (see build()) instead of
		// display:none, precisely so the editor never had to size itself
		// against a zero-width/height box. Just bring it back on-screen —
		// no slideDown needed since it was never actually collapsed.
		$(&quot;#editform&quot;).removeClass(&quot;wiktku-offscreen&quot;);
		// Belt-and-braces: if WikiEditor/CodeMirror/mobile's auto-grow still
		// cached a stale size from some earlier point, nudge them to
		// recalculate now that the box is genuinely visible.
		$(window).trigger(&quot;resize&quot;);
		if (window.CodeMirror) {
			var cm = $(&quot;#wpTextbox1&quot;).data(&quot;CodeMirror&quot;) || $(&quot;#wpTextbox1&quot;).data(&quot;cmInstance&quot;);
			if (cm &amp;&amp; typeof cm.refresh === &quot;function&quot;) cm.refresh();
		}

		$(&quot;#ca-edit&quot;).removeClass(&quot;selected&quot;);
		$(&quot;#ca-wiktku-nowizard&quot;).addClass(&quot;selected&quot;);
	}

	// Priority order for Kurdish dialects and navz.
	// Codes listed here come before all other languages; unlisted codes
	// are sorted alphabetically by their display name via localeCompare.
	var LANG_PRIORITY = [&quot;navz&quot;, &quot;ku&quot;, &quot;hac&quot;, &quot;sdh&quot;, &quot;lki&quot;, &quot;ckb&quot;, &quot;zza&quot;];

	// Inserts a new &quot;== {{ziman|code}} ==&quot; section at the correct sorted
	// position: navz, then ku/hac/sdh/lki/ckb/zza, then alphabetical by name.
	function insertNewLangSection(existing, wikitext) {
		var newCodeMatch = wikitext.match(new RegExp(&quot;^\n?&quot; + langHeaderSource(&quot;[^}]+&quot;)));
		var newCode = newCodeMatch ? newCodeMatch[1] : &quot;&quot;;
		var sections = [];
		var preamble = &quot;&quot;;
		var anyHeaderSrc = &quot;\n?&quot; + langHeaderSource(&quot;[^}]+&quot;);
		var firstMatch = new RegExp(&quot;^&quot; + anyHeaderSrc, &quot;m&quot;).exec(existing);

		if (!firstMatch) {
			// No existing lang sections — just write the new section.
			// Add \n\n only when there is real non-whitespace content above.
			var trimmed = existing.replace(/\s+$/, &quot;&quot;);
			return trimmed ? trimmed + &quot;\n\n&quot; + wikitext : wikitext;
		}

		// Everything before the first == {{ziman|...}} == is the preamble.
		var firstSectionStart = firstMatch.index;
		// Walk back to the start of that line.
		var lineStart = existing.lastIndexOf(&quot;\n&quot;, firstSectionStart - 1);
		var preambleEnd = lineStart !== -1 ? lineStart + 1 : 0;
		preamble = existing.slice(0, preambleEnd);

		// Parse each language section: header line + everything until the next header.
		var body = existing.slice(preambleEnd);
		// (?![\s\S]) matches only true end-of-string, since a bare &quot;$&quot; with
		// /m would stop at the section's first line break instead.
		var langSectionRe = new RegExp(
			&quot;^(&quot; + anyHeaderSrc + &quot;\\n?)([\\s\\S]*?)(?=\\n&quot; + anyHeaderSrc + &quot;|(?![\\s\\S]))&quot;,
			&quot;gm&quot;
		);
		var m;
		while ((m = langSectionRe.exec(body)) !== null) {
			sections.push({
				code:    m[2],
				content: m[0]   // full text of this section including header
			});
		}

		// Determine sort rank: priority list first (by index), then alphabetical.
		function getLangName(code) {
			var entry = langsByCode[code];
			return entry ? entry.label : code;
		}
		function sortRank(code) {
			var idx = LANG_PRIORITY.indexOf(code);
			return idx !== -1 ? idx : LANG_PRIORITY.length;
		}
		function compareLangs(a, b) {
			var ra = sortRank(a), rb = sortRank(b);
			if (ra !== rb) return ra - rb;
			// Both are outside priority list — sort by display name.
			return getLangName(a).localeCompare(getLangName(b), userLang);
		}

		// Insert the new section into the sorted list.
		var newSection = { code: newCode, content: wikitext };
		var inserted = false;
		for (var i = 0; i &lt; sections.length; i++) {
			if (compareLangs(newCode, sections[i].code) &lt; 0) {
				sections.splice(i, 0, newSection);
				inserted = true;
				break;
			}
		}
		if (!inserted) sections.push(newSection);

		// Re-join: preamble + sections, each separated by exactly \n\n.
		// Trim trailing whitespace off each section's content first so we
		// control the spacing precisely.
		var joined = sections.map(function (s) {
			return s.content.replace(/\s+$/, &quot;&quot;);
		}).join(&quot;\n\n&quot;);

		// Only add a separator after the preamble when it has real content.
		var preambleTrimmed = preamble.replace(/\s+$/, &quot;&quot;);
		var prefix = preambleTrimmed ? preambleTrimmed + &quot;\n\n&quot; : &quot;&quot;;

		return prefix + joined + &quot;\n&quot;;
	}

	// What [[MediaWiki:Gadget-wikt.start-wizard/form.js]] uses of this closure. What changes after loading is read and set
	// through getters and setters on the same variables.
	function formContext() {
		var ctx = {
			PER_SECTION_STEP_IDS: PER_SECTION_STEP_IDS,
			STEP_GROUPS: STEP_GROUPS,
			WIKTKU_SUGGESTIONS_KEY_PREFIX: WIKTKU_SUGGESTIONS_KEY_PREFIX,
			addLangMode: addLangMode,
			buildKeyInput: buildKeyInput,
			capitalize: capitalize,
			destroy: destroy,
			findLangHeader: findLangHeader,
			formCache: formCache,
			getValues: getValues,
			getValuesForStep: getValuesForStep,
			getWikitext: getWikitext,
			highlightLinebreak: highlightLinebreak,
			initSelects: initSelects,
			insertNewLangSection: insertNewLangSection,
			isWordGroupCls: isWordGroupCls,
			langHeaderSource: langHeaderSource,
			makeModifierLi: makeModifierLi,
			makeTrashButton: makeTrashButton,
			ordered_steps: ordered_steps,
			populateMenus: populateMenus,
			prepareInput: prepareInput,
			refresh: refresh,
			refreshForTextField: refreshForTextField,
			renderBesenDinPicker: renderBesenDinPicker,
			renderGroupTabs: renderGroupTabs,
			scrollTabBarIntoView: scrollTabBarIntoView,
			seedOpenedFromContent: seedOpenedFromContent,
			snapshotDfn: snapshotDfn,
			splitTercimeIzah: splitTercimeIzah,
			stepIdToGroup: stepIdToGroup,
			steps: steps,
			wiktkuCite: wiktkuCite,
			wiktkuEdit: wiktkuEdit,
			wiktkuInitManualResize: wiktkuInitManualResize,
			wiktkuLangs: wiktkuLangs,
			wiktkuNotify: wiktkuNotify,
			wiktkuPosparams: wiktkuPosparams,
			wiktkuSavePrefs: wiktkuSavePrefs,
			wiktkuUtil: wiktkuUtil,
			wiktkuWikitext: wiktkuWikitext,
			wordGroups: wordGroups
		};
		Object.defineProperties(ctx, {
			activeSection: { get: function () { return activeSection; }, set: function (value) { activeSection = value; } },
			autosaveDebounceTimer: { get: function () { return autosaveDebounceTimer; }, set: function (value) { autosaveDebounceTimer = value; } },
			autosaveInterval: { get: function () { return autosaveInterval; }, set: function (value) { autosaveInterval = value; } },
			continueBtn: { get: function () { return continueBtn; }, set: function (value) { continueBtn = value; } },
			formDirty: { get: function () { return formDirty; }, set: function (value) { formDirty = value; } },
			onSubmitError: { get: function () { return onSubmitError; }, set: function (value) { onSubmitError = value; } },
			openedOtherSections: { get: function () { return openedOtherSections; }, set: function (value) { openedOtherSections = value; } },
			sections: { get: function () { return sections; }, set: function (value) { sections = value; } },
			viewingPron: { get: function () { return viewingPron; }, set: function (value) { viewingPron = value; } },
			wiktkuMergeLanguages: { get: function () { return wiktkuMergeLanguages; } },
			wiktkuPrefs: { get: function () { return wiktkuPrefs; }, set: function (value) { wiktkuPrefs = value; } }
		});
		return ctx;
	}

	var wizardForm = require(&quot;./wikt.start-wizard/form.js&quot;)(formContext());
	var build = wizardForm.build;
	var restoreSection = wizardForm.restoreSection;
	var saveCurrentSection = wizardForm.saveCurrentSection;

	// Only oojs-ui-core blocks the initial render now — icons-moderation
	// (the trash glyph) is fetched lazily by makeTrashButton() instead, so
	// slow connections aren't held up loading it before anyone needs it.
	mw.loader.using([&quot;oojs-ui-core&quot;], function () {

		function wiktkuProceedWithData(wiktkuData) {
			var d = wiktkuData || {};

			// Populate metadata.
			if (d.metadata) $.extend(metadata, d.metadata);

			// Populate gender labels.
			if (d.genderLabels) $.extend(GENDER_BASE_LABELS, d.genderLabels);

			if (d.senseGroups) SENSE_GROUPS = d.senseGroups;
			// Headings for the page-level word lists, from the same table DefSideBoxes reads.
			$.each(d.pageSubsections || [], function (_, sub) {
				if (sub.kind !== &quot;wordlist&quot; || !steps[sub.id]) return;
				steps[sub.id].header = sub.header;
				steps[sub.id].name = decapitalize(sub.header);
			});
			if (d.wordlistTemplates &amp;&amp; d.wordlistTemplates.length) WORDLIST_TEMPLATE = d.wordlistTemplates[0];
			if (d.deverQuickPicks) DEVER_QUICK_PICKS = d.deverQuickPicks;

			// Populate lang choices (pinned list).
			if (d.langChoices) steps.lang.choices = choicesFromObject(d.langChoices, true);

			// Populate langsByCode and merge full language list from d.ziman.
			// d.ziman is a {code: name} object with all known languages.
			$.each(steps.lang.choices, function (i, choice) {
				if (choice.sortKey === undefined) choice.sortKey = choice.label;
				langsByCode[choice.code] = choice;
			});
			// Only the ~300 languages of ziman-core.json are merged in at load; the other ~3400 arrive
			// through wiktkuMergeLanguages() the first time somebody searches for one of them. The pinned
			// choices are kept aside so a second merge rebuilds the list instead of appending to it.
			var wiktkuPinnedChoices = steps.lang.choices;
			wiktkuMergeLanguages = function (zimanNames) {
				var pinnedCodes = {};
				$.each(wiktkuPinnedChoices, function (i, c) { pinnedCodes[c.code] = true; });
				var extraChoices = [];
				$.each(zimanNames || {}, function (code, name) {
					// A proto-language is never the language of an ordinary entry, but it is the whole point
					// of a reconstruction page, so ns 108 keeps them in the list.
					if (!isReconstruction &amp;&amp; /-pro$/i.test(code)) return;
					if (/ziman[eê]\s+destan/i.test(name)) return;
					if (pinnedCodes[code]) return;
					var choice = { code: code, label: name, sortKey: name };
					extraChoices.push(choice);
					langsByCode[code] = choice;
				});
				// One Intl.Collator built once and reused for the whole sort, instead of localeCompare() rebuilding a collator on every pair -- same order, far faster over ~3700 entries.
				var langCollator = new Intl.Collator(userLang);
				extraChoices.sort(function (a, b) {
					return langCollator.compare(a.sortKey, b.sortKey);
				});
				steps.lang.choices = wiktkuPinnedChoices.concat(extraChoices);
				// The translation/dialect steps reference any language, so they follow the same list.
				steps.trans.keys = steps.lang.choices;
				steps.dunde.keys = steps.lang.choices;
				steps.zarava.keys = getZaravaKeys(steps.lang.choices);
				return steps.lang.choices;
			};
			wiktkuMergeLanguages(wiktkuLangs.names());

			// Keep the full merged list around for trans/dunde/zarava — those
			// should still be able to reference any language even when the
			// Tercîh panel restricts the main &quot;ziman&quot; step below — then, if
			// the user set a restriction there, narrow steps.lang.choices
			// itself to just those codes.
			var wiktkuFullLangChoices = steps.lang.choices;
			if (wiktkuPrefs.langCodes &amp;&amp; wiktkuPrefs.langCodes.length) {
				var wiktkuAllowedLangSet = {};
				$.each(wiktkuPrefs.langCodes, function (i, code) { wiktkuAllowedLangSet[code] = true; });
				var wiktkuRestrictedChoices = $.grep(wiktkuFullLangChoices, function (c) {
					return !!wiktkuAllowedLangSet[c.code];
				});
				// Fall back to the full list instead of showing an empty
				// dropdown if none of the saved codes matched anything
				// (typo'd code, data-main.json changed since, …).
				steps.lang.choices = wiktkuRestrictedChoices.length ? wiktkuRestrictedChoices : wiktkuFullLangChoices;
			}

			// Populate POS choices — also a plain {code: label} object, from data-sections.json.
			if (d.posChoices) steps.pos.choices = choicesFromObject(d.posChoices, false);

			// Populate template definitions for the dfn sense-block builder.
			if (d.tplDefs) steps.dfn.tplDefs = d.tplDefs;

			// Populate pos placeholder examples.
			if (d.posExamples) steps.pos.posExamples = d.posExamples;

			// Populate citation template definitions for the quote widget.
			if (d.jederDefs) steps.dfn.jederDefs = d.jederDefs;

			// Populate pronunciation and etymology template insert lists.
			if (d.pronTpls) {
				steps.pron.pronTpls = d.pronTpls;
				steps.pron.refreshTplSelect();
			}
			if (d.etymTpls) {
				steps.etym.etymTpls = d.etymTpls;
				steps.etym.refreshTplSelect();
			}

			// Sync trans/dunde/zarava keys with the full language list
			// (not the possibly Tercîh-restricted steps.lang.choices).
			steps.trans.keys = wiktkuFullLangChoices;
			steps.dunde.keys = wiktkuFullLangChoices;
			steps.zarava.keys = getZaravaKeys(wiktkuFullLangChoices);

			build();
		}

		// The data ships inside wikt.edit, so it is already parsed and in memory.
		wiktkuProceedWithData(wiktkuEdit.data);
	});
});
//&lt;/nowiki&gt;</text>
      <sha1>djoeuga2tvtqag73ejvh5gqnrr77ogq</sha1>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Gadget-wikt.start-wizard-steps.js</title>
    <ns>8</ns>
    <id>1359513</id>
    <revision>
      <id>6903104</id>
      <parentid>6902289</parentid>
      <timestamp>2026-11-10T21:29:01Z</timestamp>
      <contributor>
        <username>Wikihez</username>
        <id>7344</id>
      </contributor>
      <minor />
      <comment>Script pages under 100 KB: part of the code moved to a second file; shared code in one place</comment>
      <origin>6903104</origin>
      <model>javascript</model>
      <format>text/javascript</format>
      <text bytes="83405" sha1="c52g7g1fvwbn4t37y4yhv4zl694bpqx" xml:space="preserve">// &lt;nowiki&gt;
/*
 * Page: [[MediaWiki:Gadget-wikt.start-wizard-steps.js]]
 *
 * The step definitions of [[MediaWiki:Gadget-wikt.start-wizard.js]]: what each step asks, offers and writes.
 * A module of its own so that neither half passes the 100 KB the browser's module store keeps. The wizard
 * calls it with ctx, its own helpers and settings; the few settings it changes after loading
 * (DEVER_QUICK_PICKS, SENSE_GROUPS, catSrcTemplates, pageName, wiktkuLabelSets) are read through ctx as
 * they are at that moment.
 */
/* global wikt */
module.exports = function (ctx) {
	var addLangMode = ctx.addLangMode;
	var applyTplDescriptions = ctx.applyTplDescriptions;
	var bindMoreMenuCloser = ctx.bindMoreMenuCloser;
	var buildChipField = ctx.buildChipField;
	var buildCite = ctx.buildCite;
	var buildDeverTpl = ctx.buildDeverTpl;
	var buildEtiketTpl = ctx.buildEtiketTpl;
	var buildManeidTpl = ctx.buildManeidTpl;
	var buildSenseTpl = ctx.buildSenseTpl;
	var capitalize = ctx.capitalize;
	var findLangHeader = ctx.findLangHeader;
	var getLangLabel = ctx.getLangLabel;
	var getValues = ctx.getValues;
	var highlightLinebreak = ctx.highlightLinebreak;
	var initSelects = ctx.initSelects;
	var insertAtCursor = ctx.insertAtCursor;
	var insertLineSnippet = ctx.insertLineSnippet;
	var isReconstruction = ctx.isReconstruction;
	var isWordGroupCls = ctx.isWordGroupCls;
	var makeModifierLi = ctx.makeModifierLi;
	var makeTrashButton = ctx.makeTrashButton;
	var manePlaceholder = ctx.manePlaceholder;
	var markTemplateOptions = ctx.markTemplateOptions;
	var needsTransliteration = ctx.needsTransliteration;
	var nimuneTranslationPrompt = ctx.nimuneTranslationPrompt;
	var refresh = ctx.refresh;
	var senseHasExtraContent = ctx.senseHasExtraContent;
	var splitTercimeIzah = ctx.splitTercimeIzah;
	var stripWikilinks = ctx.stripWikilinks;
	var tplNameFromSnippet = ctx.tplNameFromSnippet;
	var wiktkuCite = ctx.wiktkuCite;
	var wiktkuEdit = ctx.wiktkuEdit;
	var wiktkuEnsureLabels = ctx.wiktkuEnsureLabels;
	var wiktkuLabelListeners = ctx.wiktkuLabelListeners;
	var wiktkuLabelSuggestions = ctx.wiktkuLabelSuggestions;
	var wiktkuPosparams = ctx.wiktkuPosparams;
	var wiktkuUtil = ctx.wiktkuUtil;
	var wiktkuWikitext = ctx.wiktkuWikitext;
	var wordGroups = ctx.wordGroups;

	var steps = {
		lang: {
			id: &quot;lang&quot;,
			required: true,
			name: &quot;ziman&quot;,
			question_fmt: '&quot;' + ctx.pageName + '&quot; bi çi zimanî ye?',
			// Populated from data-main.json (langChoices).
			choices: [],
			output: function (values) {
				return &quot;== {{ziman|&quot; + values.lang + &quot;}} ==\n&quot;;
			}
		},
		pron: {
			id: &quot;pron&quot;,
			name: &quot;bilêvkirin&quot;,
			question_fmt: '&quot;' + ctx.pageName + '&quot; çawa tê telafûzkirin?',
			// pronTpls populated from data-main.json
			pronTpls: {},
			visible: function (values) {
				if (!values.lang) return false;
				// addLangMode: skip pron only if this lang already has a section.
				if (addLangMode) {
					// Clearing the page makes existing content irrelevant.
					var clearPageCheck = $(&quot;#wiktku-clear-page-check&quot;);
					if (clearPageCheck.length &amp;&amp; clearPageCheck.prop(&quot;checked&quot;)) {
						return true;
					}
					var existing = $(&quot;#wpTextbox1&quot;).val() || &quot;&quot;;
					return !findLangHeader(existing, values.lang);
				}
				return true;
			},
			// Fills the insert-dropdown from pronTpls, filtered by language.
			refreshTplSelect: function () {
				var sel = $(&quot;#wiktku-start-pron .wiktku-tpl-insert-select&quot;);
				if (!sel.length) return;
				var lang = getValues().lang || &quot;&quot;;
				sel.find(&quot;option[value!='']&quot;).remove();
				$.each(steps.pron.pronTpls, function (name, tpl) {
					// Filter: if tpl.langs exists, only show if lang is in that list; otherwise show always
					var allowed = !tpl.langs || tpl.langs.indexOf(lang) !== -1;
					if (allowed) {
						sel.append($(&quot;&lt;option&gt;&lt;/option&gt;&quot;)
							.val(tpl.snippet)
							.text(name + &quot; — &quot; + tpl.desc)
							.attr(&quot;data-nolang&quot;, tpl.noLang ? &quot;1&quot; : &quot;&quot;));
					}
				});
				markTemplateOptions(sel, function (opt) { return tplNameFromSnippet(opt.val()); });
				// Tell the picker the option list changed.
				sel.trigger(&quot;wiktku:refresh&quot;);
			},
			build: function (stepDiv) {
				if (stepDiv.find(&quot;.wiktku-pron-wrap&quot;).length) return null;

				var wrap = $(&quot;&lt;div class='wiktku-pron-wrap'&gt;&lt;/div&gt;&quot;);

				// Reassures the user this field is optional — the dropdown
				// below writes the template for them, no syntax needed up front.
				wrap.append(
					$(&quot;&lt;p class='wiktku-step-hint'&gt;&lt;/p&gt;&quot;).text(
						&quot;Ev qism ne mecbûrî ye. Heke tu nizanî kîjan şablonê hilbijêrî, vala bihêle.&quot;
					)
				);

				var ta = $(&quot;&lt;textarea&gt;&lt;/textarea&gt;&quot;)
					.attr(&quot;name&quot;, &quot;wiktku-pron-&quot; + $.now())
					.attr(&quot;class&quot;, &quot;wiktku-start-step-field wiktku-pron-text&quot;)
					.attr(&quot;rows&quot;, 4)
					.attr(&quot;placeholder&quot;, &quot;Nimûne: {{IPA|ku|/pɛɪ̯n/}} yan {{kîte|ku|he|ce|ki|rin}}&quot;);

				// Template insert dropdown — filtered by language.
				var sel = $(&quot;&lt;select class='wiktku-tpl-insert-select'&gt;&lt;/select&gt;&quot;);
				sel.attr(&quot;data-placeholder&quot;, wiktkuUtil.msg.addTemplate);
				sel.append($(&quot;&lt;option value=''&gt;— şablonek lê zêde bike —&lt;/option&gt;&quot;));
				var lang = getValues().lang || &quot;&quot;;
				$.each(steps.pron.pronTpls, function (name, tpl) {
					// Filter: if tpl.langs exists, only show if lang is in that list; otherwise show always
					var allowed = !tpl.langs || tpl.langs.indexOf(lang) !== -1;
					if (allowed) {
						sel.append($(&quot;&lt;option&gt;&lt;/option&gt;&quot;)
							.val(tpl.snippet)
							.text(name + &quot; — &quot; + tpl.desc)
							.attr(&quot;data-nolang&quot;, tpl.noLang ? &quot;1&quot; : &quot;&quot;));
					}
				});

				sel.on(&quot;change&quot;, function () {
					var snippet = $(this).val();
					if (!snippet) return;
					var lang = getValues().lang || &quot;&quot;;
					// Check if the selected option has noLang flag
					var selectedOption = sel.find(&quot;option:selected&quot;);
					var hasNoLang = selectedOption.attr(&quot;data-nolang&quot;) === &quot;1&quot;;
					if (!hasNoLang) {
						snippet = snippet.replace(/CODE/g, lang).replace(/SOURCELANG/g, &quot;?&quot;);
						insertLineSnippet(ta[0], snippet);
						$(this).val(&quot;&quot;);
						// Clear the picker's search box
						sel.trigger(&quot;wiktku:refresh&quot;);
						ta.focus();
						return;
					}
					// The noLang templates (ku-IPA, ku-kîte, zza-IPA, zza-kîte)
					// auto-generate content from a Lua module reading the page
					// title, so show a live preview and require confirmation
					// before inserting.
					var tplLabel = selectedOption.text();
					$(this).val(&quot;&quot;);
					sel.trigger(&quot;wiktku:refresh&quot;);
					steps.pron.showTplPreview(stepDiv, ta, snippet, tplLabel);
				});

				wrap.append(sel).append(ta);
				stepDiv.append(wrap);
				// The palette lives in wikt.edit, shared with DefSideBoxes' own Bilêvkirin box.
				wrap.append(wiktkuUtil.buildIpaPalette({
					insertText: function (text, back) {
						insertAtCursor(ta[0], text);
						if (back) {
							var pos = ta[0].selectionStart - back;
							ta[0].selectionStart = ta[0].selectionEnd = pos;
						}
						ta.focus();
					}
				}));
				initSelects(wrap);
				return ta;
			},

			// ── IPA character palette ji [[MediaWiki:Gadget-charinsert-core.js]]────────────
			// Modelled on fr.wiktionary's: every character is a button that
			// drops itself in at the cursor. Two sub-tabs, because the full
			// IPA chart is ~180 symbols and roughly twenty of them ever
			// appear in Kurmancî — &quot;IPA (kurdî)&quot; opens by default and the
			// full chart is one click away for loanwords and other
			// languages. Grouped with a label down the left so it reads as
			// a chart rather than one long line of glyphs.


			/** Inline preview + confirm panel for a &quot;noLang&quot; (auto-content)
			 *  pronunciation template — fetches what the snippet expands to
			 *  for this page and only inserts it if the user confirms. */
			showTplPreview: function (stepDiv, ta, snippet, tplLabel) {
				// Only one preview panel open at a time.
				stepDiv.find(&quot;.wiktku-pron-preview&quot;).remove();

				var panel = $(&quot;&lt;div class='wiktku-pron-preview'&gt;&lt;/div&gt;&quot;);
				panel.append($(&quot;&lt;div class='wiktku-pron-preview-label'&gt;&lt;/div&gt;&quot;)
					.text(&quot;Pêşdîtina &quot; + tplLabel + &quot;:&quot;));
				var body = $(&quot;&lt;div class='wiktku-pron-preview-body'&gt;&lt;/div&gt;&quot;).text(wiktkuUtil.msg.loading);
				panel.append(body);

				var actions = $(&quot;&lt;div class='wiktku-pron-preview-actions'&gt;&lt;/div&gt;&quot;);
				var confirmBtn = $(&quot;&lt;button type='button' class='wiktku-pron-preview-confirm'&gt;✓ Tevlî bike&lt;/button&gt;&quot;)
					.prop(&quot;disabled&quot;, true);
				var cancelBtn = $(&quot;&lt;button type='button' class='wiktku-pron-preview-cancel'&gt;&lt;/button&gt;&quot;)
					.text(&quot;✕ &quot; + wiktkuUtil.msg.cancel);
				actions.append(confirmBtn).append(cancelBtn);
				panel.append(actions);

				ta.before(panel);

				confirmBtn.on(&quot;click&quot;, function () {
					insertLineSnippet(ta[0], snippet);
					panel.remove();
					ta.focus();
				});
				cancelBtn.on(&quot;click&quot;, function () {
					panel.remove();
				});

				// action=parse, not expandtemplates: the preview needs rendered HTML, not expanded
				// wikitext. The leading &quot;* &quot; is dropped so it renders as a line, not a bulleted list.
				new mw.Api().post({
					action: &quot;parse&quot;,
					title: ctx.pageName,
					text: snippet.replace(/^\*\s*/, &quot;&quot;),
					prop: &quot;text&quot;,
					wrapoutputclass: &quot;&quot;,
					disablelimitreport: 1,
					disableeditsection: 1,
					contentmodel: &quot;wikitext&quot;,
					formatversion: 2
				}).done(function (data) {
					var html = (data &amp;&amp; data.parse &amp;&amp; data.parse.text) || &quot;&quot;;
					if ($.trim($(&quot;&lt;div&gt;&quot;).html(html).text())) {
						body.html(html);
						// Category links render as nothing but still exist;
						// and any real link inside a preview should not
						// navigate away from a half-filled form.
						body.find(&quot;a&quot;).attr(&quot;target&quot;, &quot;_blank&quot;).attr(&quot;rel&quot;, &quot;noopener&quot;);
					} else {
						body.text(&quot;(vala — ji bo vê rûpelê tiştek nehate çêkirin)&quot;);
					}
					confirmBtn.prop(&quot;disabled&quot;, false);
				}).fail(function () {
					body.text(&quot;Pêşdîtin nehate barkirin — tu dikarî hîn jî wê tevlî bikî.&quot;);
					confirmBtn.prop(&quot;disabled&quot;, false);
				});
			},
			output: function () {
				var text = $.trim($(&quot;#wiktku-start-pron .wiktku-pron-text&quot;).val());
				if (!text) return &quot;&quot;;
				var lines = text.split(&quot;\n&quot;);
				var out = $.map(lines, function (line) {
					line = $.trim(line);
					if (!line) return undefined;
					return line;
				}).join(&quot;\n&quot;);
				// &quot;===&quot; heading under Ziman and above the POS sections; the
				// field is shared across sections, so it's emitted once by
				// getWikitext() rather than per-POS-section (would otherwise
				// print the pronunciation twice for a two-POS entry).
				return &quot;\n=== Bilêvkirin ===\n&quot; + out + &quot;\n&quot;;
			} },
		pos: {
			id: &quot;pos&quot;,
			required: true,
			name: &quot;Cureyê rêzimanî&quot;,
			question_fmt: 'Cureyê rêzimanî yê &quot;' + ctx.pageName + '&quot; çi ye?',
			visible: function (values) {
				return values.lang;
			},
			// Populated from posChoices (data-sections.json) and posExamples (data-main.json).
			choices: [],
			// Definition of whichever cureyê rêzimanî is currently chosen,
			// shown as plain text right under the dropdown (see the
			// .wiktku-start-pos-example build/refresh() above). Kept clear of
			// the Mane textarea's placeholder, which answers &quot;what to type
			// here&quot; rather than &quot;what this grammatical category means&quot;.
			posExamples: {},
			example: function (values) {
				var pos = values.pos || &quot;&quot;;
				return steps.pos.posExamples[pos] ||
					&quot;Cureyê rêzimanî yê vê kelîmeyê hilbijêre — navdêr, lêker, rengdêr hwd.&quot;;
			},

			output: function (values) {
				var pos = values.pos || &quot;&quot;;
				var capitalizedPos = capitalize(pos);
				// &quot;form&quot; opt-param (checked in posparams) marks this as a
				// form-of/inflected entry — the section title becomes
				// &quot;Formeke &lt;pos&gt;ê&quot; instead of the plain pos name. The
				// template call itself still uses the unchanged pos name.
				var isForm = $(&quot;#wiktku-start-posparams [data-pp-opt='form']&quot;).is(&quot;:checked&quot;);
				var header = isForm
					? &quot;\n=== Formeke &quot; + pos + &quot;ê ===\n&quot;
					: &quot;\n=== &quot; + capitalizedPos + &quot; ===\n&quot;;

				// Read the live wikitext from the posparams textarea.
				// Fall back to a plain {{pos|lang}} if the step hasn't been built yet.
				var tplLine = $.trim($(&quot;#wiktku-start-posparams .wiktku-posparams-text&quot;).val());
				if (!tplLine) {
					tplLine = &quot;{{&quot; + pos + &quot;|&quot; + (values.lang || &quot;&quot;) + &quot;}}&quot;;
				}

				// {{ku-tewîn-lk}} line for xwerû Kurmancî verbs, parsed straight out of tplLine (not the posparams input fields, which a cache/section restore doesn't repopulate) once niha/borî/transitivity are all present.
				var tewinLkLine = &quot;&quot;;
				if (pos === &quot;lêker&quot; &amp;&amp; values.lang === &quot;ku&quot;) {
					var niha = wiktkuWikitext.callParamValue(tplLine, &quot;niha&quot;);
					var borî = wiktkuWikitext.callParamValue(tplLine, &quot;borî&quot;);
					var lekturCode = wiktkuWikitext.callParamValue(tplLine, &quot;c&quot;);
					var cParts = lekturCode ? /^(?:([xphb])-)?(n?gh)$/.exec(lekturCode) : null;
					var lekturForm = cParts ? (cParts[1] || &quot;&quot;) : &quot;&quot;;
					var lktransitivity = cParts ? cParts[2] : &quot;&quot;;
					var lkForm = lktransitivity === &quot;gh&quot; ? &quot;gerguhêz&quot; : (lktransitivity === &quot;ngh&quot; ? &quot;negerguhêz&quot; : &quot;&quot;);
					if (niha &amp;&amp; borî &amp;&amp; lekturForm === &quot;x&quot; &amp;&amp; lkForm) {
						tewinLkLine = &quot;{{ku-tewîn-lk|&quot; + ctx.pageName + &quot;|form=&quot; + lkForm + &quot;|niha=&quot; + niha + &quot;|borî=&quot; + borî + &quot;}}\n&quot;;
					}
				}

				// Image line (between the conjugation line, if any, and the template call)
				var imageLine = steps.resim.output(values);
				return header + tewinLkLine + imageLine + tplLine + &quot;\n&quot;;
			}

		},

		// cinsiyet (gender) — shown for navdêr/serenav only, with choices built
		// from metadata[lang].g since not every language has grammatical gender.
		cinsiyet: {
			id: &quot;cinsiyet&quot;,
			name: &quot;cinsiyet&quot;,
			question_fmt: 'Cinsiyeta &quot;' + ctx.pageName + '&quot; çi ye?',
			visible: function () { return false; }, // handled inside posparams
			// Single source of truth for the selected gender code. The visible
			// dropdown lives inside the posparams step (see steps.posparams),
			// but it must always read/write THIS hidden field — not a field of
			// its own — since getValuesForStep(&quot;cinsiyet&quot;) reads from here.
			build: function (stepDiv) {
				var field = stepDiv.find(&quot;.wiktku-start-step-field&quot;);
				if (field.length) return field;
				field = $(&quot;&lt;input type='hidden'&gt;&quot;)
					.addClass(&quot;wiktku-start-step-field&quot;)
					.attr(&quot;id&quot;, &quot;wiktku-start-cinsiyet-field&quot;)
					.val(&quot;&quot;);
				stepDiv.append(field);
				return field;
			},
			output: function () { return &quot;&quot;; }  // consumed by posparams/pos.output
		},

		// jimar (grammatical number) — same hidden-field pattern as cinsiyet
		// above, but writes into its own j= template parameter instead of
		// sharing c=. Shown for navdêr/serenav only, with the same choices
		// for every language — data-main.json's numberLabels (see syncHelpers).
		jimar: {
			id: &quot;jimar&quot;,
			name: &quot;jimar&quot;,
			question_fmt: 'Jimara &quot;' + ctx.pageName + '&quot; çi ye?',
			visible: function () { return false; }, // handled inside posparams
			build: function (stepDiv) {
				var field = stepDiv.find(&quot;.wiktku-start-step-field&quot;);
				if (field.length) return field;
				field = $(&quot;&lt;input type='hidden'&gt;&quot;)
					.addClass(&quot;wiktku-start-step-field&quot;)
					.attr(&quot;id&quot;, &quot;wiktku-start-jimar-field&quot;)
					.val(&quot;&quot;);
				stepDiv.append(field);
				return field;
			},
			output: function () { return &quot;&quot;; }  // consumed by posparams/pos.output
		},

		// Lêker transitivity — hidden step, handled inside posparams
		lektur: {
			id: &quot;lektur&quot;,
			name: &quot;Cureyê lêkerê (fiîlê)&quot;,
			question_fmt: &quot;Cureyê lêkerê (fiîlê) çi ye?&quot;,
			visible: function () { return false; },
			output: function () { return &quot;&quot;; }
		},
		// tr — hidden step, handled inside posparams
		tr: {
			id: &quot;tr&quot;,
			name: &quot;transliterasyon&quot;,
			question_fmt: &quot;Transliterasyona vê kelîmeyê&quot;,
			multiple: false,
			narrow: true,
			visible: function () { return false; }
		},

		// The card itself lives in wikt.edit/posparams.js, shared with DefSideBoxes -- see there for the
		// fields and the per-language gating. This is only the wizard's side: which language and part of
		// speech it is for, and mirroring gender/number into the two hidden steps the wizard keeps.
		posparams: {
			id: &quot;posparams&quot;,
			// Fused onto the &quot;pos&quot; card in styles.css so the two read as one question. The &quot;xisûsiyet&quot;
			// name is a no-CSS fallback: its h3 is hidden, and every field below is self-labelled.
			name: &quot;xisûsiyet&quot;,
			question_fmt: &quot;&quot;,
			card: null,
			visible: function (values) {
				return !!(values.lang &amp;&amp; values.pos);
			},

			build: function (stepDiv) {
				if (stepDiv.find(&quot;.wiktku-posparams-step&quot;).length) return null;
				var values = getValues();
				steps.posparams.card = wiktkuPosparams.build({
					lang: values.lang,
					pos: values.pos,
					onChange: refresh,
					// steps.cinsiyet/steps.jimar own these hidden fields; the card reports rather than
					// writes, so it needs no knowledge of them.
					onSync: function (cinsiyet, jimar) {
						$(&quot;#wiktku-start-cinsiyet-field&quot;).val(cinsiyet || &quot;&quot;);
						$(&quot;#wiktku-start-jimar-field&quot;).val(jimar || &quot;&quot;);
					}
				});
				stepDiv.append(steps.posparams.card.$element);
				return null;
			},

			rebuildTa: function () {
				if (steps.posparams.card) steps.posparams.card.rebuild();
			},

			/** Called from refresh() — re-gates every row for the current language/pos. */
			syncHelpers: function () {
				if (!steps.posparams.card) return;
				var values = getValues();
				steps.posparams.card.setContext(values.lang, values.pos);
			},

			output: function () { return &quot;&quot;; } // pos.output reads the textarea directly
		},
		dfn: {
			id: &quot;dfn&quot;,
			name: &quot;Mane&quot;,
			question_fmt: function (values) {
				var base = &quot;Maneya kelîmeyê binivîse. Mane otomatîk tê lînkkirin!&quot;;
				if (values.lang === &quot;ku&quot;) {
					return base + &quot; Ji bo tercimeyan beşa 'Werger' bi kar bîne!&quot;;
				}
				return base;
			},
			multiple: true,
			ordered: true,
			rows: 3,
			visible: function (values) {
				return values.lang &amp;&amp; values.pos;
			},

			// Builds one sense block (&lt;li&gt;): mane textarea, nimûne list, and
			// sub-lists for alternatîv/hevmane/dijmane/etc.
			buildSenseBlock: function () {
				var block = $(&quot;&lt;li class='wiktku-dfn-sense'&gt;&lt;/li&gt;&quot;);

				// — Mane textarea (declared first so the template handler can reference it) —
				var dfnArea = $(&quot;&lt;textarea&gt;&lt;/textarea&gt;&quot;)
					.attr(&quot;name&quot;, &quot;wiktku-dfn-mane-&quot; + $.now() + &quot;-&quot; + Math.random().toString(36).substr(2, 9))
					.attr(&quot;class&quot;, &quot;wiktku-start-step-field wiktku-dfn-mane&quot;)
					.attr(&quot;rows&quot;, 6)
					.attr(&quot;placeholder&quot;, &quot;Maneya vê kelîmeyê binivîse…&quot;);
				// Nothing on keystrokes: only the Werger gloss list needs a live Mane edit, and rebuilding
				// it re-reads every sense. Deferred to blur; the wikitext is read fresh on output anyway.
				dfnArea.on(&quot;blur&quot;, function () { refresh(); });

				// — Îzaha maneyî (optional second half of the mane) —
				// A non-Kurdish entry's gloss is a translation followed by {{îzah|…}} explaining it. The
				// mane box is always the mane box and the explanation opens under it when asked for, so
				// the pair reads as one gloss rather than as a different kind of field. getSenses() joins
				// the two back together, so every consumer downstream sees one gloss string.
				var izahArea = $(&quot;&lt;textarea&gt;&lt;/textarea&gt;&quot;)
					.attr(&quot;name&quot;, &quot;wiktku-dfn-izah-&quot; + $.now() + &quot;-&quot; + Math.random().toString(36).substr(2, 9))
					.attr(&quot;class&quot;, &quot;wiktku-dfn-subfield wiktku-dfn-izah&quot;)
					.attr(&quot;rows&quot;, 2)
					.attr(&quot;placeholder&quot;, &quot;Îzaha maneyî… Ji bo school-a îngilîzî li vir 'cihê tehsîlgirtinê' binivîse&quot;);

				var izahWrap = $(&quot;&lt;div class='wiktku-dfn-izah-wrap'&gt;&lt;/div&gt;&quot;)
					.append($(&quot;&lt;span class='wiktku-dfn-sublabel'&gt;&lt;/span&gt;&quot;)
						.append($(&quot;&lt;span class='wiktku-dfn-sublabel-term'&gt;&lt;/span&gt;&quot;).text(&quot;Îzaha maneyî&quot;)).append(&quot;: &quot;))
					.append(izahArea)
					.hide();


				// Opening it from a restore, where the text decides rather than a click.
				var izahOpen = false;
				function setIzahOpen(open) {
					izahOpen = !!open;
					updateManeMode();
				}
				block.data(&quot;setIzahOpen&quot;, setIzahOpen);

				izahArea.on(&quot;input&quot;, function () {
					// dfnArea drives the live preview and the auto-linker; the îzah is part of the gloss,
					// so a change to it has to reach them too.
					dfnArea.trigger(&quot;input&quot;);
				});
				izahArea.on(&quot;blur&quot;, function () { refresh(); });

				// The mane box gives way to the template title box when a template is chosen; the îzah
				// goes with it, since a template gloss has no separate explanation.
				function updateManeMode() {
					var isTpl = !!tplSelect.val();
					if (isTpl) {
						dfnArea.hide();
						izahWrap.hide();
						return;
					}
					dfnArea.show();
					dfnArea.attr(&quot;placeholder&quot;, manePlaceholder(getValues().lang || &quot;&quot;));
					// {{îzah}} explains a translation, so it belongs to entries in another language; a
					// Kurdish sense is its own definition and is not offered one. A box that already holds
					// text stays on screen whatever the language -- getSenses() joins it into the gloss
					// either way, and hiding it would make that happen unseen.
					var lang = getValues().lang || &quot;&quot;;
					var offer = !!lang &amp;&amp; lang !== &quot;ku&quot;;
					// A non-Kurdish gloss is a translation and its explanation, so the box opens with the
					// mane box rather than waiting to be asked for.
					var open = offer || izahOpen || $.trim(izahArea.val()) !== &quot;&quot;;
					izahWrap.toggle(open);
				}
				// Store on the block so refresh() can re-sync every block when
				// lang changes, and restoreDfn() can re-sync after restoring.
				block.data(&quot;updateManeMode&quot;, updateManeMode);

				// — Template selector (optional — replaces mane when chosen) —
				// Template definitions loaded from data-main.json.
				var tplDefs = steps.dfn.tplDefs || {};
				// Cache of all non-placeholder option elements, so updateTplOptions
				// can detach/re-attach them without losing the full list.
				var _allTplOptions = [];

				var tplSelect = $(mw.html.element(&quot;select&quot;, { &quot;class&quot;: &quot;wiktku-dfn-tpl-select&quot; }));
				tplSelect.attr(&quot;data-placeholder&quot;, wiktkuUtil.msg.searchTemplate);
				tplSelect.append($(&quot;&lt;option value=''&gt;— yan jî şablonek hilbijêre —&lt;/option&gt;&quot;));
				$.each(tplDefs, function (name, tpl) {
					// Shows &quot;name — tpl.desc&quot; when a tplDefs entry has a desc
					// in data-main.json, same pattern as steps.pron's template picker.
					var opt = $(&quot;&lt;option&gt;&lt;/option&gt;&quot;)
						.val(name)
						.text(tpl.desc ? name + &quot; — &quot; + tpl.desc : name)
						.attr(&quot;data-langs&quot;, tpl.langs ? tpl.langs.join(&quot;,&quot;) : &quot;&quot;)
						.attr(&quot;data-nolang&quot;, tpl.noLang ? &quot;1&quot; : &quot;&quot;);
					tplSelect.append(opt);
					_allTplOptions.push(opt[0]);
				});
				// Same status-dot / 🔗 / ⓘ row treatment as every other
				// template picker. This one carries the bare name in value=,
				// so the name mapper is the identity rather than a snippet
				// parse; descriptions come from each template's TemplateData.
				markTemplateOptions(tplSelect, function (opt) { return opt.val(); });

				function updateTplOptions() {
					var lang = getValues().lang || &quot;&quot;;
					var currentVal = tplSelect.val();
					var currentStillValid = false;

					// Detach all non-placeholder options, then re-attach only the visible
					// ones — native &lt;select&gt; won't reliably hide options any other way.
					tplSelect.find(&quot;option[value!='']&quot;).detach();

					$.each(_allTplOptions, function (_, opt) {
						var allowed = $(opt).attr(&quot;data-langs&quot;);
						var visible = !allowed || allowed.split(&quot;,&quot;).indexOf(lang) !== -1;
						if (visible) {
							tplSelect.append(opt);
							if ($(opt).val() === currentVal) currentStillValid = true;
						}
					});

					// Options that were detached when the descriptions arrived
					// missed that pass, so describe whatever is attached now.
					// The cache is warm by this point, so this is synchronous.
					applyTplDescriptions(tplSelect);

					tplSelect.trigger(&quot;wiktku:refresh&quot;);

					if (currentVal &amp;&amp; !currentStillValid) {
						tplSelect.val(&quot;&quot;);
						tplTitleInput.hide().val(&quot;&quot;);
						updateManeMode();
					}
				}

				// Store updater on the element so refresh() can call it for all blocks.
				tplSelect.data(&quot;updateOptions&quot;, updateTplOptions);

				var tplTitleInput = $(&quot;&lt;input type='text'&gt;&quot;)
					.addClass(&quot;wiktku-dfn-tpl-title wiktku-start-narrow&quot;)
					.attr(&quot;placeholder&quot;, &quot;Navê rûpela hedefê…&quot;)
					.hide();

				// Same reasoning as dfnArea above: refresh() (which rebuilds the
				// Werger/Bi zaravayên din gloss list) is deferred to blur
				// rather than run on every keystroke.
				tplTitleInput.on(&quot;blur&quot;, function () { refresh(); });

				// Şablon senses have no plain gloss, so the word-list groups (hevmane, dijmane, formên
				// alternatîv…) make no sense for them — the class hides both those groups and their
				// entries in the &quot;Hevmane û Bêhtir&quot; menu, so they cannot be asked for either. Etîket, Kategorî,
				// Nimûne and Jêgirtin stay available.
				function updateFieldVisibility() {
					block.toggleClass(&quot;wiktku-sense-is-tpl&quot;, !!tplSelect.val());
				}
				// Store on the block so restoreDfn() can re-sync visibility
				// after setting tplSelect's value.
				block.data(&quot;updateFieldVisibility&quot;, updateFieldVisibility);

				tplSelect.on(&quot;change&quot;, function () {
					var chosen = $(this).val();
					if (chosen) {
						dfnArea.hide();
						izahWrap.hide();
						tplTitleInput.show().focus();
					} else {
						tplTitleInput.hide().val(&quot;&quot;);
						updateManeMode();
					}
					updateFieldVisibility();
					// Re-run refresh so the Werger step visibility updates.
					refresh();
				});

				// The template picker is an alternative to writing a
				// definition, so this quiet link sits above the Mane box
				// rather than getting buried under Dever/Etîket/Kategorî.
				// It only expands for the minority of senses that are a
				// pointer at another word (guharto, şaşnivîs, kevnbûyî)
				// rather than a meaning.
				var tplRow = $(&quot;&lt;div&gt;&lt;/div&gt;&quot;).addClass(&quot;wiktku-dfn-tpl-row&quot;)
					.append(tplSelect).append(&quot; &quot;).append(tplTitleInput)
					.hide();
				var tplLink = $(&quot;&lt;a href='#' class='wiktku-dfn-tpl-link'&gt;&lt;/a&gt;&quot;)
					.text(&quot;Maneyê bi şablonan çêke (rastnivîs, şaşnivîs, awayekî din)&quot;);
				tplLink.on(&quot;click&quot;, function (e) {
					e.preventDefault();
					tplRow.show();
					$(this).hide();
					tplRow.find(&quot;input.wiktku-ac-input&quot;).first().focus();
				});
				/** Opens the picker without a click — used on restore, when a
				 *  sense already has a template and hiding it would make the
				 *  chosen value invisible. */
				function revealTplRow() { tplRow.show(); tplLink.hide(); }
				block.data(&quot;revealTplRow&quot;, revealTplRow);

				// Dever/Şîwe, Etîket and Kategorî as chip+toggle fields, so a sense that leaves them empty
				// stays short. getOutput() folds Dever/Şîwe into {{dever|}} for ku, {{e|}} otherwise.
				// Each closes the other two on open; onOpen runs from a click, so forward references hold.
				var deverField = buildChipField({
					wrapCls: &quot;wiktku-dfn-dever&quot;,
					toggleLabel: &quot;+ Dever/Şîwe&quot;,
					hint: &quot;Bi vê maneyê li kû derê an di kîjan devokê de tê bikaranîn?&quot;,
					// Kurmancî's pills are the handful in data-main.json; another language gets the regions
					// Modul:labels tags for it. The rest are found by typing.
					quickPicks: function () {
						var lang = getValues().lang || &quot;ku&quot;;
						if (lang === &quot;ku&quot;) return ctx.DEVER_QUICK_PICKS;
						return ctx.wiktkuLabelSets ? wiktkuEdit.labels.taggedRegionsFor(ctx.wiktkuLabelSets, lang) : [];
					},
					suggestions: function () { return wiktkuLabelSuggestions(&quot;dever&quot;); },
					onOpen: function () { etiketField.close(); kategoriField.close(); wiktkuEnsureLabels(); }
				});
				block.data(&quot;addDeverChip&quot;, deverField.addChip);

				var etiketField = buildChipField({
					wrapCls: &quot;wiktku-dfn-etiket&quot;,
					toggleLabel: &quot;+ Etîket&quot;,
					hint: &quot;xisûsen, Mêrdîn, anatomî, Badînî&quot;,
					suggestions: function () { return wiktkuLabelSuggestions(&quot;etiket&quot;); },
					onOpen: function () { deverField.close(); kategoriField.close(); wiktkuEnsureLabels(); }
				});
				block.data(&quot;addEtiketChip&quot;, etiketField.addChip);

				var kategoriField = buildChipField({
					wrapCls: &quot;wiktku-dfn-kategori&quot;,
					toggleLabel: &quot;+ Kategorî&quot;,
					hint: &quot;wekî etîket lê xuya nabe tenê kategorîze dike&quot;,
					suggestions: function () { return wiktkuLabelSuggestions(&quot;kategori&quot;); },
					onOpen: function () { deverField.close(); etiketField.close(); wiktkuEnsureLabels(); }
				});
				block.data(&quot;addKategoriChip&quot;, kategoriField.addChip);

				// Maneid -- the anchor another entry links a sense by, written &quot;{{maneid|lang|x}}&quot; at the
				// head of the line. One value rather than a list, so it is a plain box and not a chip
				// field; it still behaves like one to the &quot;Hevmane û Bêhtir&quot; menu through the small api below.
				var maneidInput = $(&quot;&lt;input type='text'&gt;&quot;)
					.addClass(&quot;wiktku-dfn-maneid-input wiktku-start-narrow&quot;)
					.attr(&quot;placeholder&quot;, &quot;id&quot;);
				var maneidWrap = $(&quot;&lt;div class='wiktku-dfn-chipfield-wrap wiktku-dfn-maneid-wrap'&gt;&lt;/div&gt;&quot;)
					.append($(&quot;&lt;label class='wiktku-dfn-maneid-label'&gt;&lt;/label&gt;&quot;)
						.text(&quot;Maneid &quot;)
						.append(maneidInput))
					.hide();
				var maneidField = {
					wrap: maneidWrap,
					open: function () { maneidWrap.show(); maneidInput.focus(); },
					values: function () {
						var v = $.trim(maneidInput.val() || &quot;&quot;);
						return v ? [v] : [];
					}
				};

				// Dever/Şîwe starts open for ku (where it's the common case)
				// and closed otherwise; backs off once the person toggles it
				// themselves (see buildChipField's setOpenDefault). Re-synced
				// from refresh() whenever lang changes — see block.data below.
				//
				// Shown only for a language with regions: every Kurdish variety, and any other language
				// Modul:labels tags one for (read once the labels arrive). One that already has a value stays.
				function updateDeverOpenState() {
					var lang = getValues().lang || &quot;&quot;;
					var hasRegions = !lang || wiktkuEdit.labels.isKurdish(lang) ||
						(ctx.wiktkuLabelSets &amp;&amp; wiktkuEdit.labels.regionalFor(ctx.wiktkuLabelSets, lang).length &gt; 0);
					if (!hasRegions &amp;&amp; !ctx.wiktkuLabelSets) wiktkuEnsureLabels();
					var show = hasRegions || deverField.values().length &gt; 0;
					deverField.wrap.toggle(show);
					if (!show) deverField.panel.hide();
					deverField.setOpenDefault(lang === &quot;ku&quot;);
				}
				block.data(&quot;updateDeverOpenState&quot;, updateDeverOpenState);
				wiktkuLabelListeners.push(updateDeverOpenState);
				updateDeverOpenState();

				// Toggles always sit together in one row; panels render in their
				// own area below so opening one never displaces the others.
				// The widget is still built on a reconstruction page so every reference to it stays valid;
				// it just never reaches the DOM, so it shows nothing and contributes nothing to getOutput().
				//
				// The row is the same shape DefSideBoxes puts under a sense -- a few chips for the common
				// things, everything else behind &quot;Hevmane û Bêhtir&quot; -- so the two gadgets are learned once. Etîket
				// and Kategorî start in the menu and their toggle only joins the row once picked.
				var chipFieldRow = $(&quot;&lt;div class='wiktku-dfn-chipfield-row'&gt;&lt;/div&gt;&quot;);
				var chipFieldPanels = $(&quot;&lt;div class='wiktku-dfn-chipfield-panels'&gt;&lt;/div&gt;&quot;);
				if (!isReconstruction) {
					chipFieldRow.append(deverField.wrap);
					chipFieldPanels.append(deverField.panel);
				}
				etiketField.wrap.hide();
				kategoriField.wrap.hide();
				chipFieldRow.append(etiketField.wrap).append(kategoriField.wrap).append(maneidWrap);
				chipFieldPanels.append(etiketField.panel).append(kategoriField.panel);

				block.append(tplLink);
				block.append(tplRow);
				block.append(dfnArea);
				block.append(izahWrap);
				block.append(chipFieldRow);
				block.append(chipFieldPanels);

				// Apply lang filter on initial build.
				updateTplOptions();
				updateManeMode();

				// Sub-field groups. Every one of them is built hidden and asked for by name -- from a chip
				// in the row above (Nimûne, Jêgirtin) or from the &quot;Hevmane û Bêhtir&quot; menu -- so a sense that needs
				// none of them is four boxes tall instead of ten. Jêgirtin is built after the loop as a
				// compound widget and inserted after Nimûne, so the visible order matches this list.
				var allGroups = [
					{ cls: &quot;wiktku-dfn-nimune&quot;, label: &quot;Nimûne&quot;, rows: 2, narrow: false, attested: true }
				].concat($.map(wordGroups(), function (g) {
					return { cls: g.cls, label: g.label, rows: 1, narrow: true, izah: g.izah };
				}));

				if (isReconstruction) {
					allGroups = $.grep(allGroups, function (g) { return !g.attested; });
				}

				$.each(allGroups, function (_, g) {
					// wiktku-dfn-wordgroup marks the six word lists, which a şablon sense hides -- both the
					// group and its entry in the menu (see the .wiktku-sense-is-tpl rules).
					var groupDiv = $(&quot;&lt;div&gt;&lt;/div&gt;&quot;).addClass(&quot;wiktku-dfn-subgroup wiktku-dfn-subgroup-hidden &quot; + g.cls + &quot;-group&quot;);
					if (g.cls !== &quot;wiktku-dfn-nimune&quot;) groupDiv.addClass(&quot;wiktku-dfn-wordgroup&quot;);

					// Declared once here rather than with `var` in each branch
					// below — both branches assign the same pair, just with a
					// different lbl and list, so one declaration avoids the
					// (harmless but lint-flagged) re-declaration.
					var lbl, list;

						// The language the example is to be written in, named in the box itself. Read fresh
						// rather than fixed at build time: the entry's language is often chosen later.
						function nimunePlaceholder() {
							var code = getValues().lang || &quot;&quot;;
							return wiktkuUtil.examplePrompt(code &amp;&amp; getLangLabel(code), false);
						}

						function buildNimuneLi() {
							var lang = getValues().lang || &quot;&quot;;
							var li = $(&quot;&lt;li&gt;&lt;/li&gt;&quot;).addClass(&quot;wiktku-dfn-nimune-li&quot;);

							var mainTa = $(&quot;&lt;textarea&gt;&lt;/textarea&gt;&quot;)
								.attr(&quot;name&quot;, &quot;wiktku-dfn-nimune-text-&quot; + $.now() + &quot;-&quot; + Math.random().toString(36).substr(2, 9))
								.attr(&quot;rows&quot;, g.rows)
								.attr(&quot;class&quot;, &quot;wiktku-dfn-subfield wiktku-dfn-nimune-text&quot;)
								.attr(&quot;placeholder&quot;, nimunePlaceholder());

							mainTa.on(&quot;input&quot;, function () {
								highlightLinebreak(this);
								var val = $.trim($(this).val());
								var isLast = li.is(list.children(&quot;li:last-child&quot;));
								if (val &amp;&amp; isLast) {
									list.append(buildNimuneLi());
								}
							});

							li.append(mainTa);

							var subWrap = $(&quot;&lt;div&gt;&lt;/div&gt;&quot;).addClass(&quot;wiktku-dfn-nimune-sub&quot;);

							if (needsTransliteration(lang)) {
								subWrap.append(
									$(&quot;&lt;textarea&gt;&lt;/textarea&gt;&quot;)
										.attr(&quot;name&quot;, &quot;wiktku-dfn-nimune-tr-&quot; + $.now() + &quot;-&quot; + Math.random().toString(36).substr(2, 9))
										.attr(&quot;rows&quot;, 5)
										.attr(&quot;class&quot;, &quot;wiktku-dfn-subfield wiktku-dfn-nimune-tr&quot;)
										.attr(&quot;placeholder&quot;, &quot;Transliterasyona bi alfabeya latînî&quot;)
								);
							}

							if (lang) {
								subWrap.append(
									$(&quot;&lt;textarea&gt;&lt;/textarea&gt;&quot;)
										.attr(&quot;name&quot;, &quot;wiktku-dfn-nimune-t-&quot; + $.now() + &quot;-&quot; + Math.random().toString(36).substr(2, 9))
										.attr(&quot;rows&quot;, 5)
										.attr(&quot;class&quot;, &quot;wiktku-dfn-subfield wiktku-dfn-nimune-t&quot;)
										.attr(&quot;placeholder&quot;, nimuneTranslationPrompt(lang))
								);
							}

							if (subWrap.children().length) li.append(subWrap);

							return li;
						}

						// The placeholder names the current language, but that's
						// often not chosen yet when this block is first built —
						// so keep a function around that refresh() (and onSubInput,
						// for newly-grown fields) can call again once lang is set
						// or changes.
						function subPlaceholder() {
							if (g.noLangSuffix) return g.label + &quot;…&quot;;
							var lang = getValues().lang || &quot;&quot;;
							var langLabel = lang ? getLangLabel(lang) : &quot;&quot;;
							return g.label + (langLabel ? &quot; bi &quot; + langLabel : &quot;&quot;) + &quot;…&quot;;
						}
						function updateSubPlaceholders() {
							list.find(&quot;&gt; li &gt; textarea.wiktku-dfn-subfield&quot;).attr(&quot;placeholder&quot;, subPlaceholder());
						}
					if (g.cls === &quot;wiktku-dfn-nimune&quot;) {
						// Nimûne — compound widget with tr/t sub-fields.
						lbl = $(&quot;&lt;span&gt;&lt;/span&gt;&quot;).addClass(&quot;wiktku-dfn-sublabel&quot;)
							.append($(&quot;&lt;span&gt;&lt;/span&gt;&quot;).addClass(&quot;wiktku-dfn-sublabel-term&quot;).text(g.label))
							.append(&quot;: &quot;);
						list = $(&quot;&lt;ol&gt;&lt;/ol&gt;&quot;).addClass(&quot;wiktku-dfn-sublist &quot; + g.cls + &quot;-list&quot;);

						groupDiv.data(&quot;buildNimuneLi&quot;, buildNimuneLi);
						// Refreshed with the word groups' own boxes when the entry's language changes.
						list.data(&quot;updatePlaceholders&quot;, function () {
							list.find(&quot;&gt; li &gt; textarea.wiktku-dfn-nimune-text&quot;)
								.attr(&quot;placeholder&quot;, nimunePlaceholder());
						});

						list.append(buildNimuneLi());
						groupDiv.append(lbl).append(list);
						block.append(groupDiv);

					} else {
						// Regular always-visible group — label + growing textarea list.
						lbl = $(&quot;&lt;span&gt;&lt;/span&gt;&quot;).addClass(&quot;wiktku-dfn-sublabel&quot;)
							.append($(&quot;&lt;span&gt;&lt;/span&gt;&quot;).addClass(&quot;wiktku-dfn-sublabel-term&quot;).text(g.label))
							.append(&quot;: &quot;)
							.append($(&quot;&lt;span&gt;&lt;/span&gt;&quot;).addClass(&quot;wiktku-dfn-sublabel-hint&quot;).text(g.izah));
						var useModifiers = isWordGroupCls(g.cls);
						list = $(&quot;&lt;ol&gt;&lt;/ol&gt;&quot;).addClass(&quot;wiktku-dfn-sublist &quot; + g.cls + &quot;-list&quot;);

						list.data(&quot;updatePlaceholders&quot;, updateSubPlaceholders);

						var firstInput = $(&quot;&lt;textarea&gt;&lt;/textarea&gt;&quot;)
							.attr(&quot;name&quot;, g.cls + &quot;-&quot; + $.now() + &quot;-&quot; + Math.random().toString(36).substr(2, 9))
							.attr(&quot;rows&quot;, g.rows)
							.attr(&quot;class&quot;, &quot;wiktku-dfn-subfield&quot; + (g.narrow ? &quot; wiktku-start-narrow&quot; : &quot;&quot;))
							.attr(&quot;placeholder&quot;, subPlaceholder());
						firstInput.on(&quot;input&quot;, function () {
							steps.dfn.onSubInput(list, this, g.rows, g.narrow, useModifiers);
						});
						list.append(useModifiers ? makeModifierLi(firstInput) : $(&quot;&lt;li&gt;&lt;/li&gt;&quot;).append(firstInput));
						groupDiv.append(lbl).append(list);
						block.append(groupDiv);
					}
				});

				// — Jêder group — growing list, same structure as Nimûne. —
				if (!isReconstruction) (function () {
					var jederGroupDiv = $(&quot;&lt;div&gt;&lt;/div&gt;&quot;).addClass(&quot;wiktku-dfn-subgroup wiktku-dfn-subgroup-hidden wiktku-dfn-jeder-group&quot;);
					var jederLbl = $(&quot;&lt;span&gt;&lt;/span&gt;&quot;).addClass(&quot;wiktku-dfn-sublabel&quot;)
						.append($(&quot;&lt;span&gt;&lt;/span&gt;&quot;).addClass(&quot;wiktku-dfn-sublabel-term&quot;).text(&quot;Jêgirtin&quot;))
						.append(&quot;: &quot;);
					var jederList = $(&quot;&lt;ol&gt;&lt;/ol&gt;&quot;).addClass(&quot;wiktku-dfn-sublist wiktku-dfn-jeder-list&quot;);
					// Refreshed with every other sub-box when the entry's language changes.
					jederList.data(&quot;updatePlaceholders&quot;, function () {
						jederList.find(&quot;&gt; li &gt; textarea.wiktku-dfn-nimune-quote&quot;)
							.attr(&quot;placeholder&quot;, jederPlaceholder());
					});

					// Same shape as the nimûne box: the language belongs in the prompt, and is read fresh
					// because the entry's language is often chosen after the block was built.
					function jederPlaceholder() {
						var code = getValues().lang || &quot;&quot;;
						return wiktkuUtil.examplePrompt(code &amp;&amp; getLangLabel(code), true);
					}

					function buildJederLi() {
						var lang = getValues().lang || &quot;&quot;;
						var li = $(&quot;&lt;li&gt;&lt;/li&gt;&quot;).addClass(&quot;wiktku-dfn-jeder-li&quot;);

						// Quote text textarea
						var quoteTa = $(&quot;&lt;textarea&gt;&lt;/textarea&gt;&quot;)
							.attr(&quot;name&quot;, &quot;wiktku-dfn-nimune-quote-&quot; + $.now() + &quot;-&quot; + Math.random().toString(36).substr(2, 9))
							.attr(&quot;rows&quot;, 2)
							.attr(&quot;class&quot;, &quot;wiktku-dfn-subfield wiktku-dfn-nimune-quote&quot;)
							.attr(&quot;placeholder&quot;, jederPlaceholder());

						quoteTa.on(&quot;input&quot;, function () {
							highlightLinebreak(this);
							var val = $.trim($(this).val());
							var isLast = li.is(jederList.children(&quot;li:last-child&quot;));
							if (val &amp;&amp; isLast) {
								jederList.append(buildJederLi());
							}
						});

						li.append(quoteTa);

						// tr/t sub-fields for the quote — shown as needed for the language.
						var quoteSubWrap = $(&quot;&lt;div&gt;&lt;/div&gt;&quot;).addClass(&quot;wiktku-dfn-quote-sub&quot;);

						if (needsTransliteration(lang)) {
							quoteSubWrap.append(
								$(&quot;&lt;textarea&gt;&lt;/textarea&gt;&quot;)
									.attr(&quot;name&quot;, &quot;wiktku-dfn-nimune-quote-tr-&quot; + $.now() + &quot;-&quot; + Math.random().toString(36).substr(2, 9))
									.attr(&quot;rows&quot;, 2)
									.attr(&quot;class&quot;, &quot;wiktku-dfn-subfield wiktku-dfn-nimune-quote-tr&quot;)
									.attr(&quot;placeholder&quot;, &quot;Transliterasyona jêgirtinê…&quot;)
							);
						}

						if (lang &amp;&amp; lang !== &quot;ku&quot;) {
							quoteSubWrap.append(
								$(&quot;&lt;textarea&gt;&lt;/textarea&gt;&quot;)
									.attr(&quot;name&quot;, &quot;wiktku-dfn-nimune-quote-t-&quot; + $.now() + &quot;-&quot; + Math.random().toString(36).substr(2, 9))
									.attr(&quot;rows&quot;, 2)
									.attr(&quot;class&quot;, &quot;wiktku-dfn-subfield wiktku-dfn-nimune-quote-t&quot;)
									.attr(&quot;placeholder&quot;, &quot;Tercimeya jêgirtinê bi kurmancî&quot;)
							);
						}

						if (quoteSubWrap.children().length) li.append(quoteSubWrap);

						// The source, in the add-examples form's order and wording: the template, then the link
						// with its Citoid button, then the template's own fields.
						var jederDefs = steps.dfn.jederDefs || {};
						var srcSel = $(&quot;&lt;select&gt;&lt;/select&gt;&quot;).addClass(&quot;wiktku-dfn-quote-src-sel wiktku-plain-select&quot;);
						// &quot;&quot; is auto-detect: a Citoid fetch picks the template.
						srcSel.append($(&quot;&lt;option value=''&gt;&lt;/option&gt;&quot;).text(wiktkuUtil.msg.citoidAuto));
						srcSel.append($(&quot;&lt;option&gt;&lt;/option&gt;&quot;).val(&quot;__manual__&quot;).text(wiktkuUtil.msg.sourceByHand));
						$.each(jederDefs, function (tplName, def) {
							srcSel.append($(&quot;&lt;option&gt;&lt;/option&gt;&quot;).val(tplName).text(def.label));
						});
						srcSel.append($(&quot;&lt;option&gt;&lt;/option&gt;&quot;).val(&quot;__category__&quot;).text(wiktkuUtil.msg.sourceFromCategory));
						// Paste a citation built on another page into the quote box and have it saved exactly
						// as typed -- the quickest way to reuse one jêgirtin across many entries.
						srcSel.append($(&quot;&lt;option&gt;&lt;/option&gt;&quot;).val(&quot;__raw__&quot;).text(wiktkuUtil.msg.sourceRaw));
						var srcSelWrap = $(&quot;&lt;div&gt;&lt;/div&gt;&quot;).addClass(&quot;wiktku-dfn-quote-field&quot;)
							.append($(&quot;&lt;label&gt;&lt;/label&gt;&quot;).text(&quot;Şablona çavkaniyê&quot;), srcSel);

						// Saved as url= in every mode but Kategorî and raw, which have no box for it.
						var urlLbl = $(&quot;&lt;label&gt;&lt;/label&gt;&quot;);
						var urlInput = $(&quot;&lt;input type='text'&gt;&quot;).addClass(&quot;wiktku-dfn-quote-url&quot;);
						var citoidBtn = new OO.ui.ButtonWidget({
							label: wiktkuUtil.msg.citoidFill,
							classes: [ &quot;wiktku-dfn-quote-citoid-btn&quot;, &quot;wiktku-add-sense-btn&quot; ]
						});
						var citoidStatus = $(&quot;&lt;span&gt;&lt;/span&gt;&quot;).addClass(&quot;wiktku-dfn-quote-citoid-status&quot;);
						var urlHint = $(&quot;&lt;p&gt;&lt;/p&gt;&quot;).addClass(&quot;wiktku-step-hint wiktku-dfn-quote-url-hint&quot;);
						var citoidWrap = $(&quot;&lt;div&gt;&lt;/div&gt;&quot;).addClass(&quot;wiktku-dfn-quote-field wiktku-dfn-quote-citoid&quot;)
							.append(urlLbl, urlInput, citoidBtn.$element, citoidStatus, urlHint);

						// The add-examples form's labels: plain &quot;attach a link&quot; wording for a hand-written
						// source, Citoid wording otherwise.
						function setUrlWording(chosen) {
							if (chosen === &quot;__manual__&quot;) {
								urlLbl.text(&quot;Adresa webê ya nimûneyê&quot;);
								urlInput.attr(&quot;placeholder&quot;, &quot;URLyeke wekî https://…&quot;);
								urlHint.text(&quot;Tenê binivîse eger lînk jixwe di referansa çavkaniyê de tinebe.&quot;);
							} else {
								urlLbl.text(&quot;Lînk, DOI an ISBNya çavkaniyê&quot;);
								urlInput.attr(&quot;placeholder&quot;, &quot;URLyek wekî https://… an jî DOI/ISBN&quot;);
								urlHint.text(chosen
									? &quot;Ev dibe lînka çavkaniyê (url=). Ji bo şablonên jêder-*, dikare bi Citoid an bi destan jî bên dagirtin.&quot;
									: &quot;Li qutiyê URL, DOI an ISBN binivîse û pê lê bike butona '&quot; + wiktkuUtil.msg.citoidFill + &quot;' da ku otomatîk çavkanî were dagirtin.&quot;);
							}
						}
						setUrlWording(&quot;&quot;);

						// Fills only empty boxes, so a repeat fetch never overwrites what was typed by hand.
						function fillEmptyFields(fields) {
							$.each(fields, function (key, val) {
								var input = srcFields.find(&quot;[data-field-key='&quot; + key + &quot;']&quot;);
								if (input.length &amp;&amp; !$.trim(input.val())) {
									input.val(val);
								}
							});
						}

						// Prefills Dem from the link's own &quot;t=&quot; once jêder-vîdeo is active.
						function autofillVideoTimestamp() {
							var citoid = window.wikt &amp;&amp; window.wikt.citoid;
							var dem = srcFields.find(&quot;[data-field-key='dem']&quot;);
							if (srcSel.val() !== &quot;jêder-vîdeo&quot; || !dem.length || $.trim(dem.val()) ||
								!(citoid &amp;&amp; citoid.extractVideoTimestamp)) {
								return;
							}
							var t = citoid.extractVideoTimestamp($.trim(urlInput.val()));
							if (t) dem.val(t);
						}

						function runCitoidFetch() {
							var query = $.trim(urlInput.val());
							if (!query) {
								mw.notify(wiktkuUtil.msg.citoidNeedsUrl);
								return;
							}

							citoidBtn.setDisabled(true);
							citoidStatus.text(&quot;Tê barkirin…&quot;);

							// Through wikt.cite rather than straight to the citoid gadget: the wrapper adds what
							// Citoid returns but citoid-helper's mapping drops -- the access date, the ISSN and
							// the DOI.
							wiktkuCite.fetchFromCitoid(query).then(function (result) {
								// Citoid picks the template only while none is chosen; a hand-picked one is kept.
								var current = srcSel.val();
								if (!current &amp;&amp; jederDefs[result.jederKey]) {
									srcSel.val(result.jederKey).trigger(&quot;change&quot;);
									current = result.jederKey;
								}
								if (jederDefs[current]) {
									// Citoid shaped its fields for the type it detected; re-derived for another.
									fillEmptyFields(current === result.jederKey ? result.fields
										: wiktkuCite.citoidFieldsFor(current, result.raw, query));
									autofillVideoTimestamp();
								} else {
									// No template for this kind of source: a hand-written source line from what
									// Citoid returned, only while that box is still empty.
									if (current !== &quot;__manual__&quot;) {
										srcSel.val(&quot;__manual__&quot;).trigger(&quot;change&quot;);
									}
									var manualField = srcFields.find(&quot;.wiktku-dfn-quote-src-manual&quot;);
									if (!$.trim(manualField.val())) {
										var parts = [];
										$.each([&quot;nivîskar&quot;, &quot;sernav&quot;, &quot;websîte&quot;, &quot;kovar&quot;, &quot;weşanxane&quot;, &quot;sal&quot;], function (_, k) {
											if (result.fields[k]) parts.push(result.fields[k]);
										});
										manualField.val(parts.join(&quot;, &quot;));
									}
								}
								citoidStatus.text(wiktkuUtil.msg.citoidFilled);
							}, function () {
								// Citoid found nothing: open the form the query points to (Kitêb for an ISBN,
								// Kovar for a DOI, Websîte for a link, a hand-written source otherwise).
								var id = wikt.citoid.identifierOf(query);
								var isLink = /^https?:\/\//i.test(query);
								var opened = !srcSel.val();
								if (opened) {
									srcSel.val(id &amp;&amp; jederDefs[id.jederKey] ? id.jederKey
										: isLink &amp;&amp; jederDefs[&quot;jêder-websîte&quot;] ? &quot;jêder-websîte&quot; : &quot;__manual__&quot;).trigger(&quot;change&quot;);
								}
								var current = srcSel.val();
								// The identifier gets its own field, so the link box would only repeat it as url=.
								if (id &amp;&amp; srcFields.find(&quot;[data-field-key='&quot; + id.field + &quot;']&quot;).length) {
									var idField = {};
									idField[id.field] = id.value;
									fillEmptyFields(idField);
									urlInput.val(&quot;&quot;);
								}
								var citoid = window.wikt &amp;&amp; window.wikt.citoid;
								if (isLink &amp;&amp; citoid &amp;&amp; citoid.websiteNameForUrl) {
									fillEmptyFields({ &quot;websîte&quot;: citoid.websiteNameForUrl(query) });
								}
								if (current === &quot;__manual__&quot;) {
									var manualField = srcFields.find(&quot;.wiktku-dfn-quote-src-manual&quot;);
									if (!$.trim(manualField.val())) {
										manualField.val(query);
									}
									urlInput.val(&quot;&quot;);
									citoidStatus.text(&quot;Ev ne lînk, DOI an ISBN e. Çavkaniyê bi destê xwe binivîse.&quot;);
								} else {
									citoidStatus.text(&quot;Citoid malûmat nedîtin. &quot; + (opened ? &quot;Forma «&quot; + jederDefs[current].label + &quot;» hate vekirin: qadên&quot; : &quot;Qadên&quot;) +
										&quot; mayî bi destê xwe tijî bike.&quot;);
								}
							}).always(function () {
								citoidBtn.setDisabled(false);
							});
						}

						citoidBtn.on(&quot;click&quot;, runCitoidFetch);
						urlInput.on(&quot;input&quot;, autofillVideoTimestamp);
						urlInput.on(&quot;keydown&quot;, function (e) {
							if (e.which === 13) { // Enter
								e.preventDefault();
								runCitoidFetch();
							}
						});

						// Dynamic source fields container.
						var srcFields = $(&quot;&lt;div&gt;&lt;/div&gt;&quot;).addClass(&quot;wiktku-dfn-quote-src-fields&quot;);

						// &quot;Malûmatên çavkaniyê&quot; over a jêder-* template's boxes, with the button that empties
						// them and the link.
						var clearBtn = new OO.ui.ButtonWidget({
							label: &quot;Vala bike&quot;,
							framed: false,
							title: &quot;Lînkê û qadên jêder-* yên vê beşê vala bike&quot;,
							classes: [ &quot;wiktku-dfn-quote-src-clear&quot; ]
						});
						clearBtn.on(&quot;click&quot;, function () {
							urlInput.val(&quot;&quot;);
							citoidStatus.text(&quot;&quot;);
							srcFields.find(&quot;.wiktku-dfn-quote-src-input&quot;).val(&quot;&quot;);
						});
						var srcHead = $(&quot;&lt;div&gt;&lt;/div&gt;&quot;).addClass(&quot;wiktku-dfn-quote-src-head&quot;)
							.append($(&quot;&lt;span&gt;&lt;/span&gt;&quot;).addClass(&quot;wiktku-dfn-quote-src-head-label&quot;).text(&quot;Malûmatên çavkaniyê&quot;),
								clearBtn.$element)
							.hide();

						// One labelled box for a citation parameter. Wide/narrow/medium layout: sernav-type
						// fields get a full-width multiline box, short ones like sal/rûpel/isbn stay narrow.
						// Sizes come from wikt.cite, so a Kategorî:Çavkanî template that happens to use the
						// same parameter names as jêder-* is laid out the same way rather than generically.
						function buildSrcFieldRow(field) {
							var size = wiktkuCite.fieldSize(field.key);
							var width = field.width || size.width || &quot;medium&quot;;
							var multiline = field.multiline !== undefined ? field.multiline : size.multiline;
							var row = $(&quot;&lt;div&gt;&lt;/div&gt;&quot;)
								.addClass(&quot;wiktku-dfn-quote-src-row wiktku-dfn-quote-src-row--&quot; + width);
							var fieldLbl = $(&quot;&lt;label&gt;&lt;/label&gt;&quot;).text(field.label + &quot;: &quot;);
							var inp = $(multiline ? &quot;&lt;textarea&gt;&lt;/textarea&gt;&quot; : &quot;&lt;input type='text'&gt;&quot;)
								.addClass(&quot;wiktku-dfn-quote-src-input&quot;)
								.attr(&quot;data-field-key&quot;, field.key)
								.attr(&quot;placeholder&quot;, field.label + &quot;…&quot;);
							if (multiline) {
								inp.attr(&quot;rows&quot;, 2).addClass(&quot;wiktku-dfn-quote-src-input--title&quot;);
							}
							// sal and tarîx say the same thing twice and Modul:quote refuses both; filling
							// one clears the other rather than letting the citation break on save.
							var partner = wiktkuCite.exclusivePartner(field.key);
							if (partner) {
								inp.on(&quot;input&quot;, function () {
									if (!$.trim($(this).val())) return;
									$(this).closest(&quot;.wiktku-dfn-quote-src-fields&quot;)
										.find(&quot;.wiktku-dfn-quote-src-input[data-field-key='&quot; + partner + &quot;']&quot;)
										.val(&quot;&quot;);
								});
							}
							return row.append(fieldLbl).append(inp);
						}

						srcSel.on(&quot;change&quot;, function () {
							srcFields.empty();
							var chosen = $(this).val();
							// As in the add-examples form: no link for Kategorî or raw, no Citoid for a
							// hand-written source, and the fields' header only over a jêder-* template.
							citoidWrap.toggle(chosen !== &quot;__category__&quot; &amp;&amp; chosen !== &quot;__raw__&quot;);
							citoidBtn.toggle(chosen !== &quot;__manual__&quot;);
							citoidStatus.text(&quot;&quot;);
							setUrlWording(chosen);
							srcHead.toggle(!!jederDefs[chosen]);
							if (!chosen) {
								return;
							}

							if (chosen === &quot;__raw__&quot;) {
								// Nothing to fill in: the quote box above already holds the finished
								// template, and it is written out exactly as typed. Only the entry name
								// inside its jêgirtin= is emboldened (see wikt.cite's boldQuoteParam).
								srcFields.append(
									$(&quot;&lt;p&gt;&lt;/p&gt;&quot;)
										.addClass(&quot;wiktku-step-hint wiktku-dfn-quote-raw-hint&quot;)
										.text(&quot;Şablona temam li qutiya jêgirtinê ya jorê binivîse — wek xwe tê qeydkirin.&quot;)
								);
								return;
							}

							if (chosen === &quot;__manual__&quot;) {
								// Freeform source, written by the user — becomes the 2nd
								// positional param of {{jêder|lang|…}} instead of çavkanî?.
								srcFields.append(
									$(&quot;&lt;textarea&gt;&lt;/textarea&gt;&quot;)
										.attr(&quot;rows&quot;, 4)
										.addClass(&quot;wiktku-dfn-subfield wiktku-dfn-quote-src-manual&quot;)
										.attr(&quot;placeholder&quot;, &quot;Çavkaniyê bi destê xwe binivîse…&quot;)
								);
								return;
							}

							if (chosen === &quot;__category__&quot;) {
								// Same [[Kategorî:Çavkanî]] search widget DefSideBoxes' own Çavkanî subsection box
								// uses -- picking a result switches the row into the hidden manual mode with
								// {{Şablon}} pre-filled. The picked şablon becomes the citation template itself:
								// its own TemplateData parameters are drawn as fields below the picker, in the
								// same markup the jêder-* branch uses, so readJederList() reads both with one loop.
								var catPicker = wiktkuCite.buildCategoryTemplateSearch({
									placeholder: wiktkuUtil.msg.searchTemplate,
									describe: false,
									onPick: function (entry) {
										li.data(&quot;catTemplate&quot;, entry.target);
										li.data(&quot;catLangParam&quot;, null);
										catPicker.$status.text(&quot;Qutiyên şablonê tên barkirin…&quot;);
										srcFields.find(&quot;.wiktku-dfn-quote-src-row&quot;).remove();
										wiktkuCite.fieldSpecs(entry.target).then(function (spec) {
											catPicker.$status.text(&quot;&quot;);
											li.data(&quot;catLangParam&quot;, spec.langParamKey || null);
											$.each(spec.fields, function (_, field) {
												srcFields.append(buildSrcFieldRow(field));
											});
										}, function () {
											catPicker.$status.text(&quot;Qutiyên şablonê nehatin anîn.&quot;);
										});
									}
								});
								srcFields.append(catPicker.$element);
								return;
							}

							var def = jederDefs[chosen];
							if (!def) return;
							$.each(def.fields, function (_, field) {
								srcFields.append(buildSrcFieldRow(field));
							});
							autofillVideoTimestamp();
						});

						// Exposed so draft restore can rebuild a saved category template's fields.
						// A whole citation line pasted into the quote box (&quot;#* {{jêder|…}}&quot;) means it was
						// copied off another entry; switch to raw mode rather than wrapping it in a second
						// {{nimûne}}. Only while no source type has been chosen by hand.
						li.find(&quot;.wiktku-dfn-nimune-quote&quot;).on(&quot;input&quot;, function () {
							if (srcSel.val()) return;
							if (wiktkuCite.looksLikeCitationLine($(this).val())) {
								srcSel.val(&quot;__raw__&quot;).trigger(&quot;change&quot;);
							}
						});
						li.data(&quot;buildSrcFieldRow&quot;, buildSrcFieldRow);
						li.append(srcSelWrap, citoidWrap, srcHead, srcFields);

						return li;
					}

					jederGroupDiv.data(&quot;buildJederLi&quot;, buildJederLi);

					jederList.append(buildJederLi());
					jederGroupDiv.append(jederLbl).append(jederList);
					// Straight after Nimûne rather than last: Jêgirtin is the
					// same kind of thing (an attested use of the word) and the
					// two belong together — see the allGroups comment above.
					var nimuneGroup = block.find(&quot;.wiktku-dfn-nimune-group&quot;);
					if (nimuneGroup.length) jederGroupDiv.insertAfter(nimuneGroup);
					else block.append(jederGroupDiv);
				}());

				// Apply the initial hide/show state for the sub-groups (matches
				// tplSelect's starting value, which is normally empty).
				updateFieldVisibility();

				// ── Which sub-field goes where: chips in the row above for the two everyday ones, the rest
				// behind &quot;Hevmane û Bêhtir&quot;. Same arrangement as DefSideBoxes' own sense menu, deliberately -- a
				// person who has used one gadget should not have to learn the other.
				(function () {
					var PICK_DEFS = [
						{ cls: &quot;wiktku-dfn-nimune&quot;, label: &quot;Nimûne&quot;,   chip: true, attested: true },
						{ cls: &quot;wiktku-dfn-jeder&quot;,  label: &quot;Jêgirtin&quot;, chip: true, attested: true }
					].concat($.map(wordGroups(), function (g) {
						return { cls: g.cls, label: g.label, word: true };
					}));

					// Etîket and Kategorî are chip fields, not sub-groups, so they are revealed by showing
					// their toggle rather than a whole box.
					var CHIP_FIELD_DEFS = [
						{ cls: &quot;wiktku-dfn-etiket&quot;,   label: &quot;Etîket&quot;,   field: etiketField },
						{ cls: &quot;wiktku-dfn-kategori&quot;, label: &quot;Kategorî&quot;, field: kategoriField },
						{ cls: &quot;wiktku-dfn-maneid&quot;,   label: &quot;Maneid&quot;,   field: maneidField }
					];

					function groupHasContent(groupDiv) {
						return groupDiv.find(&quot;textarea, input&quot;).filter(function () {
							return $.trim($(this).val() || &quot;&quot;) !== &quot;&quot;;
						}).length &gt; 0;
					}

					// Shows a group and takes its chip / menu entry out of the picker -- both carry the same
					// data-pick, so one selector covers whichever of the two this group had.
					// Which group carries no divider above it: the first one actually on screen, not the
					// first in the DOM -- see the .wiktku-dfn-subgroup-first rule.
					function updateFirstVisible() {
						var $all = block.find(&quot;.wiktku-dfn-subgroup&quot;).removeClass(&quot;wiktku-dfn-subgroup-first&quot;);
						$all.not(&quot;.wiktku-dfn-subgroup-hidden&quot;).first().addClass(&quot;wiktku-dfn-subgroup-first&quot;);
					}

					function revealGroup(cls, focus) {
						var groupDiv = block.find(&quot;.&quot; + cls + &quot;-group&quot;);
						if (!groupDiv.length) return;
						groupDiv.removeClass(&quot;wiktku-dfn-subgroup-hidden&quot;);
						block.find(&quot;[data-pick='&quot; + cls + &quot;']&quot;).hide();
						updateFirstVisible();
						if (focus) groupDiv.find(&quot;textarea, input&quot;).first().focus();
					}
					block.data(&quot;revealSenseGroup&quot;, revealGroup);

					// Hides it again and gives the picker its entry back. Anything typed is thrown away, so a
					// group holding something asks first.
					function hideGroup(cls) {
						var groupDiv = block.find(&quot;.&quot; + cls + &quot;-group&quot;);
						if (!groupDiv.length) return;
						if (groupHasContent(groupDiv) &amp;&amp;
							!window.confirm(&quot;Tiştên di vê qutiyê de winda dibin. Dewam bike?&quot;)) {
							return;
						}
						groupDiv.children(&quot;ol&quot;).children(&quot;li&quot;).not(&quot;:first&quot;).remove();
						groupDiv.find(&quot;textarea, input&quot;).val(&quot;&quot;);
						// The jêgirtin row's source &lt;select&gt; owns the fields under it; putting it back to &quot;&quot;
						// is what clears them.
						groupDiv.find(&quot;select.wiktku-dfn-quote-src-sel&quot;).val(&quot;&quot;).trigger(&quot;change&quot;);
						groupDiv.addClass(&quot;wiktku-dfn-subgroup-hidden&quot;);
						block.find(&quot;[data-pick='&quot; + cls + &quot;']&quot;).show();
						updateFirstVisible();
					}

					// Drafts, restoreDfn() and the ⊕-grown lists all put content in without going through
					// revealGroup(), so anything that ended up filled is shown on the next refresh pass.
					function syncPicks() {
						$.each(PICK_DEFS, function (_, def) {
							var groupDiv = block.find(&quot;.&quot; + def.cls + &quot;-group&quot;);
							if (groupDiv.length &amp;&amp; groupDiv.hasClass(&quot;wiktku-dfn-subgroup-hidden&quot;) &amp;&amp;
								groupHasContent(groupDiv)) {
								revealGroup(def.cls, false);
							}
						});
						$.each(CHIP_FIELD_DEFS, function (_, def) {
							if (def.field.values().length) {
								def.field.wrap.show();
								block.find(&quot;[data-pick='&quot; + def.cls + &quot;']&quot;).hide();
							}
						});
					}
					block.data(&quot;syncSensePicks&quot;, syncPicks);

					// Every group gets an × in its label, so a box opened by mistake can go away again --
					// the counterpart of DefSideBoxes' own box-remove link.
					$.each(PICK_DEFS, function (_, def) {
						var groupDiv = block.find(&quot;.&quot; + def.cls + &quot;-group&quot;);
						if (!groupDiv.length) return;
						var $x = $(&quot;&lt;button type='button' class='wiktku-dfn-subgroup-remove'&gt;&amp;#215;&lt;/button&gt;&quot;)
							.attr(&quot;title&quot;, def.label + &quot; veşêre&quot;);
						$x.on(&quot;click&quot;, function (e) {
							e.preventDefault();
							hideGroup(def.cls);
						});
						groupDiv.children(&quot;.wiktku-dfn-sublabel&quot;).first().append($x);
					});

					// — the chips, beside Dever/Şîwe —
					$.each(PICK_DEFS, function (_, def) {
						if (!def.chip || (isReconstruction &amp;&amp; def.attested)) return;
						var $chip = $(&quot;&lt;button type='button' class='wiktku-dfn-chipfield-toggle'&gt;&lt;/button&gt;&quot;)
							.attr(&quot;data-pick&quot;, def.cls)
							.text(&quot;+ &quot; + def.label);
						$chip.on(&quot;click&quot;, function (e) {
							e.preventDefault();
							revealGroup(def.cls, true);
						});
						chipFieldRow.append($chip);
					});

					// — &quot;Hevmane û Bêhtir&quot; —
					var moreArrow = $(&quot;&lt;span class='wiktku-dfn-more-arrow'&gt;&amp;#9656;&lt;/span&gt;&quot;);
					var moreToggle = $(&quot;&lt;button type='button' class='wiktku-dfn-chipfield-toggle wiktku-dfn-more-toggle'&gt;&lt;/button&gt;&quot;)
						.append(document.createTextNode(wiktkuUtil.msg.moreMenu + &quot; &quot;)).append(moreArrow);
					var moreMenu = $(&quot;&lt;div class='wiktku-dfn-more-menu'&gt;&lt;/div&gt;&quot;).hide();
					function closeMenu() {
						moreMenu.hide();
						moreArrow.html(&quot;&amp;#9656;&quot;);
					}
					moreToggle.on(&quot;click&quot;, function (e) {
						e.preventDefault();
						$(&quot;.wiktku-dfn-more-menu&quot;).not(moreMenu).hide();
						moreMenu.toggle();
						moreArrow.html(moreMenu.is(&quot;:visible&quot;) ? &quot;&amp;#9662;&quot; : &quot;&amp;#9656;&quot;);
					});

					function menuEntry(label, cls, extraCls) {
						var $link = $(&quot;&lt;a href='#' class='wiktku-dfn-more-item'&gt;&lt;/a&gt;&quot;).text(label);
						if (cls) $link.attr(&quot;data-pick&quot;, cls);
						if (extraCls) $link.addClass(extraCls);
						moreMenu.append($link);
						return $link;
					}

					// Group 1: the two label fields. Their toggle only joins the chip row once asked for.
					$.each(CHIP_FIELD_DEFS, function (_, def) {
						var $link = menuEntry(&quot;+ &quot; + def.label, def.cls);
						$link.on(&quot;click&quot;, function (e) {
							e.preventDefault();
							closeMenu();
							def.field.wrap.show();
							def.field.open();
							$link.hide();
						});
					});

					// Group 2: the word lists. wiktku-dfn-pick-word so a şablon sense hides these entries
					// along with the groups themselves.
					var firstWord = true;
					$.each(PICK_DEFS, function (_, def) {
						if (!def.word) return;
						var $link = menuEntry(&quot;+ &quot; + def.label, def.cls,
							&quot;wiktku-dfn-pick-word&quot; + (firstWord ? &quot; wiktku-dfn-more-group-start&quot; : &quot;&quot;));
						firstWord = false;
						$link.on(&quot;click&quot;, function (e) {
							e.preventDefault();
							closeMenu();
							revealGroup(def.cls, true);
						});
					});

					// Group 3: no &quot;Maneê rake&quot; counterpart -- the tab row already carries one bin for the
					// open sense, and a second delete in here would be a second way to do the same thing.
					var $newSense = menuEntry(wiktkuUtil.msg.addAnotherSense, null, &quot;wiktku-dfn-more-group-start&quot;);
					$newSense.on(&quot;click&quot;, function (e) {
						e.preventDefault();
						closeMenu();
						steps.dfn.addSense($(&quot;#wiktku-start-dfn&quot;), block);
					});

					chipFieldRow.append($(&quot;&lt;span class='wiktku-dfn-more-wrap'&gt;&lt;/span&gt;&quot;).append(moreToggle, moreMenu));
					bindMoreMenuCloser();
					syncPicks();
					updateFirstVisible();
				}());

				return block;
			},

			/** Shows only `block` among the sense list; hides every other one. */
			setOpenSense: function (stepDiv, block) {
				stepDiv.find(&quot;li.wiktku-dfn-sense&quot;).each(function () {
					$(this).toggleClass(&quot;wiktku-sense-collapsed&quot;, !$(this).is(block));
				});
				steps.dfn.renderSenseTabs(stepDiv);
			},

			/** Rebuilds the &quot;Mane 1 / Mane 2 / [trash] / + Maneyeke din&quot; tab row from the current sense list. */
			renderSenseTabs: function (stepDiv) {
				var tabsDiv = stepDiv.find(&quot;.wiktku-dfn-sense-tabs&quot;);
				if (!tabsDiv.length) return;
				tabsDiv.empty();
				var blocks = stepDiv.find(&quot;li.wiktku-dfn-sense&quot;);
				var openLi = null;
				blocks.each(function (i) {
					var li = $(this);
					var isOpen = !li.hasClass(&quot;wiktku-sense-collapsed&quot;);
					if (isOpen) openLi = li;
					var tab = $(&quot;&lt;span class='wiktku-dfn-sense-tab'&gt;&lt;/span&gt;&quot;)
						.text(&quot;Mane &quot; + (i + 1))
						.toggleClass(&quot;wiktku-tab-active&quot;, isOpen);
					tab.on(&quot;click&quot;, function () { steps.dfn.setOpenSense(stepDiv, li); });
					tabsDiv.append(tab);
				});
				// One delete button for the whole bar — not one per tab — so
				// there's only ever a single, deliberate hit-target for a
				// destructive action, positioned away from the tabs people
				// click to switch senses. Always keep at least one Mane.
				if (blocks.length &gt; 1 &amp;&amp; openLi) {
					var openIdx = blocks.index(openLi);
					var trash = makeTrashButton(&quot;Vê maneyê jê bibe (Mane &quot; + (openIdx + 1) + &quot;)&quot;);
					trash.on(&quot;click&quot;, function () {
						if (!window.confirm(&quot;Tu dixwazî Mane &quot; + (openIdx + 1) + &quot; jê bibî? Ev tişt nayê vegerandin.&quot;)) return;
						steps.dfn.removeSense(stepDiv, openLi);
					});
					tabsDiv.append(trash.$element);
				}
				var addBtn = $(&quot;&lt;button type='button' class='wiktku-add-sense'&gt;&lt;/button&gt;&quot;)
					.append($(&quot;&lt;span class='wiktku-add-sense-plus'&gt;+&lt;/span&gt;&quot;))
					.append(document.createTextNode(wiktkuUtil.msg.anotherSense));
				addBtn.on(&quot;click&quot;, function (e) {
					e.preventDefault();
					steps.dfn.addSense(stepDiv);
				});
				tabsDiv.append(addBtn);
			},

			/** Adds a sense, opens it, and hides the others. With afterBlock, the new one lands directly
			 *  under that sense rather than at the end — &quot;Maneyeke din zêde bike&quot; in a sense's own
			 *  &quot;Hevmane û Bêhtir&quot; menu is asking for one next to *this* meaning. */
			addSense: function (stepDiv, afterBlock) {
				var list = stepDiv.find(&quot;ol.wiktku-dfn-list&quot;);
				var newBlock = steps.dfn.buildSenseBlock(stepDiv);
				if (afterBlock &amp;&amp; afterBlock.length) newBlock.insertAfter(afterBlock);
				else list.append(newBlock);
				initSelects(newBlock);
				steps.dfn.setOpenSense(stepDiv, newBlock);
				newBlock.find(&quot;textarea.wiktku-dfn-mane&quot;).first().focus();
				refresh();
				return newBlock;
			},

			/** Removes one sense block. Assumes the caller already confirmed
			 *  and already checked more than one sense remains. If the
			 *  removed sense was the open one, opens whichever sense ends up
			 *  taking its place (or the last one, if it was the last). */
			removeSense: function (stepDiv, li) {
				var list = stepDiv.find(&quot;ol.wiktku-dfn-list&quot;);
				var blocks = list.find(&quot;li.wiktku-dfn-sense&quot;);
				var removedIdx = blocks.index(li);
				var wasOpen = !li.hasClass(&quot;wiktku-sense-collapsed&quot;);
				li.remove();
				if (wasOpen) {
					var remaining = list.find(&quot;li.wiktku-dfn-sense&quot;);
					var next = remaining.eq(removedIdx);
					if (!next.length) next = remaining.last();
					if (next.length) steps.dfn.setOpenSense(stepDiv, next);
				}
				steps.dfn.renderSenseTabs(stepDiv);
				refresh();
			},

			/** Grows a sub-list (nimûne/formên alternatîv/hevmane/dijmane/termên koordîne) on input. */
			onSubInput: function (list, input, rows, narrow, modifiers) {
				var val = $.trim($(input).val());
				var item = $(input).parent();
				var isLast = item.is(list.children(&quot;li:last-child&quot;));
				if (val &amp;&amp; isLast) {
					var next = $(&quot;&lt;textarea&gt;&lt;/textarea&gt;&quot;)
						.attr(&quot;name&quot;, &quot;wiktku-dfn-sub-&quot; + $.now() + &quot;-&quot; + Math.random().toString(36).substr(2, 9))
						.attr(&quot;rows&quot;, rows)
						.attr(&quot;class&quot;, &quot;wiktku-dfn-subfield&quot; + (narrow ? &quot; wiktku-start-narrow&quot; : &quot;&quot;));
					next.on(&quot;input&quot;, function () {
						steps.dfn.onSubInput(list, this, rows, narrow, modifiers);
					});
					list.append(modifiers ? makeModifierLi(next) : $(&quot;&lt;li&gt;&lt;/li&gt;&quot;).append(next));
					// New field starts with no placeholder — give it (and any
					// others in the list) the current one.
					var updatePlaceholders = list.data(&quot;updatePlaceholders&quot;);
					if (typeof updatePlaceholders === &quot;function&quot;) updatePlaceholders();
				}
			},

			// Populated from data-main.json (tplDefs, jederDefs).
			tplDefs: {},
			jederDefs: {},

			build: function (stepDiv) {
				if (stepDiv.find(&quot;ol.wiktku-dfn-list&quot;).length) return null;

				var tabsDiv = $(&quot;&lt;div class='wiktku-dfn-sense-tabs'&gt;&lt;/div&gt;&quot;);
				stepDiv.append(tabsDiv);

				var list = $(&quot;&lt;ol class='wiktku-dfn-list'&gt;&lt;/ol&gt;&quot;);
				list.append(steps.dfn.buildSenseBlock(stepDiv));
				stepDiv.append(list);

				steps.dfn.renderSenseTabs(stepDiv);
				return null;
			},

			/** Reads all sense blocks from the DOM and returns an array of sense objects. */
			getSenses: function (stepDiv) {
				var senses = [];
				stepDiv.find(&quot;li.wiktku-dfn-sense&quot;).each(function () {
					var block    = $(this);
					var tplSel   = block.find(&quot;select.wiktku-dfn-tpl-select&quot;);
					var tpl      = tplSel.val() || &quot;&quot;;
					// noLang: template already encodes the language — don't add |lang| param.
					var tplNoLang = tpl
						? tplSel.find(&quot;option[value='&quot; + tpl + &quot;']&quot;).attr(&quot;data-nolang&quot;) === &quot;1&quot;
						: false;
					var tplTitle = $.trim(block.find(&quot;input.wiktku-dfn-tpl-title&quot;).val());
					// The mane box and the îzah box are one gloss on the page: &quot;tercime {{îzah|…}}&quot;. Joined
					// here so everything downstream (getOutput, the linkify pass, the cache) keeps seeing a
					// single string, exactly as it did when the pair was two boxes.
					var mane = $.trim(block.find(&quot;textarea.wiktku-dfn-mane&quot;).val());
					var izah = $.trim(block.find(&quot;textarea.wiktku-dfn-izah&quot;).val());
					if (izah) {
						mane = $.trim(mane + &quot; {{îzah|&quot; + izah + &quot;}}&quot;);
					}

					function readList(cls) {
						var vals = [];
						// Matches only the canonical field, not the visible word-input mirror makeModifierLi() adds alongside it.
						block.find(&quot;.&quot; + cls + &quot;-list textarea.wiktku-dfn-subfield&quot;).each(function () {
							var v = $.trim($(this).val());
							if (v) vals.push(v);
						});
						return vals;
					}

					// Nimûne items are compound: { text, tr?, t? }
					function readNimuneList() {
						var items = [];
						block.find(&quot;.wiktku-dfn-nimune-list li.wiktku-dfn-nimune-li&quot;).each(function () {
							var text = $.trim($(this).find(&quot;.wiktku-dfn-nimune-text&quot;).val());
							if (!text) return;
							var obj = { text: text };
							var tr = $.trim($(this).find(&quot;.wiktku-dfn-nimune-tr&quot;).val());
							var t  = $.trim($(this).find(&quot;.wiktku-dfn-nimune-t&quot;).val());
							if (tr) obj.tr = tr;
							if (t)  obj.t  = t;
							items.push(obj);
						});
						return items;
					}

					// Jêder is a growing list of citations, one per li — mirrors readNimuneList().
					function readJederList() {
						var items = [];
						block.find(&quot;.wiktku-dfn-jeder-list li.wiktku-dfn-jeder-li&quot;).each(function () {
							var li = $(this);
							var quote = $.trim(li.find(&quot;.wiktku-dfn-nimune-quote&quot;).val());
							if (!quote) return;
							var obj = { quote: quote };
							var qtr = $.trim(li.find(&quot;.wiktku-dfn-nimune-quote-tr&quot;).val());
							var qt  = $.trim(li.find(&quot;.wiktku-dfn-nimune-quote-t&quot;).val());
							if (qtr) obj.quoteTr = qtr;
							if (qt)  obj.quoteT  = qt;
							var tplName = li.find(&quot;.wiktku-dfn-quote-src-sel&quot;).val();
							var url = tplName === &quot;__raw__&quot; || tplName === &quot;__category__&quot; ? &quot;&quot;
								: $.trim(li.find(&quot;.wiktku-dfn-quote-url&quot;).val());
							if (url) obj.url = url;
							if (tplName === &quot;__manual__&quot;) {
								var manual = $.trim(li.find(&quot;.wiktku-dfn-quote-src-manual&quot;).val());
								if (manual) obj.jederManual = manual;
							} else if (tplName === &quot;__raw__&quot;) {
								// The quote box already holds a finished citation template; it is written
								// out untouched, so there is nothing else on this row to read.
								obj.raw = true;
							} else if (tplName === &quot;__category__&quot;) {
								// A picked Kategorî:Çavkanî template IS the citation template, with its own
								// TemplateData parameters -- rendered into the same markup the jêder-* branch
								// below uses, so one loop reads both.
								var catName = li.data(&quot;catTemplate&quot;);
								if (catName) {
									obj.jederCatTpl = catName;
									var catFields = {};
									li.find(&quot;.wiktku-dfn-quote-src-input&quot;).each(function () {
										var ck = $(this).attr(&quot;data-field-key&quot;);
										var cv = $.trim($(this).val());
										if (ck &amp;&amp; cv) catFields[ck] = cv;
									});
									// A restore in progress has no boxes yet -- its TemplateData is still on
									// the way -- so the values it is restoring stand in until they exist.
									// See restoreDfn, which parks them here and clears them once they land.
									if (!Object.keys(catFields).length) {
										catFields = li.data(&quot;catFields&quot;) || {};
									}
									obj.jederCatFields = catFields;
									var catLang = li.data(&quot;catLangParam&quot;);
									if (catLang) obj.jederCatLangParam = catLang;
								}
							} else if (tplName) {
								obj.jederTpl = tplName;
								var fields = {};
								li.find(&quot;.wiktku-dfn-quote-src-input&quot;).each(function () {
									var k = $(this).attr(&quot;data-field-key&quot;);
									var v = $.trim($(this).val());
									if (k &amp;&amp; v) fields[k] = v;
								});
								obj.jêderFields = wiktkuCite.withLinkAsUrl(tplName, fields, url);
							}
							items.push(obj);
						});
						return items;
					}

					// Dever/Şîwe, Etîket and Kategorî are chip fields (buildChipField),
					// not textareas, so readList() doesn't reach them — each chip's
					// value lives in data-value, scoped by the field's wrap class.
					function readChipList(wrapCls) {
						var vals = [];
						block.find(&quot;.&quot; + wrapCls + &quot;-wrap .wiktku-dfn-chipfield-chip&quot;).each(function () {
							var v = $.trim($(this).attr(&quot;data-value&quot;) || &quot;&quot;);
							if (v) vals.push(v);
						});
						return vals;
					}

					var sense = {
						tpl:       tpl,
						tplNoLang: tplNoLang,
						tplTitle:  tplTitle,
						mane:      mane,
						maneid:    $.trim(block.find(&quot;input.wiktku-dfn-maneid-input&quot;).val() || &quot;&quot;),
						etiket:    readChipList(&quot;wiktku-dfn-etiket&quot;),
						kategori:  readChipList(&quot;wiktku-dfn-kategori&quot;),
						nimune:    readNimuneList(),
						jeder:     readJederList(),
						dever:     readChipList(&quot;wiktku-dfn-dever&quot;)
					};
					// alternativ, hevmane, dijmane, koordine, jornav, jernav — one property each, named by
					// senseGroups' &quot;field&quot; so getOutput() and restoreDfn() find them under the same names.
					$.each(wordGroups(), function (_, g) {
						sense[g.field] = readList(g.cls);
					});
					senses.push(sense);
				});
				return senses;
			},

			getOutput: function (values, callback) {
				var stepDiv = $(&quot;#wiktku-start-dfn&quot;);
				var senses = steps.dfn.getSenses(stepDiv);
				var lang = values.lang;

				// A sense counts as &quot;filled&quot; if it has a mane, a chosen template + title,
				// or any other content (etîket/hevmane/nimûne/jêder…) worth keeping.
				var hasMane = senses.some(function (s) {
					return s.mane !== &quot;&quot; || (s.tpl &amp;&amp; s.tplTitle) || senseHasExtraContent(s);
				});


				var defLines  = [];   // one entry per kept sense (goes to linkify)
				var citeLines = [];   // parallel — nimûne+jêder for that same sense
				var izahLines = [];   // parallel — raw îzah gloss for that same sense

				// True only once some sense's *actual* dfn text (post tercime/îzah
				// split) is non-empty.
				var hasLinkableMane = false;

				$.each(senses, function (_, sense) {
					// Declared once here rather than with `var` in each branch
					// below — the template-sense branch returns early, so only
					// one of the two assignments ever actually runs, but both
					// are lexically in this same function scope.
					var idx, cite;

					// — Template sense (e.g. {{guharto|ku|somepage}}) —
					if (sense.tpl) {
						if (!sense.tplTitle) return; // skip empty template senses

						var tplManeidTpl = buildManeidTpl(sense, lang);
						var tplKatTpl = buildSenseTpl(sense, &quot;kategori&quot;, lang, &quot;K&quot;);
						var tplDeverTpl = buildDeverTpl(sense, lang);
						var tplLabelTpl = buildEtiketTpl(sense, lang);

						var tplCall = sense.tplNoLang
							? &quot;{{&quot; + sense.tpl + &quot;|&quot; + sense.tplTitle + &quot;}}&quot;
							: &quot;{{&quot; + sense.tpl + &quot;|&quot; + lang + &quot;|&quot; + sense.tplTitle + &quot;}}&quot;;

						idx = defLines.length;
						cite = buildCite(sense, lang);

						defLines.push(&quot;# &quot; + (tplManeidTpl ? tplManeidTpl + &quot; &quot; : &quot;&quot;) + (tplKatTpl ? tplKatTpl + &quot; &quot; : &quot;&quot;) + (tplDeverTpl ? tplDeverTpl + &quot; &quot; : &quot;&quot;) +
							(tplLabelTpl ? tplLabelTpl + &quot; &quot; : &quot;&quot;) + tplCall +
							(cite ? &quot;{{wiktku-cite-&quot; + idx + &quot;}}&quot; : &quot;&quot;));
						citeLines.push(cite);
						izahLines.push(&quot;&quot;); // template senses have no îzah
						return;
					}

					// — Normal mane sense —
					var dfn = sense.mane;
					if (!dfn &amp;&amp; !senseHasExtraContent(sense)) return; // truly empty

					// Pull the îzah gloss (if any) out of the combined tercime+îzah
					// string — it's spliced back in separately below, after its
					// own linkify pass (see izahLines / the second linkifyText call).
					var izahRaw = null;
					var tercimeIzah = splitTercimeIzah(dfn);
					if (tercimeIzah) {
						dfn = tercimeIzah.tercime;
						izahRaw = stripWikilinks(tercimeIzah.izah);
					}

					if (dfn) {
						dfn = stripWikilinks(dfn);
						// Sentence-case + trailing period are for ku definitions,
						// which are written as full glosses.
						if (lang === &quot;ku&quot;) {
							if (dfn[0] !== dfn[0].toUpperCase()) dfn = capitalize(dfn);
							if (!dfn.match(/[.…?!)\]]$/)) dfn += &quot;.&quot;;
						}
						// Real prose — this is what makes the sense worth running
						// through the main linkify pass.
						hasLinkableMane = true;
					} else if (izahRaw === null) {
						// No mane at all — this is just the &quot;{{mane?|lang}}&quot;
						// placeholder, a bare template call with no plain words
						// in it. Do NOT count it as linkable: sending nothing but
						// bracketed templates through the main linkify pass hangs
						// the linkify gadget (see the hasLinkableMane/hasIzah
						// check below).
						//
						// Every language, not just ku: a sense kept for its jêgirtin or word lists
						// alone still needs the marker, or the line goes out as a bare &quot;# &quot;.
						dfn = &quot;{{mane?|&quot; + lang + &quot;}}&quot;;
					}

					var maneidTpl = buildManeidTpl(sense, lang);
					var katTpl = buildSenseTpl(sense, &quot;kategori&quot;, lang, &quot;K&quot;);
					var deverTpl = buildDeverTpl(sense, lang);
					var labelTpl = buildEtiketTpl(sense, lang);

					var out = &quot;# &quot; + (maneidTpl ? maneidTpl + &quot; &quot; : &quot;&quot;) + (katTpl ? katTpl + &quot; &quot; : &quot;&quot;) + (deverTpl ? deverTpl + &quot; &quot; : &quot;&quot;) + (labelTpl ? labelTpl + &quot; &quot; : &quot;&quot;) + dfn;

					idx = defLines.length;
					var hasThisIzah = izahRaw !== null &amp;&amp; $.trim(izahRaw) !== &quot;&quot;;
					// Bare {{...}} token — like {{wiktku-cite-N}}, this survives
					// linkify's first pass untouched (it treats template calls as
					// opaque), then gets swapped for {{îzah|…}} once the actual
					// gloss text has been linkified in its own separate pass.
					if (hasThisIzah) {
						out += (dfn ? &quot; &quot; : &quot;&quot;) + &quot;{{wiktku-izah-&quot; + idx + &quot;}}&quot;;
					}

					function wordLine(tpl, words) {
						if (!words.length) return &quot;&quot;;
						return &quot;\n#: {{&quot; + tpl + &quot;|&quot; + lang + &quot;|&quot; + words.join(&quot;|&quot;) + &quot;}}&quot;;
					}
					// Template name and sense property both come from senseGroups, so this and
					// DefSideBoxes write the same &quot;#:&quot; lines.
					$.each(ctx.SENSE_GROUPS, function (_, g) {
						out += wordLine(g.key, sense[g.field] || []);
					});

					cite = buildCite(sense, lang);

					defLines.push(out + (cite ? &quot;{{wiktku-cite-&quot; + idx + &quot;}}&quot; : &quot;&quot;));
					citeLines.push(cite);
					izahLines.push(hasThisIzah ? izahRaw : &quot;&quot;);
				});

				// Splice citeLines back into a linkified string, replacing each
				// {{wiktku-cite-N}} token with its stored nimûne/jêder block.
				function restoreCites(t) {
					return t.replace(/\{\{wiktku-cite-(\d+)\}\}/g, function (_, n) {
						return citeLines[parseInt(n, 10)] || &quot;&quot;;
					});
				}

				// Runs text through the linkify gadget if it's loaded, otherwise
				// just passes it through unchanged. Shared by both linkify passes
				// below (main mane text, and — separately — îzah glosses).
				var linkifyText = wiktkuUtil.linkifyText;

				var hasIzah = izahLines.some(function (t) { return t &amp;&amp; $.trim(t) !== &quot;&quot;; });
				var text = defLines.join(&quot;\n&quot;) + &quot;\n&quot;;

				if (!hasMane) {
					// Nothing written yet: the sense is still marked as needing one, but no example
					// placeholder goes with it.
					text = &quot;# {{mane?|&quot; + lang + &quot;}}\n&quot;;
					callback(text);
					return;
				}

				// Runs the îzah-only linkify pass against `base` (either the raw
				// text, when there's no linkable mane to run the main pass on
				// first, or the already-linkified main text). Shared by both
				// branches below so the token-splice logic only lives once.
				function runIzahPass(base) {
					var izahJoined = $.map(izahLines, function (raw, idx) {
						if (!raw) return undefined;
						return &quot;{{wiktku-izah-open-&quot; + idx + &quot;}}&quot; + raw + &quot;{{wiktku-izah-close-&quot; + idx + &quot;}}&quot;;
					}).join(&quot;\n&quot;);

					linkifyText(izahJoined, function (izahLinked) {
						var izahByIdx = {};
						var re = /\{\{wiktku-izah-open-(\d+)\}\}([\s\S]*?)\{\{wiktku-izah-close-\1\}\}/g;
						var m;
						while ((m = re.exec(izahLinked)) !== null) {
							izahByIdx[parseInt(m[1], 10)] = m[2];
						}

						var withIzah = base.replace(/\{\{wiktku-izah-(\d+)\}\}/g, function (_, n) {
							var linked = izahByIdx[parseInt(n, 10)];
							return linked !== undefined ? &quot;{{îzah|&quot; + linked + &quot;}}&quot; : &quot;&quot;;
						});

						callback(restoreCites(withIzah));
					});
				}

				if (!hasLinkableMane) {
					if (!hasIzah) {
						// All filled senses are template senses (or otherwise have
						// no plain text at all) — nothing here needs linkify.
						callback(restoreCites(text));
						return;
					}
					// There's no plain mane text anywhere (e.g. tercime left blank
					// with only îzah filled in), so every defLine is just a bare
					// template call with nothing to word-link. Sending a line
					// like &quot;# {{wiktku-izah-0}}&quot; through the main linkify pass
					// gives it no plain words to work with, makes the linkify
					// gadget hang — so skip that pass entirely and run only
					// the îzah pass, splicing straight into the unlinkified text.
					var loadIzahOnly = function () { runIzahPass(text); };
					mw.loader.using(&quot;ext.gadget.linkify&quot;, loadIzahOnly, loadIzahOnly);
					return;
				}

				var didTryToLoad = function () {
					// First pass: the main definition text (mane), same as before. On failure the text
					// comes back unchanged, so the save carries on with what the user wrote -- only the
					// automatic linking is lost, and saying so is better than losing it silently.
					linkifyText(text, function (mainLinked, error) {
						if (error) {
							mw.notify(error, { type: &quot;warn&quot; });
						}
						if (!hasIzah) {
							callback(restoreCites(mainLinked));
							return;
						}
						// Second pass: îzah glosses, linkified via their own  						
						// separate call. Each gloss is wrapped in its own
						// {{wiktku-izah-open/close-N}} pair; like the existing
						// {{wiktku-cite-N}} tokens, these sit inside double
						// braces so linkify leaves the tokens themselves alone —
						// only the raw gloss text between each pair gets linked.
						runIzahPass(mainLinked);
					});
				};
				mw.loader.using(&quot;ext.gadget.linkify&quot;, didTryToLoad, didTryToLoad);
			}
		},
		};

	// The sections other than Mane: [[MediaWiki:Gadget-wikt.start-wizard-steps/sections.js]].
	require(&quot;./wikt.start-wizard-steps/sections.js&quot;)(ctx, steps);
	return steps;
};
// &lt;/nowiki&gt;</text>
      <sha1>c52g7g1fvwbn4t37y4yhv4zl694bpqx</sha1>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Gadget-definition-links.js</title>
    <ns>8</ns>
    <id>1359530</id>
    <revision>
      <id>6903096</id>
      <parentid>6902522</parentid>
      <timestamp>2026-11-10T15:44:01Z</timestamp>
      <contributor>
        <username>Wikihez</username>
        <id>7344</id>
      </contributor>
      <minor />
      <comment>definition-links: a link to the page itself in another language's section jumps to this page's Kurmancî section</comment>
      <origin>6903096</origin>
      <model>javascript</model>
      <format>text/javascript</format>
      <text bytes="1364" sha1="3jxccrgoooirvcktyy649g0euaouacy" xml:space="preserve">// &lt;nowiki&gt;
// Adds #Kurmancî to links in definition lines, so following one lands on (and on mobile opens) the Kurmancî
// section. Links inside another language's text, and links with a fragment, query or namespace, are left alone.
// A link to the page itself, which MediaWiki leaves without an address, jumps to this page's Kurmancî section
// when it sits in another language's section.
$(function () {
	var kurmanci = document.getElementById(&quot;Kurmancî&quot;);
	var headings = document.querySelectorAll(&quot;.mw-parser-output h2&quot;);
	// The id of the language heading that comes before el, or &quot;&quot; when there is none.
	function languageOf(el) {
		var id = &quot;&quot;;
		Array.prototype.forEach.call(headings, function (h2) {
			if (h2.compareDocumentPosition(el) &amp; Node.DOCUMENT_POSITION_FOLLOWING) {
				id = h2.id;
			}
		});
		return id;
	}
	var links = document.querySelectorAll(&quot;.mw-parser-output ol:not(.references) a:not(.mw-parser-output [lang] a), &quot; +
		&quot;.mw-parser-output ol:not(.references) [lang|=ku] a&quot;);
	Array.prototype.forEach.call(links, function (a) {
		var href = a.getAttribute(&quot;href&quot;);
		if (href &amp;&amp; /^\/wiki\/[^#?:]+$/.test(href)) {
			a.setAttribute(&quot;href&quot;, href + &quot;#Kurmancî&quot;);
		} else if (!href &amp;&amp; a.classList.contains(&quot;mw-selflink&quot;) &amp;&amp; kurmanci &amp;&amp; languageOf(a) !== &quot;Kurmancî&quot;) {
			a.setAttribute(&quot;href&quot;, &quot;#Kurmancî&quot;);
		}
	});
});
// &lt;/nowiki&gt;</text>
      <sha1>3jxccrgoooirvcktyy649g0euaouacy</sha1>
    </revision>
    <revision>
      <id>6903098</id>
      <parentid>6903096</parentid>
      <timestamp>2026-11-10T18:24:54Z</timestamp>
      <contributor>
        <username>Wikihez</username>
        <id>7344</id>
      </contributor>
      <minor />
      <comment>definition-links: a self-link turned into a jump looks like a normal link, not bold text</comment>
      <origin>6903098</origin>
      <model>javascript</model>
      <format>text/javascript</format>
      <text bytes="1514" sha1="4cuzhwekravig94lmrzlbv0zp598m7m" xml:space="preserve">// &lt;nowiki&gt;
// Adds #Kurmancî to links in definition lines, so following one lands on (and on mobile opens) the Kurmancî
// section. Links inside another language's text, and links with a fragment, query or namespace, are left alone.
// A link to the page itself, which MediaWiki leaves without an address, jumps to this page's Kurmancî section
// when it sits in another language's section.
$(function () {
	var kurmanci = document.getElementById(&quot;Kurmancî&quot;);
	var headings = document.querySelectorAll(&quot;.mw-parser-output h2&quot;);
	// The id of the language heading that comes before el, or &quot;&quot; when there is none.
	function languageOf(el) {
		var id = &quot;&quot;;
		Array.prototype.forEach.call(headings, function (h2) {
			if (h2.compareDocumentPosition(el) &amp; Node.DOCUMENT_POSITION_FOLLOWING) {
				id = h2.id;
			}
		});
		return id;
	}
	var links = document.querySelectorAll(&quot;.mw-parser-output ol:not(.references) a:not(.mw-parser-output [lang] a), &quot; +
		&quot;.mw-parser-output ol:not(.references) [lang|=ku] a&quot;);
	Array.prototype.forEach.call(links, function (a) {
		var href = a.getAttribute(&quot;href&quot;);
		if (href &amp;&amp; /^\/wiki\/[^#?:]+$/.test(href)) {
			a.setAttribute(&quot;href&quot;, href + &quot;#Kurmancî&quot;);
		} else if (!href &amp;&amp; a.classList.contains(&quot;mw-selflink&quot;) &amp;&amp; kurmanci &amp;&amp; languageOf(a) !== &quot;Kurmancî&quot;) {
			a.setAttribute(&quot;href&quot;, &quot;#Kurmancî&quot;);
			// The self-link style shows it as plain bold text; dropped so it looks like the link it now is.
			a.classList.remove(&quot;mw-selflink&quot;, &quot;selflink&quot;);
		}
	});
});
// &lt;/nowiki&gt;</text>
      <sha1>4cuzhwekravig94lmrzlbv0zp598m7m</sha1>
    </revision>
  </page>
  <page>
    <title>Baxo</title>
    <ns>0</ns>
    <id>1359532</id>
    <revision>
      <id>6903088</id>
      <timestamp>2026-11-10T12:24:10Z</timestamp>
      <contributor>
        <username>Keyomerd</username>
        <id>8814</id>
      </contributor>
      <comment>Rûpel bi &quot;== {{ziman|ku}} ==  === Navdêr === {{navdêr|ku|z=n}} # [[Xweda]] #* {{jêder|ku|jêgirtin=Bê rahet û bê sekne yî&lt;/br&gt;Yan aşiqê '''Baxoyê''' xwe yî&lt;/br&gt;Yan şubhetê qelbê me yî&lt;/br&gt;Ji emrekî bi lez ketî|{{Jêgirtin/Feqiyê Teyran/Dîwan}}}}  ==== Etîmolojî ==== Hevreha {{g|ku|beg}}, bo agahiyên zêdetir lê binêre.  ==== Werger ==== {{werger-ser}} {{werger-bin}}&quot; hat çêkirin</comment>
      <origin>6903088</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="382" sha1="7nbi8vbc6gwpiorb3b9qdnvbvd63cgr" xml:space="preserve">== {{ziman|ku}} ==

=== Navdêr ===
{{navdêr|ku|z=n}}
# [[Xweda]]
#* {{jêder|ku|jêgirtin=Bê rahet û bê sekne yî&lt;/br&gt;Yan aşiqê '''Baxoyê''' xwe yî&lt;/br&gt;Yan şubhetê qelbê me yî&lt;/br&gt;Ji emrekî bi lez ketî|{{Jêgirtin/Feqiyê Teyran/Dîwan}}}}

==== Etîmolojî ====
Hevreha {{g|ku|beg}}, bo agahiyên zêdetir lê binêre.

==== Werger ====
{{werger-ser}}
{{werger-bin}}</text>
      <sha1>7nbi8vbc6gwpiorb3b9qdnvbvd63cgr</sha1>
    </revision>
  </page>
  <page>
    <title>xewsar</title>
    <ns>0</ns>
    <id>1359533</id>
    <revision>
      <id>6903092</id>
      <timestamp>2026-11-10T12:43:37Z</timestamp>
      <contributor>
        <username>Keyomerd</username>
        <id>8814</id>
      </contributor>
      <comment>Rûpel bi &quot;== {{ziman|ku}} ==  === Navdêr === {{navdêr|ku|z=m}} # {{guharto|ku|xûsî}} #* {{jêder|ku|jêgirtin=Bûye payîz li van waran&lt;/br&gt;Xezam weşyan binê daran&lt;/br&gt;Ji min çi dikin gelî yaran&lt;/br&gt;Li mêrgan bûye '''xewsar''' e|{{Jêgirtin/Feqiyê Teyran/Dîwan}}}}&quot; hat çêkirin</comment>
      <origin>6903092</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="266" sha1="qtqtdv4o7m4mlsjqp976poxcsrk429o" xml:space="preserve">== {{ziman|ku}} ==

=== Navdêr ===
{{navdêr|ku|z=m}}
# {{guharto|ku|xûsî}}
#* {{jêder|ku|jêgirtin=Bûye payîz li van waran&lt;/br&gt;Xezam weşyan binê daran&lt;/br&gt;Ji min çi dikin gelî yaran&lt;/br&gt;Li mêrgan bûye '''xewsar''' e|{{Jêgirtin/Feqiyê Teyran/Dîwan}}}}</text>
      <sha1>qtqtdv4o7m4mlsjqp976poxcsrk429o</sha1>
    </revision>
  </page>
  <page>
    <title>Şablon:Jêgirtin/Feqiyê Teyran/Dîwan</title>
    <ns>10</ns>
    <id>1359534</id>
    <redirect title="Şablon:J:Feqiyê Teyran" />
    <revision>
      <id>6903095</id>
      <timestamp>2026-11-10T15:43:22Z</timestamp>
      <contributor>
        <username>Wikihez</username>
        <id>7344</id>
      </contributor>
      <comment>Ji bo [[Şablon:J:Feqiyê Teyran]] hat beralîkirin</comment>
      <origin>6903095</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="42" sha1="gnr4x2xghihkx424t74llj800d9sqq1" xml:space="preserve">#BERALÎKIRIN [[Şablon:J:Feqiyê Teyran]]</text>
      <sha1>gnr4x2xghihkx424t74llj800d9sqq1</sha1>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Gadget-wikt.start-wizard/form.js</title>
    <ns>8</ns>
    <id>1359535</id>
    <revision>
      <id>6903100</id>
      <timestamp>2026-11-10T21:26:08Z</timestamp>
      <contributor>
        <username>Wikihez</username>
        <id>7344</id>
      </contributor>
      <comment>Split the wizard's script pages under 100 KB; identifierOf shared from citoid-helper</comment>
      <origin>6903100</origin>
      <model>javascript</model>
      <format>text/javascript</format>
      <text bytes="64487" sha1="l9lde63h0wlcvy0qbnu66bdr1zxu9c5" xml:space="preserve">// &lt;nowiki&gt;
/*
 * Page: [[MediaWiki:Gadget-wikt.start-wizard/form.js]]
 *
 * The parts of [[MediaWiki:Gadget-wikt.start-wizard.js]] that build the form, restore a draft into it and
 * open Tercîh. A file of the same module, called with ctx: the wizard's helpers and state.
 */
module.exports = function (ctx) {
	var PER_SECTION_STEP_IDS = ctx.PER_SECTION_STEP_IDS;
	var STEP_GROUPS = ctx.STEP_GROUPS;
	var WIKTKU_SUGGESTIONS_KEY_PREFIX = ctx.WIKTKU_SUGGESTIONS_KEY_PREFIX;
	var addLangMode = ctx.addLangMode;
	var buildKeyInput = ctx.buildKeyInput;
	var capitalize = ctx.capitalize;
	var destroy = ctx.destroy;
	var findLangHeader = ctx.findLangHeader;
	var formCache = ctx.formCache;
	var getValues = ctx.getValues;
	var getValuesForStep = ctx.getValuesForStep;
	var getWikitext = ctx.getWikitext;
	var highlightLinebreak = ctx.highlightLinebreak;
	var initSelects = ctx.initSelects;
	var insertNewLangSection = ctx.insertNewLangSection;
	var isWordGroupCls = ctx.isWordGroupCls;
	var langHeaderSource = ctx.langHeaderSource;
	var makeModifierLi = ctx.makeModifierLi;
	var makeTrashButton = ctx.makeTrashButton;
	var ordered_steps = ctx.ordered_steps;
	var populateMenus = ctx.populateMenus;
	var prepareInput = ctx.prepareInput;
	var refresh = ctx.refresh;
	var refreshForTextField = ctx.refreshForTextField;
	var renderBesenDinPicker = ctx.renderBesenDinPicker;
	var renderGroupTabs = ctx.renderGroupTabs;
	var scrollTabBarIntoView = ctx.scrollTabBarIntoView;
	var seedOpenedFromContent = ctx.seedOpenedFromContent;
	var snapshotDfn = ctx.snapshotDfn;
	var splitTercimeIzah = ctx.splitTercimeIzah;
	var stepIdToGroup = ctx.stepIdToGroup;
	var steps = ctx.steps;
	var wiktkuCite = ctx.wiktkuCite;
	var wiktkuEdit = ctx.wiktkuEdit;
	var wiktkuInitManualResize = ctx.wiktkuInitManualResize;
	var wiktkuLangs = ctx.wiktkuLangs;
	var wiktkuNotify = ctx.wiktkuNotify;
	var wiktkuPosparams = ctx.wiktkuPosparams;
	var wiktkuSavePrefs = ctx.wiktkuSavePrefs;
	var wiktkuUtil = ctx.wiktkuUtil;
	var wiktkuWikitext = ctx.wiktkuWikitext;
	var wordGroups = ctx.wordGroups;


	// Clears every draft cache and resize height this script writes, for all pages. Tercîh itself is
	// left alone: it is the setting being edited when this button is reached.
	// The state it touches is assigned by build(), which has always run by the time this is callable.
	function wiktkuClearAllScriptCache() {
		// Cancel the pending autosave, or it would rewrite the cache from the still-filled form.
		if (ctx.autosaveDebounceTimer) {
			clearTimeout(ctx.autosaveDebounceTimer);
			ctx.autosaveDebounceTimer = null;
		}
		ctx.formDirty = false;
		$(&quot;#wiktku-last-saved&quot;).text(&quot;&quot;);
		// Keeps formCache's in-memory copy in step with the localStorage sweep below.
		try { formCache.Set({}); } catch (e) { /* storage unavailable — the raw sweep below still runs */ }

		if (!window.localStorage) return;
		var toRemove = [];
		try {
			for (var i = 0; i &lt; localStorage.length; i++) {
				var key = localStorage.key(i);
				if (!key) continue;
				// ObjectStorage wraps the draft key as &quot;enwikt/ObjectStorage/&lt;name&gt;?v=&lt;n&gt;&amp;Type=…&quot;, so it
				// is matched as a substring; the mw.storage keys below are plain prefixes.
				if (key.indexOf(&quot;wiktku_start_draft_&quot;) !== -1 || key.indexOf(&quot;wiktku_resize_height_&quot;) === 0 ||
					key.indexOf(WIKTKU_SUGGESTIONS_KEY_PREFIX) === 0) {
					toRemove.push(key);
				}
			}
		} catch (e) { return; }

		$.each(toRemove, function (_, key) {
			try { localStorage.removeItem(key); } catch (e) { /* skip this key, keep clearing the rest */ }
		});
	}

	// Lazily built the first time it's opened; reused after that (see
	// wiktkuOpenPrefsDialog below, defined once we know OOUI is available).
	var wiktkuPrefsWindowManager = null;
	var wiktkuPrefsDialog = null;

	function wiktkuOpenPrefsDialog() {
		mw.loader.using([&quot;oojs-ui-core&quot;, &quot;oojs-ui-windows&quot;], function () {
			function WiktkuPrefsDialog(config) {
				WiktkuPrefsDialog.super.call(this, config);
			}
			if (!wiktkuPrefsDialog) {
				
				OO.inheritClass(WiktkuPrefsDialog, OO.ui.ProcessDialog);
				WiktkuPrefsDialog.static.name = &quot;wiktkuPrefsDialog&quot;;
				WiktkuPrefsDialog.static.title = &quot;Tercîhên min&quot;;
				WiktkuPrefsDialog.static.actions = [
					{ action: &quot;save&quot;, label: &quot;Qeyd bike&quot;, flags: [&quot;primary&quot;, &quot;progressive&quot;] },
					{ action: &quot;cancel&quot;, label: wiktkuUtil.msg.cancel, flags: &quot;safe&quot; },
					{ action: &quot;clearcache&quot;, label: &quot;Hemû cache paqij bike&quot;, flags: &quot;destructive&quot; }
				];

				WiktkuPrefsDialog.prototype.initialize = function () {
					WiktkuPrefsDialog.super.prototype.initialize.call(this);

					this.langCodesInput = new OO.ui.TextInputWidget({
						placeholder: &quot;ku, zza, ckb (vala bihêle ji bo hemû zimanan)&quot;
					});
					this.onlyOnClickCheckbox = new OO.ui.CheckboxInputWidget({});
					this.quietCheckbox = new OO.ui.CheckboxInputWidget({});
					this.portletDropdown = new OO.ui.DropdownInputWidget({
						options: [
							{ data: &quot;auto&quot;, label: &quot;Otomatîk (li gorî rûyê wîkiyê)&quot; },
							{ data: &quot;p-cactions&quot;, label: &quot;p-cactions - Li qismê Amûran&quot; },
							{ data: &quot;left-navigation&quot;, label: &quot;left-navigation - Li qismê Gotar-Gotûbêj&quot; },
							{ data: &quot;p-tb&quot;, label: &quot;p-tb - Li qismê Giştî&quot; },
							{ data: &quot;p-views&quot;, label: &quot;p-views - Li qismê Bixwîne&quot; }
						]
					});

					// Two named groups rather than one &quot;Eyar&quot; heap: which languages the wizard offers, then
					// how it behaves. The dialog title already says these are preferences.
					var langSet = new OO.ui.FieldsetLayout({ label: &quot;Ziman&quot; });
					langSet.addItems([
						new OO.ui.FieldLayout(this.langCodesInput, {
							label: &quot;Kodên zimanan ên ku tê xuyakirin li qismê \&quot;ziman\&quot;&quot;,
							align: &quot;top&quot;,
							help: &quot;Kodan bi virgulê (,) ji hev veqetîne. Vala bihêle da ku hemû ziman werin nîşandan.&quot;,
							helpInline: true
						})
					]);

					var behaviourSet = new OO.ui.FieldsetLayout({ label: &quot;Wextê xebitînê&quot; });
					behaviourSet.addItems([
						new OO.ui.FieldLayout(this.onlyOnClickCheckbox, {
							label: &quot;Tenê veke wextê \&quot;+Ziman/beşeke din\&quot; were tikandin&quot;,
							align: &quot;inline&quot;,
							help: &quot;Eger were hilbijartin, ev amûr êdî otomatîk li ser rûpelên nû dest pê nake — divê meriv her carê pêl \&quot;+Ziman/beşeke din\&quot; bike ku bişixule.&quot;,
							helpInline: true
						}),
						new OO.ui.FieldLayout(this.portletDropdown, {
							label: &quot;Cihê lînka \&quot;+Ziman/beşeke din\&quot;&quot;,
							align: &quot;top&quot;,
							help: &quot;\&quot;Otomatîk\&quot; li gorî rûyê wîkiyê hildibijêre.&quot;,
							helpInline: true
						}),
						new OO.ui.FieldLayout(this.quietCheckbox, {
							label: &quot;Moda bêdeng (kêmtir agahdarî nîşan bide)&quot;,
							align: &quot;inline&quot;,
							help: &quot;Agahdariyên normal nîşan nede. Xeta her tim tên xuyakirin.&quot;,
							helpInline: true
						})
					]);

					this.$element.addClass(&quot;wiktku-prefs-dialog&quot;);
					this.$body.addClass(&quot;wiktku-prefs-dialog-body&quot;)
						.append(langSet.$element, behaviourSet.$element);
				};

				WiktkuPrefsDialog.prototype.getSetupProcess = function (data) {
					return WiktkuPrefsDialog.super.prototype.getSetupProcess.call(this, data)
						.next(function () {
							this.langCodesInput.setValue(ctx.wiktkuPrefs.langCodes.join(&quot;, &quot;));
							this.onlyOnClickCheckbox.setSelected(!!ctx.wiktkuPrefs.onlyOnClick);
							this.portletDropdown.setValue(ctx.wiktkuPrefs.portlet || &quot;auto&quot;);
							this.quietCheckbox.setSelected(!!ctx.wiktkuPrefs.quiet);
						}, this);
				};

				WiktkuPrefsDialog.prototype.getActionProcess = function (action) {
					var dialog = this;
					if (action === &quot;save&quot;) {
						return new OO.ui.Process(function () {
							var codes = dialog.langCodesInput.getValue()
								.split(/[,\s]+/)
								.map(function (c) { return c.trim().toLowerCase(); })
								.filter(function (c) { return !!c; });

							ctx.wiktkuPrefs = {
								langCodes: codes,
								onlyOnClick: dialog.onlyOnClickCheckbox.isSelected(),
								portlet: dialog.portletDropdown.getValue() || &quot;auto&quot;,
								quiet: dialog.quietCheckbox.isSelected()
							};
							wiktkuSavePrefs(ctx.wiktkuPrefs);
							mw.notify(
								&quot;Tercîh hatin qeydkirin. Rûpelê ji nû ve bar bike (F5).&quot;,
								{ type: &quot;success&quot;, tag: &quot;wiktku-prefs-save&quot; }
							);
							dialog.close({ action: &quot;save&quot; });
						});
					}
					if (action === &quot;cancel&quot;) {
						return new OO.ui.Process(function () {
							dialog.close({ action: &quot;cancel&quot; });
						});
					}
					if (action === &quot;clearcache&quot;) {
						return new OO.ui.Process(function () {
							if (!window.confirm(
								&quot;Tu dixwazî hemû cache-ya vê amûrê ji her rûpelê paqij bikî &quot; +
								&quot;(danûstandinên qeydkirî yên hemû rûpelan, bilindahiyên qutiyan)? &quot; +
								&quot;Tercîhên li jor nayên jêbirin. Ev tişt nayê vegerandin.&quot;
							)) return;
							wiktkuClearAllScriptCache();
							mw.notify(&quot;Hemû cache hate paqijkirin.&quot;, { type: &quot;success&quot;, tag: &quot;wiktku-cache-clear-all&quot; });
							dialog.close({ action: &quot;clearcache&quot; });
						});
					}
					return WiktkuPrefsDialog.super.prototype.getActionProcess.call(this, action);
				};

				wiktkuPrefsWindowManager = new OO.ui.WindowManager();
				$(document.body).append(wiktkuPrefsWindowManager.$element);
				wiktkuPrefsDialog = new WiktkuPrefsDialog();
				wiktkuPrefsWindowManager.addWindows([wiktkuPrefsDialog]);
			}
			wiktkuPrefsWindowManager.openWindow(wiktkuPrefsDialog);
		});
	}

	// Rebuilds the dfn DOM from a previously snapshotted senses array.
	function restoreDfn(senses) {
		var stepDiv = $(&quot;#wiktku-start-dfn&quot;);
		// Tear down the existing tab bar + list so build() recreates them cleanly.
		stepDiv.find(&quot;.wiktku-dfn-sense-tabs&quot;).remove();
		stepDiv.find(&quot;ol.wiktku-dfn-list&quot;).remove();
		steps.dfn.build(stepDiv);

		var list = stepDiv.find(&quot;ol.wiktku-dfn-list&quot;);

		$.each(senses, function (i, sense) {
			// Ensure enough blocks exist (build() seeds one).
			var blocks = list.find(&quot;li.wiktku-dfn-sense&quot;);
			var block = blocks.eq(i);
			if (!block.length) {
				var nb = steps.dfn.buildSenseBlock(stepDiv);
				list.append(nb);
				block = list.find(&quot;li.wiktku-dfn-sense&quot;).last();
			}

			// Template selector.
			block.find(&quot;select.wiktku-dfn-tpl-select&quot;).val(sense.tpl || &quot;&quot;);
			if (sense.tpl) {
				block.find(&quot;textarea.wiktku-dfn-mane&quot;).hide();
				block.find(&quot;input.wiktku-dfn-tpl-title&quot;).val(sense.tplTitle || &quot;&quot;).show();
				// The picker is collapsed behind a link by default; a restored
				// sense that already uses a template has to show it, or the
				// chosen template is invisible and looks lost.
				var reveal = block.data(&quot;revealTplRow&quot;);
				if (typeof reveal === &quot;function&quot;) reveal();
			} else {
				block.find(&quot;textarea.wiktku-dfn-mane&quot;).val(sense.mane || &quot;&quot;).show();
				block.find(&quot;input.wiktku-dfn-tpl-title&quot;).hide().val(&quot;&quot;);
			}

			// dfnArea is the only thing actually saved, so split it back into
			// tercime/îzah for editing (mirrors syncNonKuToMane's join format).
			var maneParts = splitTercimeIzah(sense.mane);
			block.find(&quot;textarea.wiktku-dfn-mane&quot;).val(maneParts ? $.trim(maneParts.tercime) : (sense.mane || &quot;&quot;));
			block.find(&quot;.wiktku-dfn-izah&quot;).val(maneParts ? $.trim(maneParts.izah) : &quot;&quot;);
			var setIzahOpen = block.data(&quot;setIzahOpen&quot;);
			if (setIzahOpen) setIzahOpen(!!(maneParts &amp;&amp; $.trim(maneParts.izah)));

			// Re-sync the formên alternatîv/hevmane/… hide state now that
			// tplSelect's value was set (its own &quot;change&quot;
			// handler doesn't fire from .val(), so this doesn't happen otherwise).
			var updateVis = block.data(&quot;updateFieldVisibility&quot;);
			if (updateVis) updateVis();

			// Same for the mane-box mode (plain vs tercime+îzah), since this
			// also depends on tplSelect's (and lang's) value.
			var updateMane = block.data(&quot;updateManeMode&quot;);
			if (updateMane) updateMane();

			// Restore a sub-list (etiket, formên alternatîv, hevmane …) from a values array.
			function restoreSubList(cls, values) {
				if (!values || !values.length) return;
				var groupDiv = block.find(&quot;.&quot; + cls + &quot;-group&quot;);
				var subList = groupDiv.find(&quot;ol, ul&quot;).first();
				if (!subList.length) return; // group not found
				var useModifiers = isWordGroupCls(cls);
				// Fill existing items, append new ones as needed.
				$.each(values, function (j, val) {
					var items = subList.find(&quot;li&quot;);
					if (j &lt; items.length) {
						// useModifiers rows keep the word and its modifier tags in
						// separate elements (see makeModifierLi) — setRawValue()
						// re-splits val() the same way parsing it fresh would,
						// instead of dumping the raw &quot;word&lt;key:value&gt;&quot; string into
						// the visible word box.
						var setRaw = items.eq(j).data(&quot;setRawValue&quot;);
						if (useModifiers &amp;&amp; typeof setRaw === &quot;function&quot;) {
							setRaw(val);
						} else {
							items.eq(j).find(&quot;textarea&quot;).val(val);
						}
					} else {
						var ta = $(&quot;&lt;textarea&gt;&lt;/textarea&gt;&quot;)
							.attr(&quot;name&quot;, &quot;wiktku-dfn-restore-&quot; + $.now() + &quot;-&quot; + Math.random().toString(36).substr(2, 9))
							.attr(&quot;rows&quot;, 1)
							.attr(&quot;class&quot;, &quot;wiktku-dfn-subfield wiktku-start-narrow&quot;)
							.val(val);
						ta.on(&quot;input&quot;, function () {
							steps.dfn.onSubInput(subList, this, 1, true, useModifiers);
						});
						subList.append(useModifiers ? makeModifierLi(ta) : $(&quot;&lt;li&gt;&lt;/li&gt;&quot;).append(ta));
					}
				});
				if (!useModifiers) return;
				// A fresh empty row goes on the end so there's always somewhere
				// to add the next word without first having to click into a
				// filled one.
				var filled = subList.find(&quot;li.wiktku-word-li&quot;);
				if (filled.last().is(&quot;:last-child&quot;)) {
					var nextTa = $(&quot;&lt;textarea&gt;&lt;/textarea&gt;&quot;)
						.attr(&quot;name&quot;, &quot;wiktku-dfn-restore-next-&quot; + $.now() + &quot;-&quot; + Math.random().toString(36).substr(2, 9))
						.attr(&quot;rows&quot;, 1)
						.attr(&quot;class&quot;, &quot;wiktku-dfn-subfield wiktku-start-narrow&quot;);
					nextTa.on(&quot;input&quot;, function () {
						steps.dfn.onSubInput(subList, this, 1, true, useModifiers);
					});
					subList.append(makeModifierLi(nextTa));
				}
			}

			// Populate the word lists that the draft has something for. senseGroups' &quot;field&quot; is both the
			// property getSenses() read them into and the tail of the box's own class.
			$.each(wordGroups(), function (_, g) {
				var vals = sense[g.field];
				if (vals &amp;&amp; vals.length) restoreSubList(g.cls, vals);
			});

			// Dever/Şîwe, Etîket, Kategorî — chip fields, not textarea
			// sub-lists, restored via the adders buildSenseBlock stashed on
			// the block.
			block.find(&quot;input.wiktku-dfn-maneid-input&quot;).val(sense.maneid || &quot;&quot;);

			var chipRestoreMap = {
				addDeverChip:    sense.dever,
				addEtiketChip:   sense.etiket,
				addKategoriChip: sense.kategori
			};
			$.each(chipRestoreMap, function (dataKey, vals) {
				var addChip = block.data(dataKey);
				if (addChip &amp;&amp; vals &amp;&amp; vals.length) {
					$.each(vals, function (_, v) { addChip(v); });
				}
			});

			// Nimûne items are objects { text, tr?, t? } — restore using the builder.
			if (sense.nimune &amp;&amp; sense.nimune.length) {
				var nimuneGroupDiv = block.find(&quot;.wiktku-dfn-nimune-group&quot;);
				var nimuneList = nimuneGroupDiv.find(&quot;ol.wiktku-dfn-nimune-list&quot;);
				var buildFn = nimuneGroupDiv.data(&quot;buildNimuneLi&quot;);
				nimuneList.empty();
				$.each(sense.nimune, function (_, n) {
					var text = typeof n === &quot;object&quot; ? (n.text || &quot;&quot;) : n;
					if (!text) return;
					var li = buildFn ? buildFn() : $(&quot;&lt;li class='wiktku-dfn-nimune-li'&gt;&lt;/li&gt;&quot;);
					li.find(&quot;.wiktku-dfn-nimune-text&quot;).val(text).each(function () { highlightLinebreak(this); });
					if (n.tr) li.find(&quot;.wiktku-dfn-nimune-tr&quot;).val(n.tr);
					if (n.t)  li.find(&quot;.wiktku-dfn-nimune-t&quot;).val(n.t);
					nimuneList.append(li);
				});
				// Always leave a blank trailing item.
				if (buildFn) nimuneList.append(buildFn());
			}

			// Restore jêder entries — accepts current array shape or a legacy
			// single object (older saved sections) for backwards compat.
			var jederArr = $.isArray(sense.jeder) ? sense.jeder : (sense.jeder ? [sense.jeder] : []);
			if (jederArr.length) {
				var jederGroupDiv = block.find(&quot;.wiktku-dfn-jeder-group&quot;);
				var jederList = jederGroupDiv.find(&quot;ol.wiktku-dfn-jeder-list&quot;);
				var buildJederFn = jederGroupDiv.data(&quot;buildJederLi&quot;);
				jederList.empty();
				$.each(jederArr, function (_, j) {
					if (!j || !j.quote) return;
					var li = buildJederFn ? buildJederFn() : $(&quot;&lt;li class='wiktku-dfn-jeder-li'&gt;&lt;/li&gt;&quot;);
					li.find(&quot;.wiktku-dfn-nimune-quote&quot;).val(j.quote).each(function () { highlightLinebreak(this); });
					if (j.quoteTr) li.find(&quot;.wiktku-dfn-nimune-quote-tr&quot;).val(j.quoteTr);
					if (j.quoteT)  li.find(&quot;.wiktku-dfn-nimune-quote-t&quot;).val(j.quoteT);
					if (j.url) li.find(&quot;.wiktku-dfn-quote-url&quot;).val(j.url);
					if (j.jederManual) {
						var manualSel = li.find(&quot;.wiktku-dfn-quote-src-sel&quot;);
						manualSel.val(&quot;__manual__&quot;).trigger(&quot;change&quot;);
						li.find(&quot;.wiktku-dfn-quote-src-manual&quot;).val(j.jederManual);
					} else if (j.raw) {
						li.find(&quot;.wiktku-dfn-quote-src-sel&quot;).val(&quot;__raw__&quot;).trigger(&quot;change&quot;);
					} else if (j.jederCatTpl) {
						// Reopen the category picker on the saved template and put its fields back. The
						// fields arrive asynchronously (TemplateData), so the saved values are applied
						// once they exist rather than straight away.
						var catSelEl = li.find(&quot;.wiktku-dfn-quote-src-sel&quot;);
						catSelEl.val(&quot;__category__&quot;).trigger(&quot;change&quot;);
						li.data(&quot;catTemplate&quot;, j.jederCatTpl);
						if (j.jederCatLangParam) li.data(&quot;catLangParam&quot;, j.jederCatLangParam);
						li.find(&quot;.wiktku-dfn-quote-src-cat-input&quot;).val(j.jederCatTpl);
						// Kept on the row from the moment the restore starts. Submitting walks every section
						// -- restore, then read -- and the read is synchronous while the boxes below only
						// exist once TemplateData comes back, so without this the values are read from boxes
						// that are not there yet and every parameter but the quote is lost. readJederList()
						// falls back to these until the boxes catch up.
						li.data(&quot;catFields&quot;, j.jederCatFields || {});
						wiktkuCite.fieldSpecs(j.jederCatTpl).then(function (spec) {
							var srcFields = li.find(&quot;.wiktku-dfn-quote-src-fields&quot;);
							li.data(&quot;catLangParam&quot;, j.jederCatLangParam || spec.langParamKey || null);
							$.each(spec.fields, function (_, field) {
								srcFields.append(li.data(&quot;buildSrcFieldRow&quot;)(field));
							});
							$.each(j.jederCatFields || {}, function (key, val) {
								li.find(&quot;.wiktku-dfn-quote-src-input[data-field-key='&quot; + key + &quot;']&quot;).val(val);
							});
							// The boxes hold them now, so they are the truth again -- clearing this keeps a
							// field the user empties from being refilled from the stale copy.
							li.removeData(&quot;catFields&quot;);
						});
					} else if (j.jederTpl) {
						var srcSel = li.find(&quot;.wiktku-dfn-quote-src-sel&quot;);
						srcSel.val(j.jederTpl).trigger(&quot;change&quot;);
						if (j.jêderFields) {
							$.each(j.jêderFields, function (key, val) {
								li.find(&quot;.wiktku-dfn-quote-src-input[data-field-key='&quot; + key + &quot;']&quot;).val(val);
							});
						}
					}
					jederList.append(li);
				});
				// Always leave a blank trailing item, same as Nimûne.
				if (buildJederFn) jederList.append(buildJederFn());
			}
		});

		// Unlike addSense(), build()/buildSenseBlock() above don't wrap their own &lt;select&gt;s -- do it once for the whole restored list (idempotent, so already-wrapped selects are skipped).
		initSelects(list);

		// Everything above filled boxes that are still behind the chip row, so each block is asked to
		// show whichever of its sub-fields the draft actually had something in.
		list.find(&quot;li.wiktku-dfn-sense&quot;).each(function () {
			var syncPicks = $(this).data(&quot;syncSensePicks&quot;);
			if (syncPicks) syncPicks();
		});

		// Restoring a draft opens the first sense's tab by default.
		steps.dfn.setOpenSense(stepDiv, list.find(&quot;li.wiktku-dfn-sense&quot;).first());
	}

	// Snapshots simple (non-dfn) per-section steps from the DOM into obj.
	function saveCurrentSection() {
		var snap = {};
		$.each(PER_SECTION_STEP_IDS, function (_, id) {
			if (id === &quot;dfn&quot;) {
				snap.dfn = snapshotDfn();
				return;
			}
			if (id === &quot;etym&quot;) {
				snap.etym = $.trim($(&quot;#wiktku-start-etym .wiktku-etym-text&quot;).val());
				return;
			}
			if (id === &quot;cavkani&quot;) {
				snap.cavkani = $.trim($(&quot;#wiktku-start-cavkani .wiktku-cavkani-text&quot;).val());
				return;
			}
			if (id === &quot;posparams&quot;) {
				snap.posparams = $.trim($(&quot;#wiktku-start-posparams .wiktku-posparams-text&quot;).val());
				return;
			}
			if (id === &quot;resim&quot;) {
				// One entry per row, including blank ones, so a mid-edit draft
				// (e.g. a filename typed but no caption yet) survives a cache
				// restore instead of being silently dropped.
				snap.resim = $(&quot;#wiktku-start-resim li.wiktku-resim-item&quot;).map(function () {
					return {
						file:    $.trim($(this).find(&quot;.wiktku-resim-file&quot;).val()),
						caption: $.trim($(this).find(&quot;.wiktku-resim-caption&quot;).val()),
						alt:     $.trim($(this).find(&quot;.wiktku-resim-alt&quot;).val())
					};
				}).get();
				return;
			}
			var step = steps[id];
			if (!step) return;
			var stepDiv = $(&quot;#wiktku-start-&quot; + id);
			if (id === &quot;trans&quot;) {
				snap.trans = steps.trans.getTranslations(stepDiv);
				return;
			}
			if (id === &quot;zarava&quot;) {
				snap.zarava = steps.zarava.getTranslations(stepDiv);
				return;
			}
			if (id === &quot;dunde&quot;) {
				snap.dunde = steps.dunde.getRows(stepDiv);
				return;
			}
			// Generic: read all step fields.
			var fields = stepDiv.find(&quot;.wiktku-start-step-field&quot;);
			if (step.multiple) {
				snap[id] = fields.map(function () { return $(this).val(); }).get();
			} else {
				snap[id] = fields.val();
			}
		});
		// Which &quot;Beşên din&quot; sub-sections this section has already opened
		// via the picker — per-section, like everything else here.
		snap.openedOtherSections = $.extend({}, ctx.openedOtherSections);
		ctx.sections[ctx.activeSection] = snap;
	}

	// Restores a previously saved snapshot into the form DOM.
	function restoreSection(snap) {
		$.each(PER_SECTION_STEP_IDS, function (_, id) {
			if (id === &quot;dfn&quot;) {
				restoreDfn(snap.dfn || []);
				return;
			}
			if (id === &quot;etym&quot;) {
				$(&quot;#wiktku-start-etym .wiktku-etym-wrap&quot;).remove();
				steps.etym.build($(&quot;#wiktku-start-etym&quot;));
				$(&quot;#wiktku-start-etym .wiktku-etym-text&quot;).val(snap.etym || &quot;&quot;);
				return;
			}
			if (id === &quot;cavkani&quot;) {
				$(&quot;#wiktku-start-cavkani .wiktku-cavkani-wrap&quot;).remove();
				steps.cavkani.build($(&quot;#wiktku-start-cavkani&quot;));
				$(&quot;#wiktku-start-cavkani .wiktku-cavkani-text&quot;).val(snap.cavkani || &quot;&quot;);
				return;
			}
			if (id === &quot;posparams&quot;) {
				var ppDiv = $(&quot;#wiktku-start-posparams&quot;);
				ppDiv.find(&quot;.wiktku-posparams-step&quot;).remove();
				steps.posparams.build(ppDiv);
				var savedTa = snap.posparams || &quot;&quot;;
				ppDiv.find(&quot;.wiktku-posparams-text&quot;).val(savedTa);
				// Re-parse saved textarea to restore helper widget states.
				if (savedTa) {
					// Read with the shared parser, so a nested &quot;c=&quot; is never taken for the call's own, and a
					// saved &quot;z=&quot; restores the gender the same as &quot;c=&quot;.
					var savedC = wiktkuWikitext.callParamValue(savedTa, &quot;c&quot;);
					var savedJ = wiktkuWikitext.callParamValue(savedTa, &quot;j&quot;);
					var savedTr = wiktkuWikitext.callParamValue(savedTa, &quot;tr&quot;);
					// Write into the shared hidden field (not the visible
					// select, which has no &lt;option&gt;s yet) — syncHelpers()
					// below reads it back to restore the dropdown once the
					// gender/number options for this language are populated.
					if (savedC) $(&quot;#wiktku-start-cinsiyet-field&quot;).val(savedC);
					if (savedJ) $(&quot;#wiktku-start-jimar-field&quot;).val(savedJ);
					if (savedTr) ppDiv.find(&quot;.wiktku-posparams-field[data-pp-key='tr']&quot;).val(savedTr);
					// For lêker, c= holds the verb-type code instead of a
					// gender — split it back across the two dropdowns it is
					// now assembled from (&quot;x-gh&quot; → form &quot;x&quot; + base &quot;gh&quot;).
					if (savedC &amp;&amp; /^lêker/.test(snap.pos || &quot;&quot;)) {
						var lekturParts = /^(?:([xphb])-)?(n?gh)$/.exec(savedC);
						if (lekturParts) {
							ppDiv.find(&quot;.wiktku-posparams-lektur-sel&quot;).val(lekturParts[2]);
							ppDiv.find(&quot;.wiktku-posparams-lekturform-sel&quot;).val(lekturParts[1] || &quot;&quot;);
						}
					}
					// Restore checked optional params via the same param/value overrides rebuildTa uses.
					ppDiv.find(&quot;.wiktku-posparams-opt-panel input[type='checkbox']&quot;).each(function () {
						var key = $(this).val();
						var override = wiktkuPosparams.OPT_PARAM_OVERRIDES[key];
						var needle = override ? &quot;|&quot; + override.param + &quot;=&quot; + override.value : &quot;|&quot; + key + &quot;=1&quot;;
						$(this).prop(&quot;checked&quot;, savedTa.indexOf(needle) !== -1);
					});
				}
				steps.posparams.syncHelpers(ppDiv);
				return;
			}
			if (id === &quot;resim&quot;) {
				var resimDiv = $(&quot;#wiktku-start-resim&quot;);
				resimDiv.find(&quot;.wiktku-resim-wrap&quot;).remove();
				steps.resim.build(resimDiv);
				// Accept both the new array-of-rows format and the older
				// single {file, caption} object saved before multi-image
				// support existed.
				var resimSnap = snap.resim;
				var rows = $.isArray(resimSnap) ? resimSnap : (resimSnap ? [resimSnap] : []);
				// setValues() keeps a blank trailing row of its own, same as Nimûne/Dûnde.
				if (rows.length &amp;&amp; steps.resim.field) steps.resim.field.setValues(rows);
				return;
			}
			if (id === &quot;trans&quot;) {
				// Rebuild trans groups (dfn must already be restored by this
				// point in the $.each loop, so glossList() reflects it).
				var transDiv = $(&quot;#wiktku-start-trans&quot;);
				transDiv.find(&quot;.wiktku-trans-group&quot;).remove();
				steps.trans.build(transDiv);
				var groupsSnap = snap.trans || [];
				$.each(groupsSnap, function (gi, rows) {
					var group = transDiv.find(&quot;.wiktku-trans-group[data-gloss-pos='&quot; + gi + &quot;']&quot;);
					if (!group.length) return; // gloss no longer exists — drop its rows
					var list = group.find(&quot;ul.wiktku-trans-list&quot;);
					$.each(rows, function (j, row) {
						var lang = row[0], words = row[1];
						var lastRow = list.find(&quot;li.wiktku-trans-row&quot;).last();
						lastRow.find(&quot;select&quot;).val(lang).trigger(&quot;change&quot;);
						var wordList = lastRow.find(&quot;ul.wiktku-trans-words&quot;);
						$.each(words, function (k, word) {
							var wordItems = wordList.find(&quot;li&quot;);
							if (k &lt; wordItems.length) {
								wordItems.eq(k).find(&quot;textarea&quot;).val(word);
							} else {
								// .val() below doesn't fire &quot;input&quot;, so the normal
								// auto-grow never runs — append a matching item
								// ourselves instead of silently dropping the word.
								var extraInput = steps.trans.makeWordInput();
								wordList.append($(&quot;&lt;li&gt;&lt;/li&gt;&quot;).append(extraInput));
								extraInput.val(word);
							}
						});
						// Leave one trailing empty field so the row can still grow
						// when the user types, matching a freshly-built row.
						if ($.trim(wordList.children(&quot;li&quot;).last().find(&quot;textarea&quot;).val())) {
							wordList.append($(&quot;&lt;li&gt;&lt;/li&gt;&quot;).append(steps.trans.makeWordInput()));
						}
					});
				});
				return;
			}
			if (id === &quot;zarava&quot;) {
				// Rebuild zarava groups (dfn must already be restored by this
				// point in the $.each loop, so glossList() reflects it).
				var zaravaDiv = $(&quot;#wiktku-start-zarava&quot;);
				zaravaDiv.find(&quot;.wiktku-zarava-group&quot;).remove();
				steps.zarava.build(zaravaDiv);
				var zaravaGroupsSnap = snap.zarava || [];
				$.each(zaravaGroupsSnap, function (gi, rows) {
					var group = zaravaDiv.find(&quot;.wiktku-zarava-group[data-gloss-pos='&quot; + gi + &quot;']&quot;);
					if (!group.length) return; // gloss no longer exists — drop its rows
					var list = group.find(&quot;ul.wiktku-zarava-list&quot;);
					$.each(rows, function (j, row) {
						var lang = row[0], words = row[1];
						var lastRow = list.find(&quot;li.wiktku-zarava-row&quot;).last();
						lastRow.find(&quot;select&quot;).val(lang).trigger(&quot;change&quot;);
						var wordList = lastRow.find(&quot;ul.wiktku-zarava-words&quot;);
						$.each(words, function (k, word) {
							var wordItems = wordList.find(&quot;li&quot;);
							if (k &lt; wordItems.length) {
								wordItems.eq(k).find(&quot;textarea&quot;).val(word);
							} else {
								var extraInput = steps.zarava.makeWordInput();
								wordList.append($(&quot;&lt;li&gt;&lt;/li&gt;&quot;).append(extraInput));
								extraInput.val(word);
							}
						});
						if ($.trim(wordList.children(&quot;li&quot;).last().find(&quot;textarea&quot;).val())) {
							wordList.append($(&quot;&lt;li&gt;&lt;/li&gt;&quot;).append(steps.zarava.makeWordInput()));
						}
					});
				});
				return;
			}
			if (id === &quot;dunde&quot;) {
				// Rebuild dunde rows.
				var dundeDiv = $(&quot;#wiktku-start-dunde&quot;);
				dundeDiv.find(&quot;ul.wiktku-dunde-list&quot;).remove();
				steps.dunde.build(dundeDiv);
				var dundeRows = snap.dunde || [];
				$.each(dundeRows, function (i, row) {
					var lang = row[0], words = row[1];
					var list = dundeDiv.find(&quot;ul.wiktku-dunde-list&quot;);
					var lastRow = list.find(&quot;li.wiktku-dunde-row&quot;).last();
					lastRow.find(&quot;select&quot;).val(lang).trigger(&quot;change&quot;);
					var wordList = lastRow.find(&quot;ul.wiktku-dunde-words&quot;);
					$.each(words, function (j, word) {
						var wordItems = wordList.find(&quot;li&quot;);
						if (j &lt; wordItems.length) {
							wordItems.eq(j).find(&quot;textarea&quot;).val(word);
						} else {
							// .val() below doesn't fire &quot;input&quot;, so the normal
							// auto-grow never runs — append a matching item
							// ourselves instead of silently dropping the word.
							var extraInput = steps.dunde.makeWordInput();
							wordList.append($(&quot;&lt;li&gt;&lt;/li&gt;&quot;).append(extraInput));
							extraInput.val(word);
						}
					});
					// Leave one trailing empty field so the row can still grow
					// when the user types, matching a freshly-built row.
					if ($.trim(wordList.children(&quot;li&quot;).last().find(&quot;textarea&quot;).val())) {
						wordList.append($(&quot;&lt;li&gt;&lt;/li&gt;&quot;).append(steps.dunde.makeWordInput()));
					}
				});
				return;
			}
			var step = steps[id];
			if (!step) return;
			var stepDiv = $(&quot;#wiktku-start-&quot; + id);
			var fields = stepDiv.find(&quot;.wiktku-start-step-field&quot;);
			var val = snap[id];
			if (val === undefined || val === null) return;
			if (step.multiple) {
				var arr = val;
				fields.each(function (i) {
					if (i &lt; arr.length) $(this).val(arr[i]);
				});
			} else {
				fields.val(val);
			}
			// Tell the pickers about the programmatic value change.
			fields.filter(&quot;select&quot;).trigger(&quot;wiktku:refresh&quot;);
		});
		// Restore which &quot;Beşên din&quot; sub-sections were already opened for
		// this section, then seed in anything the DOM restore above just
		// filled in but that wasn't marked opened yet.
		ctx.openedOtherSections = $.extend({}, snap.openedOtherSections || {});
		seedOpenedFromContent();
		renderBesenDinPicker();
	}

	function build() {
		$(&quot;.nowizard, .nowizard .noafterwizard&quot;).hide();

		var callToAction = $(&quot;#wiktku-calltoaction&quot;);
		var origCallToActionText = callToAction.text();
		$(mw.util.addPortletLink(&quot;p-views&quot;, &quot;#&quot;, &quot;Edîtora çavkaniyê veke&quot;,
			&quot;ca-wiktku-nowizard&quot;, &quot;Vê rûpelê bi edîtora çavkaniyê çêke&quot;,
			undefined, &quot;#ca-watch&quot;)).click(function (evt) {
			evt.preventDefault();
			callToAction.text(origCallToActionText);
			destroy();
		});
		if (callToAction.length) {
			callToAction.text(origCallToActionText +
				&quot; Forma li jêr ji bo çêkirina madeyeke nû bi kar bîne.&quot;);
		}

		var startForm = $(&quot;&lt;form id='wiktku-start-form'&gt;&lt;/form&gt;&quot;);
		var clearPageCheck = null;
		if (addLangMode) {
			startForm.append($(&quot;&lt;p class='wiktku-addlang-notice'&gt;&lt;/p&gt;&quot;).html(
				&quot;Bi vê formê tu yê zimanekî nû li rûpelê îlawe bikî. Eger ev ziman jixwe hebe, beşa nû li dawiya vî zimanî dê were îlawekirin. &quot; +
				&quot;Ji kerema xwe netîceya dawî kontrol bike, eger problemek derkeve, li &lt;a href='&quot; +
				mw.util.getUrl('Mediawiki talk:Gadget-start.js') +
				&quot;'&gt;nîqaşa vê amûrê&lt;/a&gt; problemê ragihîne.&quot;
			));
			clearPageCheck = $(&quot;&lt;input type='checkbox' id='wiktku-clear-page-check'&gt;&quot;);
			var clearPageLabel = $(&quot;&lt;label for='wiktku-clear-page-check'&gt;&lt;/label&gt;&quot;)
				.text(&quot; Muhtewaya rûpelê paqij bike (her tiştî jê bibe û rûpelê ji nû ve binivîse)&quot;);
			startForm.append(
				$(&quot;&lt;p class='wiktku-addlang-notice'&gt;&lt;/p&gt;&quot;)
					.append(clearPageCheck)
					.append(clearPageLabel)
			);
			// Re-evaluate step visibility (e.g. the pron step) whenever this
			// is toggled, since it changes what counts as &quot;existing content&quot;.
			clearPageCheck.on(&quot;change&quot;, function () {
				refresh();
			});
		}
		var spinner;
		// Tab bar for switching between POS sections.
		var sectionTabsDiv = $(&quot;&lt;div id='wiktku-section-tabs'&gt;&lt;/div&gt;&quot;);
		// Tab bar for switching between step-groups (topics) within a section.
		// renderGroupTabs()/updateGroupTabIndicators() (which populate and
		// maintain it) live outside build() — see near &quot;var activeSection&quot;.
		var groupTabsDiv = $(&quot;&lt;div id='wiktku-group-tabs'&gt;&lt;/div&gt;&quot;);
		// Both tab bars are sticky. group-tabs sits below section-tabs' rendered height, which varies
		// when the bar wraps, so it is measured and published as a CSS custom property.
		// Vector 2022's own sticky header would cover section-tabs, so its occupied height goes into
		// --wiktku-siteheader-h. It slides with scroll, hence the re-measure on scroll as well as resize.
		function siteHeaderOffset() {
			var el = document.querySelector(&quot;.vector-sticky-header&quot;);
			if (!el) return 0;
			var rect = el.getBoundingClientRect();
			// Present in the DOM at all times on Vector 2022, but only
			// actually occupying screen space once scrolled into place —
			// before that it sits translated above the viewport (negative/
			// zero rect), which must not add a phantom gap under our bars.
			if (rect.bottom &lt;= 0 || rect.top &gt; 4) return 0;
			return Math.max(0, rect.bottom);
		}
		var stickyOffsetQueued = false;
		function syncStickyTabsOffset() {
			var h = sectionTabsDiv.is(&quot;:visible&quot;) ? (sectionTabsDiv.outerHeight() || 0) : 0;
			startForm.css(&quot;--wiktku-stabs-h&quot;, h + &quot;px&quot;);
			startForm.css(&quot;--wiktku-siteheader-h&quot;, siteHeaderOffset() + &quot;px&quot;);
		}
		function queueStickyTabsOffsetSync() {
			if (stickyOffsetQueued) return;
			stickyOffsetQueued = true;
			window.requestAnimationFrame(function () {
				stickyOffsetQueued = false;
				syncStickyTabsOffset();
			});
		}
		$(window).on(&quot;resize.wiktkuStickyTabs scroll.wiktkuStickyTabs&quot;, queueStickyTabsOffsetSync);
		// &quot;Beşên din&quot; picker — the search box for adding a section, at the top of the form;
		// renderBesenDinPicker() fills it.
		var besenDinPickerDiv = $(&quot;&lt;div id='wiktku-besendin-picker' class='wiktku-besendin-picker'&gt;&lt;/div&gt;&quot;);
		/** Puts the form back in a usable state after a failed submit and
		 *  says what happened. Without this the button stays disabled and
		 *  the spinner spins forever on any exception — the person is left
		 *  staring at a form that looks busy but is dead, with the reason
		 *  visible only in the browser console. */
		function submitFailed(err) {
			spinner.hide();
			ctx.continueBtn.setDisabled(false);
			ctx.continueBtn.$element.removeClass(&quot;wiktku-btn-sending&quot;);
			var detail = (err &amp;&amp; (err.message || err.toString())) || &quot;sedem nediyar&quot;;
			mw.notify(
				&quot;Şandin bi ser neket: &quot; + detail +
				&quot; — tiştê ku te nivîsî winda nebûye. Heke ev dubare bibe, &quot; +
				&quot;bi 'Edîtora çavkaniyê veke' berdewam bike.&quot;,
				{ type: &quot;error&quot;, tag: &quot;wiktku-submit&quot;, autoHide: false }
			);
			// Deliberately console.error as well: the notification is for the
			// person, this is for whoever they report the bug to.
			if (window.console &amp;&amp; console.error) console.error(&quot;[wiktku] submit failed&quot;, err);
		}
		ctx.onSubmitError = submitFailed;

		startForm.submit(function (evt) {
			evt.preventDefault();

			ctx.continueBtn.setDisabled(true);
			ctx.continueBtn.$element.addClass(&quot;wiktku-btn-sending&quot;);
			spinner.show();

			try {
			getWikitext(function (wikitext) {
				try {
				if (addLangMode &amp;&amp; clearPageCheck &amp;&amp; clearPageCheck.prop(&quot;checked&quot;)) {
					// User asked to wipe the page — write fresh content.
					$(&quot;#wpTextbox1&quot;).val(wikitext);
				} else if (addLangMode) {
					var textbox  = $(&quot;#wpTextbox1&quot;);
					var existing = textbox.val() || &quot;&quot;;

					// ── h-bnr merge ──────────────────────────────────────────
					// If the user filled bnr-h inputs, either merge into the
					// existing {{h-bnr|…}} call or prepend a new one.
					var bnrhOut = steps.bnrh.output(getValues());
					if (bnrhOut) {
						var newPages = bnrhOut.replace(/^\{\{h-bnr\|/, &quot;&quot;).replace(/\}\}\n?$/, &quot;&quot;).split(&quot;|&quot;);
						var bnrhRe = /\{\{h-bnr\|([^}]*)\}\}/i;
						if (bnrhRe.test(existing)) {
							existing = existing.replace(bnrhRe, function (_, inner) {
								var existingPages = inner.split(&quot;|&quot;).map(function (p) { return p.trim(); });
								$.each(newPages, function (_, p) {
									p = p.trim();
									if (p &amp;&amp; existingPages.indexOf(p) === -1) existingPages.push(p);
								});
								return &quot;{{h-bnr|&quot; + existingPages.join(&quot;|&quot;) + &quot;}}&quot;;
							});
						} else {
							existing = bnrhOut + existing;
						}
					}

					// If this language's section already exists (whitespace
					// differences aside), merge into it; otherwise insert new.
					var langHeaderMatch = wikitext.match(new RegExp(&quot;^(\n?&quot; + langHeaderSource(&quot;[^}]+&quot;) + &quot;\\n)&quot;));
					if (langHeaderMatch) {
						var langHeader = langHeaderMatch[1]; // e.g. &quot;== {{ziman|ku}} ==\n&quot;
						var newCode = langHeaderMatch[2];
						var existingHeader = findLangHeader(existing, newCode);
						if (existingHeader) {
							// Strip the header from the new output.
							var newContent = wikitext.slice(langHeader.length);

							// Find the insertion point: end of the existing lang section.
							// A new L2 heading marks the start of the next language block.
							var searchFrom = existingHeader.index + existingHeader.match.length;
							// Find the next == … == heading after this section's start.
							var nextL2 = existing.indexOf(&quot;\n== &quot;, searchFrom);
							var insertAt = nextL2 !== -1 ? nextL2 : existing.length;

							// Ensure there's a blank line before the inserted block.
							var before = existing.slice(0, insertAt);
							var after  = existing.slice(insertAt);
							var sep = /\n\s*$/.test(before) ? &quot;&quot; : &quot;\n&quot;;
							var merged = before + sep + newContent + after;

							// The section just added may repeat a part of speech the page already had. Both
							// are renumbered across the whole language section, so a lone &quot;Rengdêr&quot; that was
							// there before becomes &quot;Rengdêr 1&quot; and the new one &quot;Rengdêr 2&quot; -- leaving the old
							// one unnumbered would make the pair unreadable on the page.
							var secStart = existingHeader.index;
							var nextLang = merged.indexOf(&quot;\n== &quot;, secStart + existingHeader.match.length);
							var secEnd = nextLang === -1 ? merged.length : nextLang;
							textbox.val(
								merged.slice(0, secStart) +
								wiktkuEdit.wt.numberRepeatedPosHeadings(merged.slice(secStart, secEnd)) +
								merged.slice(secEnd)
							);
						} else {
							// New language — insert at the correct sorted position.
							textbox.val(insertNewLangSection(existing, wikitext));
						}
					} else {
						// Unexpected format — insert at sorted position anyway.
						textbox.val(insertNewLangSection(existing, wikitext));
					}
				} else {
					$(&quot;#wpTextbox1&quot;).val(wikitext);
				}
				$(&quot;html, body&quot;).animate({scrollTop: 0});
				callToAction.text(&quot;Hindik ma!&quot;);
				// The draft is now live in the editor, submitted or not — keeping
				// it cached would just offer to restore already-used content
				// the next time the wizard opens on this page.
				try { formCache.Set({}); } catch (e) { /* storage unavailable — harmless, the content is already in the editor */ }
				destroy();
				} catch (e) {
					// Thrown while writing the result into #wpTextbox1.
					submitFailed(e);
				}
			});
			} catch (e) {
				// Catches anything thrown synchronously inside getWikitext.
				submitFailed(e);
			}
		});
		// The step the &quot;Beşên din&quot; picker is inserted directly above.
		var PICKER_BEFORE_STEP = &quot;tewandin&quot;;
		// Tracks whether groupTabsDiv has been inserted yet.
		var groupTabsInserted = false;
		$.each(ordered_steps, function (i, step) {
			var stepDiv = $(mw.html.element(&quot;div&quot;, {
				&quot;class&quot;: &quot;wiktku-start-step&quot;,
				id: &quot;wiktku-start-&quot; + step.id }));
			var name = capitalize(step.name);
			var nameH3 = $(&quot;&lt;h3&gt;&lt;/h3&gt;&quot;).addClass(&quot;wiktku-start-step-name&quot;);
			var nameLabel = $(&quot;&lt;label&gt;&lt;/label&gt;&quot;)
				.attr(&quot;for&quot;, &quot;wiktku-start-&quot; + step.id + &quot;-field&quot;)
				.text(name);
			nameH3.append(nameLabel);
			stepDiv.append(nameH3);

			if (step.question_fmt) {
				// question_fmt can be a plain string, or a function of the
				// current values (used by steps whose question text depends
				// on e.g. the chosen language) — refresh() keeps it in sync
				// afterwards via the .wiktku-start-step-question class.
				var questionText = typeof step.question_fmt === &quot;function&quot;
					? step.question_fmt(getValues())
					: step.question_fmt;
				var questionLabel = $(mw.html.element(&quot;label&quot;, {
					&quot;class&quot;: &quot;wiktku-start-step-question&quot;,
					&quot;for&quot;: &quot;wiktku-start-&quot; + step.id + &quot;-field&quot; }, questionText));
				stepDiv.append(questionLabel);
			}

			var input;
			if (step.choices) {
				input = $(mw.html.element(&quot;select&quot;, {
					&quot;class&quot;: &quot;wiktku-start-step-field&quot;,
					id: &quot;wiktku-start-&quot; + step.id + &quot;-field&quot; }));
				input.attr(&quot;data-placeholder&quot;,
					capitalize(step.name) + &quot; hilbijêre &quot;);
				populateMenus(input, step.choices);
				// The language step ships ~300 languages; if a search comes up empty, fetch the other ~3400
				// and refill this select before telling the user there is no such language.
				if (step.id === &quot;lang&quot;) {
					input.data(&quot;wiktkuOnNoMatch&quot;, function (query, refresh) {
						if (!ctx.wiktkuMergeLanguages || wiktkuLangs.isFull()) {
							return;
						}
						wiktkuLangs.ensureFull().then(function (all) {
							populateMenus(input, ctx.wiktkuMergeLanguages(all));
							refresh();
						});
					});
				}
				if (step.multiple) input.attr(&quot;multiple&quot;, true);
				// initSelects() runs over the whole form once it is in the DOM.
				stepDiv.append(input);
				// Pos-specific: the definition/example for whichever cureyê
				// rêzimanî is currently chosen, as plain text right under the
				// dropdown — kept in sync by refresh() via .wiktku-start-pos-example.
				if (step.id === &quot;pos&quot;) {
					stepDiv.append(
						$(&quot;&lt;p class='wiktku-step-hint wiktku-start-pos-example'&gt;&lt;/p&gt;&quot;).text(step.example(getValues()))
					);
				}
			} else if (typeof(step.build) === &quot;function&quot;) {
				input = step.build(stepDiv);
			} else {
				input = $(&quot;&lt;textarea&gt;&lt;/textarea&gt;&quot;)
					.attr(&quot;class&quot;, &quot;wiktku-start-step-field&quot;)
					.attr(&quot;id&quot;, &quot;wiktku-start-&quot; + step.id + &quot;-field&quot;)
					.attr(&quot;rows&quot;, step.rows || 2);
				if (step.narrow) input.addClass(&quot;wiktku-start-narrow&quot;);
				if (step.placeholder) {
					input.attr(&quot;placeholder&quot;, typeof step.placeholder === &quot;function&quot; ? step.placeholder() : step.placeholder);
				}
				if (step.multiple) {
					input.on(&quot;input&quot;, function (evt) {
						refreshForTextField(evt.target, step);
					});
					var keyInput = buildKeyInput(step);
					// Same one-box-per-word layout as the per-sense ⊕-modifier
					// groups (see makeModifierLi) when this step has modifiers.
					var list = $(step.ordered ? &quot;&lt;ol&gt;&lt;/ol&gt;&quot; : &quot;&lt;ul&gt;&lt;/ul&gt;&quot;)
						.append(step.modifiers
							? makeModifierLi(input)
							: $(&quot;&lt;li&gt;&lt;/li&gt;&quot;).append(keyInput).append(input));
					stepDiv.append(list);
				}
				else stepDiv.append(input);
			}

			prepareInput(input, step);
			stepDiv.hide();
			// Section tabs (switch between POS sections) sit above the
			// per-section fields, starting at &quot;pos&quot;.
			if (step.id === &quot;pos&quot;) {
				startForm.append(sectionTabsDiv);
			}
			// Step-group tabs sit just before the first grouped step in
			// ordered_steps. Derived from stepIdToGroup so this keeps
			// working no matter how STEP_GROUPS/ordered_steps get reordered.
			if (!groupTabsInserted &amp;&amp; stepIdToGroup[step.id] !== undefined) {
				// With a single group there is nothing to switch between, so the bar is never built --
				// rather than built and then hidden, which left it on screen whenever the form was
				// rebuilt before refresh() next ran.
				if (STEP_GROUPS.length &gt; 1) {
					startForm.append(groupTabsDiv);
				}
				groupTabsInserted = true;
			}
			// The picker sits between the senses and Tewandin: sections are added underneath it, so a
			// newly picked one lands right here and pushes the rest of the form down.
			if (step.id === PICKER_BEFORE_STEP) {
				startForm.append(besenDinPickerDiv);
			}
			startForm.append(stepDiv);
		});

		// ── Section tab helpers ──────────────────────────────────────────────

		// ── Add-section button — lives in the tab bar, disabled until pos chosen ──
		var addSectionBtn = new OO.ui.ButtonWidget({
			label: &quot;+ Beşeke din&quot;,
			disabled: true,
			classes: [ &quot;wiktku-add-sense-btn&quot; ]
		});
		/** Adds a new, empty POS section and switches to it. */
		function addPosSection() {
			saveCurrentSection();
			ctx.viewingPron = false;
			ctx.sections.push({});
			ctx.activeSection = ctx.sections.length - 1;
			$.each(PER_SECTION_STEP_IDS, function (_, id) {
				// Declared once here rather than with `var` in the &quot;dfn&quot;
				// branch and again in the fallback branch below — each
				// branch returns before the other runs, but both are
				// lexically in this same function scope.
				var stepDiv;
				if (id === &quot;dfn&quot;) {
					stepDiv = $(&quot;#wiktku-start-dfn&quot;);
					stepDiv.find(&quot;.wiktku-dfn-sense-tabs&quot;).remove();
					stepDiv.find(&quot;ol.wiktku-dfn-list&quot;).remove();
					steps.dfn.build(stepDiv);
					return;
				}
				if (id === &quot;etym&quot;) {
					$(&quot;#wiktku-start-etym .wiktku-etym-wrap&quot;).remove();
					steps.etym.build($(&quot;#wiktku-start-etym&quot;));
					return;
				}
				if (id === &quot;cavkani&quot;) {
					$(&quot;#wiktku-start-cavkani .wiktku-cavkani-wrap&quot;).remove();
					steps.cavkani.build($(&quot;#wiktku-start-cavkani&quot;));
					return;
				}
				if (id === &quot;posparams&quot;) {
					var ppDiv = $(&quot;#wiktku-start-posparams&quot;);
					ppDiv.find(&quot;.wiktku-posparams-step&quot;).remove();
					return;
				}
				if (id === &quot;resim&quot;) {
					$(&quot;#wiktku-start-resim .wiktku-resim-wrap&quot;).remove();
					return;
				}
				if (id === &quot;trans&quot;) {
					var transDiv = $(&quot;#wiktku-start-trans&quot;);
					transDiv.find(&quot;.wiktku-trans-group&quot;).remove();
					return;
				}
				if (id === &quot;zarava&quot;) {
					var zaravaDiv = $(&quot;#wiktku-start-zarava&quot;);
					zaravaDiv.find(&quot;.wiktku-zarava-group&quot;).remove();
					return;
				}
				if (id === &quot;dunde&quot;) {
					var dundeDiv = $(&quot;#wiktku-start-dunde&quot;);
					dundeDiv.find(&quot;ul.wiktku-dunde-list&quot;).remove();
					return;
				}
				stepDiv = $(&quot;#wiktku-start-&quot; + id);
				stepDiv.find(&quot;.wiktku-start-step-field&quot;).val(&quot;&quot;);
				stepDiv.find(&quot;select.wiktku-start-step-field&quot;).trigger(&quot;wiktku:refresh&quot;);
			});
			// Fresh section — no &quot;Beşên din&quot; sub-section has been opened yet.
			ctx.openedOtherSections = {};
			renderBesenDinPicker();
			renderSectionTabs();
			refresh();
		}

		addSectionBtn.on(&quot;click&quot;, addPosSection);

		/** Removes one POS section. Assumes the caller already confirmed and
		 *  already checked more than one section remains. If the removed
		 *  section was the one on screen, its in-progress DOM edits are
		 *  discarded along with it (never saved back into sections[]) and a
		 *  neighboring section is restored in its place. */
		function removePosSection(idx) {
			ctx.sections.splice(idx, 1);
			if (idx === ctx.activeSection) {
				ctx.viewingPron = false;
				ctx.activeSection = Math.min(idx, ctx.sections.length - 1);
				restoreSection(ctx.sections[ctx.activeSection]);
				refresh();
			} else if (idx &lt; ctx.activeSection) {
				ctx.activeSection -= 1;
			}
			renderSectionTabs();
		}

		/** Re-render the tab bar to reflect current sections[] and activeSection. */
		function renderSectionTabs() {
			// Detach (not remove) the button first: .empty() strips bound
			// event data from any children left inside it, which would
			// silently kill addSectionBtn's click handler on every re-render.
			addSectionBtn.$element.detach();
			sectionTabsDiv.empty();

			var lang = getValues().lang || &quot;&quot;;
			if (!lang) {
				sectionTabsDiv.hide();
				syncStickyTabsOffset();
				return;
			}
			sectionTabsDiv.show();

			// Bilêvkirin leads the bar, ahead of the POS sections.
			var pronTab = $(&quot;&lt;span&gt;&lt;/span&gt;&quot;)
				.addClass(&quot;wiktku-section-tab wiktku-section-tab-pron&quot;)
				.text(&quot;Bilêvkirin&quot;)
				.toggleClass(&quot;wiktku-tab-active&quot;, ctx.viewingPron);
			pronTab.on(&quot;click&quot;, function () {
				if (ctx.viewingPron) return;
				saveCurrentSection();
				ctx.viewingPron = true;
				refresh();
				renderSectionTabs();
				scrollTabBarIntoView(&quot;wiktku-section-tabs&quot;);
			});
			sectionTabsDiv.append(pronTab);

			$.each(ctx.sections, function (i) {
				var posVal = ctx.sections[i].pos || &quot;&quot;;
				// Numbered while there is more than one section of this part of speech, so two tabs are
				// never both &quot;Rengdêr&quot; -- the same numbering the headings get on save.
				var samePos = $.grep(ctx.sections, function (s) { return (s.pos || &quot;&quot;) === posVal; });
				var nth = 0;
				$.each(ctx.sections, function (j, s) {
					if ((s.pos || &quot;&quot;) === posVal &amp;&amp; j &lt;= i) nth++;
				});
				var tabLabel = posVal
					? capitalize(posVal) + (samePos.length &gt; 1 ? &quot; &quot; + nth : &quot;&quot;)
					: (&quot;Beş &quot; + (i + 1));
				var tab = $(&quot;&lt;span&gt;&lt;/span&gt;&quot;)
					.addClass(&quot;wiktku-section-tab&quot;)
					.text(tabLabel)
					.toggleClass(&quot;wiktku-tab-active&quot;, i === ctx.activeSection &amp;&amp; !ctx.viewingPron);
				(function (idx) {
					tab.on(&quot;click&quot;, function () {
						if (idx === ctx.activeSection &amp;&amp; !ctx.viewingPron) return;
						// Leaving Bilêvkirin doesn't need a save — its field
						// is shared and never part of a section snapshot.
						if (!ctx.viewingPron) saveCurrentSection();
						ctx.viewingPron = false;
						ctx.activeSection = idx;
						restoreSection(ctx.sections[ctx.activeSection]);
						refresh();
						renderSectionTabs();
						scrollTabBarIntoView(&quot;wiktku-section-tabs&quot;);
					});
				}(i));
				sectionTabsDiv.append(tab);
			});

			// One delete button for the whole bar — not one per tab — same
			// reasoning as the Mane tabs' trash button: deletes whichever
			// Beş is currently open, so there's only one thing a click on it
			// can possibly remove. Not shown on Bilêvkirin (nothing to
			// delete there) or when it's the only Beş left.
			if (ctx.sections.length &gt; 1 &amp;&amp; !ctx.viewingPron) {
				var activeTabLabel = ctx.sections[ctx.activeSection] &amp;&amp; ctx.sections[ctx.activeSection].pos
					? capitalize(ctx.sections[ctx.activeSection].pos)
					: (&quot;Beş &quot; + (ctx.activeSection + 1));
				var sectionTrash = makeTrashButton(&quot;Vê beşê jê bibe (&quot; + activeTabLabel + &quot;)&quot;);
				sectionTrash.on(&quot;click&quot;, function () {
					if (!window.confirm(&quot;Tu dixwazî \&quot;&quot; + activeTabLabel + &quot;\&quot; jê bibî? Ev tişt nayê vegerandin.&quot;)) return;
					removePosSection(ctx.activeSection);
				});
				sectionTabsDiv.append(sectionTrash.$element);
			}

			// Enable &quot;+ Beşeke din&quot; only when the active section has a pos chosen.
			var activePos = ctx.sections[ctx.activeSection] &amp;&amp; ctx.sections[ctx.activeSection].pos
				? ctx.sections[ctx.activeSection].pos
				: getValues().pos;
			addSectionBtn.setDisabled(!activePos);
			sectionTabsDiv.append(addSectionBtn.$element);
			syncStickyTabsOffset();
		}

		renderSectionTabs();

		/**
		 * Re-populates a growing &quot;multiple&quot; field list (bnrh, je, tekildar, …) from a saved array.
		 * Values are set with .val() plus an &quot;input&quot; event so refreshForTextField() grows the rows,
		 * exactly as typing into the last row does.
		 */
		function restoreMultiField(id, values) {
			var container = $(&quot;#wiktku-start-&quot; + id);
			$.each(values || [], function (i, v) {
				var field = container.find(&quot;.wiktku-start-step-field&quot;).eq(i);
				if (!field.length || !v) return;
				field.val(v).trigger(&quot;input&quot;);
			});
		}

		/**
		 * Restores a full cached draft: shared lang/pron/bnrh fields, then
		 * every section (via the same restoreSection()/refresh()/
		 * renderSectionTabs() sequence already used when switching tabs).
		 * @param cached {{lang: string, pron: string, bnrh: Array, sections: Array, activeSection: number}}
		 */
		function restoreFromCache(cached) {
			if (cached.lang) {
				$(&quot;#wiktku-start-lang-field&quot;).val(cached.lang);
				$(&quot;#wiktku-start-lang-field&quot;).trigger(&quot;wiktku:refresh&quot;);
			}
			// Rebuild dependent steps (pos, pron wrap, etc.) now that lang is set.
			refresh();

			if (cached.pron !== undefined) {
				$(&quot;#wiktku-start-pron .wiktku-pron-text&quot;).val(cached.pron);
			}

			if (cached.bnrh) {
				restoreMultiField(&quot;bnrh&quot;, cached.bnrh);
			}

			ctx.sections = (cached.sections &amp;&amp; cached.sections.length) ? cached.sections : [{}];
			ctx.activeSection = (typeof cached.activeSection === &quot;number&quot; &amp;&amp;
				cached.activeSection &gt;= 0 &amp;&amp; cached.activeSection &lt; ctx.sections.length)
				? cached.activeSection : 0;

			restoreSection(ctx.sections[ctx.activeSection]);
			refresh();
			renderSectionTabs();

			updateLastSavedIndicator(cached.savedAt || null);
			ctx.formDirty = false;

			wiktkuNotify(&quot;Danûstandina berê ya qeydkirî ji cache hate barkirin.&quot;,
				{ type: &quot;info&quot;, tag: &quot;wiktku-cache-restore&quot; });
		}

		// Update the active tab's label whenever pos changes.
		startForm.on(&quot;change&quot;, &quot;#wiktku-start-pos-field&quot;, function () {
			// renderSectionTabs() labels each tab from sections[i].pos, which
			// is only synced from the DOM by saveCurrentSection() (on tab
			// switch/section add). Without this, the active tab's own label
			// stays on the previous pos (or &quot;Beş N&quot;) until the user switches
			// away and back. Update it directly so the rename is immediate.
			if (ctx.sections[ctx.activeSection]) ctx.sections[ctx.activeSection].pos = $(this).val();
			renderSectionTabs();

			// A new cureyê rêzimanî means any previously chosen cinsiyet/
			// cureyê lêkerê no longer applies — clear both selections (and
			// the shared hidden cinsiyet field, since rebuildTa()/syncHelpers()
			// fall back to it) before wiping the textarea, so nothing stale
			// gets carried over into the rebuilt template.
			var ppDiv = $(&quot;#wiktku-start-posparams&quot;);
			ppDiv.find(&quot;.wiktku-posparams-cinsiyet-sel&quot;).val(&quot;&quot;);
			ppDiv.find(&quot;.wiktku-posparams-jimar-sel&quot;).val(&quot;&quot;);
			ppDiv.find(&quot;.wiktku-posparams-lektur-sel&quot;).prop(&quot;selectedIndex&quot;, 0);
			ppDiv.find(&quot;.wiktku-posparams-lekturform-sel&quot;).prop(&quot;selectedIndex&quot;, 0);
			$(&quot;#wiktku-start-cinsiyet-field&quot;).val(&quot;&quot;);
			$(&quot;#wiktku-start-jimar-field&quot;).val(&quot;&quot;);
			ppDiv.find(&quot;.wiktku-posparams-text&quot;).val(&quot;&quot;);

			// refresh() runs steps.posparams.syncHelpers(), which toggles the
			// param rows for the new pos and — since the textarea is now
			// empty — calls rebuildTa() to repopulate it.
			refresh();
		});

		// Show the tab bar as soon as a language is selected.
		startForm.on(&quot;change&quot;, &quot;#wiktku-start-lang-field&quot;, function () {
			renderSectionTabs();
		});

		var footer = $(&quot;&lt;div id='wiktku-start-footer'&gt;&lt;/div&gt;&quot;);

		spinner = $(mw.html.element(&quot;img&quot;, {
			id: &quot;wiktku-start-spinner&quot;,
			src: &quot;//upload.wikimedia.org/wikipedia/commons/d/de/Ajax-loader.gif&quot;,
			alt: &quot;Tê barkirin…&quot;,
			title: &quot;Tê barkirin…&quot; }));
		footer.append(spinner.hide());

		ctx.continueBtn = new OO.ui.ButtonWidget({
			id: &quot;wiktku-unhide-editform&quot;,
			label: &quot;Bişîne&quot;,
			flags: [ &quot;primary&quot;, &quot;progressive&quot; ]
		});
		ctx.continueBtn.on(&quot;click&quot;, function () {
			// Immediate feedback that the click registered
			ctx.continueBtn.$element.addClass(&quot;wiktku-btn-flash&quot;);
			setTimeout(function () {
				ctx.continueBtn.$element.removeClass(&quot;wiktku-btn-flash&quot;);
			}, 500);

			wiktkuNotify(&quot;Tê şandin…&quot;, { type: &quot;info&quot;, tag: &quot;wiktku-submit&quot; });
			startForm.trigger(&quot;submit&quot;);
		});
		ctx.continueBtn.$element.addClass(&quot;wiktku-footer-primary&quot;);
		footer.append(ctx.continueBtn.$element);

		// &quot;Edîtora çavkaniyê veke&quot; button — inline fallback for the portlet link
		var sourceEditorBtn = new OO.ui.ButtonWidget({
			label: &quot;Edîtora çavkaniyê veke&quot;,
			flags: [ &quot;destructive&quot; ],
		});
		sourceEditorBtn.on(&quot;click&quot;, function () {
			destroy();
		});
		sourceEditorBtn.$element.addClass(&quot;wiktku-footer-primary&quot;);
		footer.append(sourceEditorBtn.$element);

		// ── Cache save/clear buttons ─────────────────────────────────────────
		// Manual, page-scoped save of the entire wizard (all sections, not
		// just the active one) via [[MediaWiki:Gadget-StorageUtils.js]]'s
		// ObjectStorage. Restoring happens silently on load at the end of
		// build(), once the full language list is available.
		//
		// Saving also happens automatically (debounced while typing, plus a
		// periodic fallback) — see &quot;Autosave&quot; below — since relying on the
		// person to remember to click &quot;Li cache qeyd bike&quot; before an
		// accidental tab close/reload defeats the point of having a cache
		// at all.
		function buildCacheSnapshot() {
			return {
				lang: getValues().lang || &quot;&quot;,
				pron: $(&quot;#wiktku-start-pron .wiktku-pron-text&quot;).val() || &quot;&quot;,
				// bnrh is shared (page-level), same as lang/pron above — not
				// per-section, so it doesn't live in sections[].
				bnrh: getValuesForStep(&quot;bnrh&quot;),
				sections: ctx.sections,
				activeSection: ctx.activeSection,
				savedAt: Date.now()
			};
		}

		// ── Last-saved indicator ─────────────────────────────────────────────
		var lastSavedEl = $(&quot;&lt;span id='wiktku-last-saved'&gt;&lt;/span&gt;&quot;);
		function formatSavedTime(ts) {
			try {
				return new Date(ts).toLocaleTimeString(mw.config.get(&quot;wgUserLanguage&quot;),
					{ hour: &quot;2-digit&quot;, minute: &quot;2-digit&quot; });
			} catch (e) {
				return new Date(ts).toLocaleTimeString();
			}
		}
		function updateLastSavedIndicator(ts) {
			lastSavedEl.text(ts ? (&quot;Cache: qeydkirî di saet &quot; + formatSavedTime(ts) + &quot; de&quot;) : &quot;&quot;);
		}

		// ── Dirty-state tracking + autosave ──────────────────────────────────
		// formDirty mirrors &quot;does the live form differ from what's in cache&quot;.
		// Anything the person types/selects sets it; a successful save (auto
		// or manual) clears it; destroy() (final submit, or switching to the
		// source editor) also clears it since the wizard's job is over at
		// that point either way. formDirty/autosaveDebounceTimer/autosaveInterval
		// are declared in the outer scope (near activeGroup) — assigned here,
		// not re-declared — so destroy() can reach them too.
		var AUTOSAVE_DEBOUNCE_MS = 8000;   // save shortly after typing pauses
		var AUTOSAVE_INTERVAL_MS = 60000;  // …and at least this often regardless

		function performAutosave() {
			if (!ctx.formDirty) return;
			saveCurrentSection();
			try {
				formCache.Set(buildCacheSnapshot());
				ctx.formDirty = false;
				updateLastSavedIndicator(Date.now());
			} catch (e) {
				// Silent on autosave failure (storage blocked/full, etc.) — the
				// manual button still surfaces a proper error if the person
				// tries it directly, no need to interrupt typing with a toast.
			}
		}

		function scheduleAutosave() {
			ctx.formDirty = true;
			if (ctx.autosaveDebounceTimer) clearTimeout(ctx.autosaveDebounceTimer);
			ctx.autosaveDebounceTimer = setTimeout(performAutosave, AUTOSAVE_DEBOUNCE_MS);
		}

		startForm.on(&quot;input change&quot;, &quot;input, textarea, select&quot;, scheduleAutosave);

		ctx.autosaveInterval = setInterval(performAutosave, AUTOSAVE_INTERVAL_MS);

		// Warn on accidental tab close/reload while there's anything unsaved.
		$(window).on(&quot;beforeunload.wiktkuUnsaved&quot;, function (e) {
			if (!ctx.formDirty) return undefined;
			e.preventDefault();
			e.returnValue = &quot;&quot;;
			return &quot;&quot;;
		});

		var saveCacheBtn = new OO.ui.ButtonWidget({
			label: &quot;Li cache qeyd bike&quot;,
			title: &quot;Halê vê formê yê niha (ziman, bilêvkirin û hemû beş) li cache (localStorage) qeyd bike, da ku eger rûpel bêyî xwestin were girtin an ji nû ve were barkirin, tu karibî berdewam bikî.&quot;
		});
		saveCacheBtn.on(&quot;click&quot;, function () {
			saveCurrentSection();
			// ObjectStorage.Set() doesn't return a success/failure value, so
			// the only way to detect a real failure (storage blocked, quota
			// exceeded, JSON.stringify choking on something unexpected) is to
			// catch it here rather than inspect a (nonexistent) return value.
			try {
				var snapshot = buildCacheSnapshot();
				formCache.Set(snapshot);
				ctx.formDirty = false;
				updateLastSavedIndicator(snapshot.savedAt);
				wiktkuNotify(&quot;Halê formê li cache hate qeydkirin.&quot;, { type: &quot;success&quot;, tag: &quot;wiktku-cache-save&quot; });
			} catch (e) {
				mw.notify(&quot;Qeydkirina li cache bi ser neket.&quot;, { type: &quot;error&quot;, tag: &quot;wiktku-cache-save&quot; });
			}
		});

		var clearCacheBtn = new OO.ui.ButtonWidget({
			label: &quot;Cache paqij bike&quot;,
			flags: [ &quot;destructive&quot; ],
			title: &quot;Datayên qeydkirî yên vê rûpelê ji cache jê bibe (forma ku niha xuya dike naguherîne).&quot;
		});
		clearCacheBtn.on(&quot;click&quot;, function () {
			formCache.Set({});
			// Cancel the scheduled autosave, or it would rewrite the cache from the still-filled form.
			// The form is left clean, so autosave resumes only once something is edited again.
			if (ctx.autosaveDebounceTimer) {
				clearTimeout(ctx.autosaveDebounceTimer);
				ctx.autosaveDebounceTimer = null;
			}
			ctx.formDirty = false;
			updateLastSavedIndicator(null);
			wiktkuNotify(&quot;Cache hate paqijkirin.&quot;, { type: &quot;success&quot;, tag: &quot;wiktku-cache-clear&quot; });
		});
		// Everything sits on the bar: no overflow menu, nothing a click away.
		// Settings button — opens the Tercîh dialog. Plain OOUI icon names depend on which icon-pack
		// module happens to be loaded, so this uses the actual Codex &quot;settings&quot; (color-subtle) SVG from
		// Commons directly, the same way the spinner above hotlinks its gif.
		var prefsBtn = $(&quot;&lt;button&gt;&lt;/button&gt;&quot;, {
			type: &quot;button&quot;,
			&quot;class&quot;: &quot;wiktku-prefs-btn&quot;,
			title: &quot;Tercîh — sazkariyên vê amûrê biguherîne&quot;,
			&quot;aria-label&quot;: &quot;Tercîh&quot;
		});
		prefsBtn.on(&quot;click&quot;, function (e) {
			e.preventDefault();
			wiktkuOpenPrefsDialog();
		});

		clearCacheBtn.$element.addClass(&quot;wiktku-btn-danger&quot;);
		saveCacheBtn.$element.addClass(&quot;wiktku-footer-cache&quot;);
		clearCacheBtn.$element.addClass(&quot;wiktku-footer-cache&quot;);
		footer.append(saveCacheBtn.$element)
			.append(clearCacheBtn.$element)
			.append(prefsBtn)
			.append($(&quot;&lt;span class='wiktku-cache-note'&gt;&lt;/span&gt;&quot;).append(lastSavedEl));

		startForm.append(footer);

		// Moved off-screen rather than display:none. WikiEditor and the mobile editor measure
		// #wpTextbox1 while the wizard is up, and a hidden ancestor reports zero, which they then keep.
		// Off-screen keeps it laid out and measurable.
		$(&quot;#editform&quot;).addClass(&quot;wiktku-offscreen&quot;).before(startForm);
		// renderGroupTabs() looks up #wiktku-group-tabs via a live DOM
		// selector, so it must run after startForm is actually in the document.
		renderGroupTabs();
		renderBesenDinPicker();
		// One pass over the whole form: every select that hasn't already been
		// initialised, and isn't opted out with .wiktku-plain-select, gets
		// the searchable picker.
		initSelects(startForm);
		refresh();

		// Give every draggable textarea a custom resize grip (works
		// consistently on Safari/iOS, unlike the native corner grip — see
		// the &quot;Manual drag-to-resize handle&quot; comment in styles.css), and
		// keep applying it to textareas added later on (new sense blocks,
		// quote-source fields, nimûne rows, …).
		wiktkuInitManualResize(startForm);
		new MutationObserver(function (mutations) {
			mutations.forEach(function (mutation) {
				$(mutation.addedNodes).each(function () {
					if (this.nodeType !== 1) return;
					wiktkuInitManualResize(this);
				});
			});
		}).observe(startForm[0], { childList: true, subtree: true });

		// Now that the full language list is loaded, silently restore any
		// draft the editor previously saved for this page.
		var cachedDraft = formCache.Get();
		if (cachedDraft &amp;&amp; cachedDraft.sections &amp;&amp; cachedDraft.sections.length) {
			restoreFromCache(cachedDraft);
		}
	}

	return {
		build: build,
		restoreSection: restoreSection,
		saveCurrentSection: saveCurrentSection
	};
};
// &lt;/nowiki&gt;</text>
      <sha1>l9lde63h0wlcvy0qbnu66bdr1zxu9c5</sha1>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Gadget-wikt.start-wizard-steps/sections.js</title>
    <ns>8</ns>
    <id>1359536</id>
    <revision>
      <id>6903101</id>
      <timestamp>2026-11-10T21:26:13Z</timestamp>
      <contributor>
        <username>Wikihez</username>
        <id>7344</id>
      </contributor>
      <comment>Split the wizard's script pages under 100 KB; identifierOf shared from citoid-helper</comment>
      <origin>6903101</origin>
      <model>javascript</model>
      <format>text/javascript</format>
      <text bytes="35513" sha1="41qu73uqjujtkmhmcblor40h5fepob6" xml:space="preserve">// &lt;nowiki&gt;
/*
 * Page: [[MediaWiki:Gadget-wikt.start-wizard-steps/sections.js]]
 *
 * The step definitions after the senses: the sections of an entry other than Mane. A file of the
 * wikt.start-wizard-steps module, called with the wizard's ctx and the steps object it adds to.
 */
module.exports = function (ctx, steps) {
	var GENDER_BASE_LABELS = ctx.GENDER_BASE_LABELS;
	var ZARAVA_LANG_CODES = ctx.ZARAVA_LANG_CODES;
	var decapitalize = ctx.decapitalize;
	var fetchCatSrcTemplates = ctx.fetchCatSrcTemplates;
	var getLangLabel = ctx.getLangLabel;
	var getValues = ctx.getValues;
	var initSelects = ctx.initSelects;
	var insertAtCursor = ctx.insertAtCursor;
	var langHasMultipleScripts = ctx.langHasMultipleScripts;
	var langsByCode = ctx.langsByCode;
	var makeWordListStep = ctx.makeWordListStep;
	var markTemplateOptions = ctx.markTemplateOptions;
	var populateMenus = ctx.populateMenus;
	var refresh = ctx.refresh;
	var senseHasExtraContent = ctx.senseHasExtraContent;
	var stripWikilinks = ctx.stripWikilinks;
	var tplNameFromSnippet = ctx.tplNameFromSnippet;
	var wiktkuCite = ctx.wiktkuCite;
	var wiktkuUtil = ctx.wiktkuUtil;
	var wiktkuWikitext = ctx.wiktkuWikitext;

	// The {{werger-ser}} boxes of a step that lists words under each sense (zarava, trans), below its heading.
	function glossBoxes(id, heading) {
		var stepDiv = $(&quot;#wiktku-start-&quot; + id);
		var glosses = steps.trans.glossList();

		// Every sense is a template sense — there's no real gloss
		// anywhere and no group in the DOM either (glossList() only
		// returns empty in that case), so skip the section entirely.
		if (!glosses.length) return &quot;&quot;;

		// A completely empty entry (nothing filled in dfn at all, no
		// şablon chosen either) still gets a placeholder section
		// to fill in later. Only
		// skip an individual placeholder gloss below when some other
		// sense actually has real content, making that particular
		// placeholder redundant.
		var dfnSenses = steps.dfn.getSenses($(&quot;#wiktku-start-dfn&quot;));
		var hasRegularMane = dfnSenses.some(function (s) {
			return !s.tpl &amp;&amp; (s.mane !== &quot;&quot; || senseHasExtraContent(s));
		});

		// Each gloss now has its own group of translation rows —
		// attach every gloss's own words under its own werger-ser/-bin
		// pair instead of dumping everything under the first one.
		var blocks = $.map(glosses, function (gloss, gi) {
			var group = stepDiv.find(&quot;.wiktku-&quot; + id + &quot;-group[data-gloss-pos='&quot; + gi + &quot;']&quot;);
			var rows = group.length ? steps[id].getGroupTranslations(group) : [];

			// Placeholder gloss (no real mane entered yet) with nothing
			// translated into it. If some other sense already has real
			// content, this placeholder is redundant — skip it. If the
			// whole entry is empty, keep it so the heading still gets a
			// section to fill in.
			if (!gloss.text &amp;&amp; !rows.length &amp;&amp; hasRegularMane) return undefined;

			if (rows.length) {
				// Sort by Kurdish sort key.
				rows.sort(function (a, b) {
					var aLang = langsByCode[a[0]] || {};
					var bLang = langsByCode[b[0]] || {};
					return (aLang.sortKey || &quot;&quot;).localeCompare(bLang.sortKey || &quot;&quot;, &quot;ku&quot;);
				});
			}

			var wordLines = $.map(rows, function (row) {
				var lang  = row[0];
				var words = row[1];
				var wikiWords = words.map(function (w) {
					return &quot;{{W|&quot; + lang + &quot;|&quot; + w + &quot;}}&quot;;
				}).join(&quot;, &quot;);
				return &quot;* {{Z|&quot; + lang + &quot;}}: &quot; + wikiWords;
			}).join(&quot;\n&quot;);

			var block = &quot;{{werger-ser|&quot; + (gloss.text || &quot;?&quot;) + &quot;|&quot; + gloss.index + &quot;}}&quot;;
			if (wordLines) block += &quot;\n&quot; + wordLines;
			block += &quot;\n{{werger-bin}}&quot;;
			return block;
		});

		if (!blocks.length) return &quot;&quot;;
		return &quot;\n==== &quot; + heading + &quot; ====\n&quot; + blocks.join(&quot;\n&quot;) + &quot;\n&quot;;
	}

	$.extend(steps, {
		tewandin: {
			id: &quot;tewandin&quot;,
			name: &quot;tewandin&quot;,
			question_fmt: 'Tewandina &quot;' + ctx.pageName + '&quot; binivîse',
			visible: function (values) {
				return values.lang &amp;&amp; values.pos;
			},
			build: function (stepDiv) {
				if (stepDiv.find(&quot;.wiktku-tewandin-wrap&quot;).length) return null;
				var wrap = $(&quot;&lt;div class='wiktku-tewandin-wrap'&gt;&lt;/div&gt;&quot;);
				var ta = $(&quot;&lt;textarea&gt;&lt;/textarea&gt;&quot;)
					.attr(&quot;name&quot;, &quot;wiktku-tewandin-&quot; + $.now())
					.attr(&quot;class&quot;, &quot;wiktku-start-step-field wiktku-tewandin-text&quot;)
					.attr(&quot;rows&quot;, 4);
				wrap.append(ta);
				stepDiv.append(wrap);

				function autoPopulate() {
					if (!ta.length) return;
					var vals = getValues();
					var c = vals.cinsiyet || &quot;&quot;;
					var p = vals.pos || &quot;&quot;;
					if (!ctx.pageName.includes(&quot; &quot;) &amp;&amp; c &amp;&amp; GENDER_BASE_LABELS[c] &amp;&amp;
						(p === &quot;navdêr&quot; || p === &quot;serenav&quot;) &amp;&amp; vals.lang === &quot;ku&quot; &amp;&amp;
						c !== &quot;mndudil&quot;) {
						var label = (c === &quot;mnmane&quot;) ? &quot;mê û nêr&quot; : GENDER_BASE_LABELS[c];
						var out = &quot;{{ku-tewîn-nav|&quot; + label;
						if (p === &quot;serenav&quot;) out += &quot;|y&quot;;
						out += &quot;}}&quot;;
						if (!$.trim(ta.val())) ta.val(out);
					}
				}
				// The example placeholder only fits Kurmancî nouns — showing it
				// for a verb or another language would suggest the wrong template.
				function updatePlaceholder() {
					if (!ta.length) return;
					var vals = getValues();
					ta.attr(&quot;placeholder&quot;, (vals.lang === &quot;ku&quot; &amp;&amp; vals.pos === &quot;navdêr&quot;) ? &quot;{{ku-tewîn-nav|nêr}}&quot; : &quot;&quot;);
				}
				setTimeout(function () {
					autoPopulate();
					updatePlaceholder();
					$(&quot;#wiktku-start-form&quot;).on(&quot;change.tewandin&quot;,
						&quot;#wiktku-start-lang-field, #wiktku-start-cinsiyet-field, #wiktku-start-pos-field&quot;,
						function () { autoPopulate(); updatePlaceholder(); });
				}, 0);

				return ta;
			},
			output: function () {
				var manualText = $.trim($(&quot;#wiktku-start-tewandin .wiktku-tewandin-text&quot;).val());
				if (manualText) {
					return &quot;\n==== Tewandin ====\n&quot; + manualText + &quot;\n&quot;;
				}
				return &quot;&quot;;
			}
		},
		// resim — one or more images 
		resim: {
			id: &quot;resim&quot;,
			name: &quot;resim&quot;,
			question_fmt: &quot;Resmekê lê zêde bike&quot;,
			visible: function (values) { return !!(values.lang &amp;&amp; values.pos); },

			// The rows are wikt.edit's, shared with DefSideBoxes, which offers the same three boxes.
			field: null,

			build: function (stepDiv) {
				if (stepDiv.find(&quot;.wiktku-resim-wrap&quot;).length) return null;
				steps.resim.field = wiktkuUtil.buildImageListField({
					prefix: &quot;wiktku-&quot;,
					rowClass: &quot;wiktku-posparams-row&quot;,
					inputClass: &quot;wiktku-start-step-field wiktku-start-narrow&quot;,
					pageName: ctx.pageName
				});
				stepDiv.append($(&quot;&lt;div class='wiktku-resim-wrap'&gt;&lt;/div&gt;&quot;).append(steps.resim.field.$element));
				return null;
			},

			/** {file, caption, alt} per filled row, with the caption wrapped for a non-Kurdish entry. */
			getImages: function (values) {
				var lang = (values &amp;&amp; values.lang) || getValues().lang || &quot;&quot;;
				if (!steps.resim.field) return [];
				return $.map(steps.resim.field.values(), function (image) {
					return {
						file: image.file,
						caption: wiktkuWikitext.captionForLang(image.caption, lang),
						alt: image.alt,
						size: image.size,
						extra: image.extra
					};
				});
			},

			output: function (values) {
				var images = steps.resim.getImages(values);
				if (!images.length) return &quot;&quot;;
				return $.grep($.map(images, wiktkuWikitext.buildImageLine), Boolean).join(&quot;\n&quot;) + &quot;\n&quot;;
			}
		},
		// h-bnr — {{h-bnr|Page1|Page2|…}} prepended before the lang section (shared, not per-section)
		bnrh: {
			id: &quot;bnrh&quot;,
			name: &quot;herwiha binêre (h-bnr)&quot;,
			question_fmt: &quot;Şablona h-bnr li qismê herî jor a rûpelê&quot;,
			//visible: function (values) { return !!values.lang; },
			multiple: true,
			narrow: true,
			placeholder: &quot;Ji bo 'test' bnr 'Test', 'teşt'&quot;,
			output: function (values) {
				var call = wiktkuWikitext.buildHbnrCall(values.bnrh);
				return call ? call + &quot;\n&quot; : &quot;&quot;;
			}
		},
		bikaranin: {
			id: &quot;bikaranin&quot;,
			name: &quot;Notên bikaranînê&quot;,
			question_fmt: &quot;Notên bikaranînê yên li ser vê kelîmeyê&quot;,
			visible: function (values) {
				return values.lang &amp;&amp; values.pos;
			},
			multiple: false,
			narrow: false,
			output: function (values) {
				var text = $.trim(values.bikaranin || &quot;&quot;);
				if (!text) return &quot;&quot;;
				return &quot;\n==== Notên bikaranînê ====\n&quot; + text + &quot;\n&quot;;
			},
		},
		xwendin: {
			id: &quot;xwendin&quot;,
			name: &quot;Bêhtir bixwîne&quot;,
			question_fmt: &quot;Lînkên derveyî eleqedarî vê madeyê&quot;,
			visible: function (values) {
				return values.lang &amp;&amp; values.pos;
			},
			multiple: false,
			narrow: false,
			placeholder: function (values) {
				if (!values || !values.lang) {
					return `* {{wpedî}} ji bo ku meqaleya Wîkîpediyayê lînk bidî`;
				}
				const ziman = values.lang === &quot;ku&quot; ? &quot;&quot; : `|ziman=${values.lang}`;
				
				return `* {{wpedî${ziman}}} ji bo ku meqaleya Wîkîpediyayê lînk bidî`;
			},
			output: function (values) {
				var text = $.trim(values.xwendin || &quot;&quot;);
				if (!text) return &quot;&quot;;
				return &quot;\n==== Bêhtir bixwîne ====\n&quot; + text + &quot;\n&quot;;
			},
		},
		alfabeyendin: {
			id: &quot;alfabeyendin&quot;,
			name: &quot;Bi alfabeyên din&quot;,
			question_fmt: function (values) {
				var base = &quot;Nivîsîna vê kelîmeyê bi alfabeyên din&quot;
				var langLabel = values.lang ? getLangLabel(values.lang) : &quot;&quot;;
				if (langLabel) {
					return base + &quot; ên &quot; + langLabel;
				}
				return base;
			},
			// Latin-script Kurdish itself, and languages with only one script
			// on record, don't need this — but any language wikt.lang-metadata
			// lists more than one script for (its &quot;sc&quot;) clearly does.
			visible: function (values) {
				if (!(values.lang &amp;&amp; values.pos)) return false;
				var lang = values.lang;
				return lang === &quot;ku&quot; || ZARAVA_LANG_CODES.indexOf(lang) !== -1 || langHasMultipleScripts(lang);
			},
			multiple: false,
			narrow: false,
			placeholder: &quot;Ji bo kurmancî: * {{ku-ar|şiklê alfaba erebî}}&quot;,
			output: function (values) {
				var text = $.trim(values.alfabeyendin || &quot;&quot;);
				if (!text) return &quot;&quot;;
				return &quot;\n==== Bi alfabeyên din ====\n&quot; + text + &quot;\n&quot;;
			},
		},
		formalt: makeWordListStep(&quot;formalt&quot;, &quot;Formên alternatîv ên vê kelîmeyê ji bo hemû maneyan eger te li binê maneyê nenivîsandibe&quot;),
		hevmane: makeWordListStep(&quot;hevmane&quot;, &quot;Hevmaneyên vê kelîmeyê ji bo hemû maneyan eger te li binê maneyê nenivîsandibe&quot;),
		dijmane: makeWordListStep(&quot;dijmane&quot;, &quot;Dijmaneyên vê kelîmeyê ji bo hemû maneyan eger te li binê maneyê nenivîsandibe&quot;),
		jornav: makeWordListStep(&quot;jornav&quot;, &quot;Jornavên vê kelîmeyê ji bo hemû maneyan eger te li binê maneyê nenivîsandibe&quot;),
		jernav: makeWordListStep(&quot;jernav&quot;, &quot;Jêrnavên vê kelîmeyê ji bo hemû maneyan eger te li binê maneyê nenivîsandibe&quot;),
		je: makeWordListStep(&quot;je&quot;, &quot;Kelîmeyên jê çêbûyî binivîse&quot;),
		tekildar: makeWordListStep(&quot;tekildar&quot;, &quot;Kelîmeyên ji aliyê etîmolojiyê ve têkildarî vê kelîmeyê binivîse&quot;),
		binereherwiha: makeWordListStep(&quot;binereherwiha&quot;, &quot;Kelîmeyên din ên eleqedar binivîse&quot;),
		etym: {
			id: &quot;etym&quot;,
			name: &quot;etîmolojî&quot;,
			question_fmt: &quot;Etîmolojiya kelîmeyê binivîse&quot;,
			// etymTpls populated from data-main.json
			etymTpls: {},
			visible: function (values) {
				return values.lang &amp;&amp; values.pos;
			},
			// Fills the insert-dropdown from the current etymTpls object.
			refreshTplSelect: function () {
				var sel = $(&quot;#wiktku-start-etym .wiktku-tpl-insert-select&quot;);
				if (!sel.length) return;
				sel.find(&quot;option[value!='']&quot;).remove();
				$.each(steps.etym.etymTpls, function (name, tpl) {
					sel.append($(&quot;&lt;option&gt;&lt;/option&gt;&quot;).val(tpl.snippet).text(name + &quot; — &quot; + tpl.desc));
				});
				markTemplateOptions(sel, function (opt) { return tplNameFromSnippet(opt.val()); });
				// Tell the picker the option list changed.
				sel.trigger(&quot;wiktku:refresh&quot;);
			},
			build: function (stepDiv) {
				if (stepDiv.find(&quot;.wiktku-etym-wrap&quot;).length) return null;

				var wrap = $(&quot;&lt;div class='wiktku-etym-wrap'&gt;&lt;/div&gt;&quot;);

				var ta = $(&quot;&lt;textarea&gt;&lt;/textarea&gt;&quot;)
					.attr(&quot;name&quot;, &quot;wiktku-etym-&quot; + $.now())
					.attr(&quot;class&quot;, &quot;wiktku-start-step-field wiktku-etym-text&quot;)
					.attr(&quot;rows&quot;, 4)
					.attr(&quot;placeholder&quot;, &quot;Ji {{ji|en|ku|apple}}. yan rasterast binivîse…&quot;);

				// Template insert dropdown — options also refreshed after data-main.json loads.
				var sel = $(&quot;&lt;select class='wiktku-tpl-insert-select'&gt;&lt;/select&gt;&quot;);
				sel.attr(&quot;data-placeholder&quot;, wiktkuUtil.msg.addTemplate);
				sel.append($(&quot;&lt;option value=''&gt;— şablonek lê zêde bike —&lt;/option&gt;&quot;));
				$.each(steps.etym.etymTpls, function (name, tpl) {
					sel.append($(&quot;&lt;option&gt;&lt;/option&gt;&quot;).val(tpl.snippet).text(name + &quot; — &quot; + tpl.desc));
				});

				sel.on(&quot;change&quot;, function () {
					var snippet = $(this).val();
					if (!snippet) return;
					var lang = getValues().lang || &quot;&quot;;
					snippet = snippet.replace(/CODE/g, lang).replace(/SOURCELANG/g, &quot;?&quot;);
					$(this).val(&quot;&quot;);
					sel.trigger(&quot;wiktku:refresh&quot;);
					// Same param dialog DefSideBoxes' own Etîmolojî editor opens on a fresh insert: filled
					// from the template's own TemplateData, with CODE/SOURCELANG already substituted above
					// as the fields' starting values, so the user only has to replace the &quot;?&quot; placeholders
					// rather than hunt for them in raw wikitext afterward.
					wiktkuCite.openTemplateDialog(snippet).then(function (edited) {
						if (!edited) return; // cancelled, or &quot;Jê bibe&quot; on a call that was never inserted
						insertAtCursor(ta[0], edited);
						ta.focus();
					});
				});

				wrap.append(sel);
				wrap.append(ta);
				stepDiv.append(wrap);
				initSelects(wrap);
				return ta;
			},
			output: function (values) {
				var text = $.trim($(&quot;#wiktku-start-etym .wiktku-etym-text&quot;).val());
				if (text) {
					return &quot;\n==== Etîmolojî ====\n&quot; + text + &quot;\n&quot;;
				}
				// {{ji?}} (a redirect to {{bêetîmolojî}}) is only ever added automatically to Kurdish
				// entries.
				if (values.lang !== &quot;ku&quot;) return &quot;&quot;;
				// Multi-word page names skip the {{ji?|lang}} placeholder entirely -- &quot;source unknown?&quot; doesn't apply to a phrase.
				if (ctx.pageName.includes(&quot; &quot;)) return &quot;&quot;;
				// No etymology entered — emit {{ji?|lang}} as a placeholder.
				// Skip it only when every filled sense is a şablon sense
				// a completely empty entry with no şablon chosen still gets the placeholder
				var dfnSenses = steps.dfn.getSenses($(&quot;#wiktku-start-dfn&quot;));
				var hasFilledTplSense = dfnSenses.some(function (s) {
					return !!s.tpl &amp;&amp; !!s.tplTitle;
				});
				var hasRegularMane = dfnSenses.some(function (s) {
					return !s.tpl &amp;&amp; (s.mane !== &quot;&quot; || senseHasExtraContent(s));
				});
				if (hasFilledTplSense &amp;&amp; !hasRegularMane) return &quot;&quot;;
				return &quot;\n==== Etîmolojî ====\n{{ji?|&quot; + values.lang + &quot;}}\n&quot;;
			} },
		dunde: {
			id: &quot;dunde&quot;,
			name: &quot;dûnde&quot;,
			question_fmt: &quot;Eger ev kelîme ji vî zimanî ketibe zimanekî din, vî zimanî û kelîmeya wî binivîse&quot;,
			visible: function (values) {
				return  !!values.pos;
			},
			disabledKeys: function (values) {
				return {&quot;navz&quot;: true, [values.lang]: true}
			},

			// Language dropdown + growing word-input list; a new row appends
			// when the dropdown gets a value. Mirrors steps.trans, but flat.
			buildRow: function (stepDiv) {
				var row = $(&quot;&lt;li class='wiktku-dunde-row wiktku-lang-row'&gt;&lt;/li&gt;&quot;);

				// Language selector — the searchable picker is applied after insertion into DOM.
				var langSel = $(mw.html.element(&quot;select&quot;, {
					&quot;class&quot;: &quot;wiktku-start-step-keyfield wiktku-start-narrow&quot; }));
				langSel.attr(&quot;data-placeholder&quot;, &quot;Li zimanekî bigere&quot;);
				populateMenus(langSel, steps.dunde.keys || [], steps.dunde.disabledKeys);

				// When a language is chosen, ensure a next empty row exists.
				langSel.on(&quot;change&quot;, function () {
					steps.dunde.onLangChange(stepDiv, row);
				});

				// Word list for this language.
				var wordList = $(&quot;&lt;ul class='wiktku-dunde-words wiktku-lang-row-words'&gt;&lt;/ul&gt;&quot;);
				var firstWord = steps.dunde.makeWordInput();
				wordList.append($(&quot;&lt;li&gt;&lt;/li&gt;&quot;).append(firstWord));

				// The searchable picker is attached by initSelects() once the row
				// is in the DOM (see onLangChange/build below).
				row.append(langSel).append(wordList);
				return row;
			},

			makeWordInput: function () {
				var input = $(&quot;&lt;textarea&gt;&lt;/textarea&gt;&quot;)
					.attr(&quot;name&quot;, &quot;wiktku-dunde-word-&quot; + $.now() + &quot;-&quot; + Math.random().toString(36).substr(2, 9))
					.attr(&quot;rows&quot;, 1)
					.attr(&quot;class&quot;, &quot;wiktku-dfn-subfield wiktku-start-narrow&quot;)
					.attr(&quot;placeholder&quot;, &quot;Kelîme…&quot;);
				input.on(&quot;input&quot;, function () {
					var list = $(this).closest(&quot;ul.wiktku-dunde-words&quot;);
					var item = $(this).parent();
					var val = $.trim($(this).val());
					if (val &amp;&amp; item.is(list.children(&quot;li:last-child&quot;))) {
						var next = steps.dunde.makeWordInput();
						list.append($(&quot;&lt;li&gt;&lt;/li&gt;&quot;).append(next));
					}
				});
				return input;
			},

			onLangChange: function (stepDiv, row) {
				var list = stepDiv.find(&quot;ul.wiktku-dunde-list&quot;);
				var isLast = row.is(list.children(&quot;li.wiktku-dunde-row:last-child&quot;));
				if (isLast) {
					var newRow = steps.dunde.buildRow(stepDiv);
					list.append(newRow);
					// Attach the searchable picker now the row is in the DOM.
					initSelects(newRow);
				}
				// Keep disabled keys in sync across all lang selectors.
				steps.dunde.syncDisabledKeys(stepDiv);
			},

			/** Disables already-selected languages in all other dropdowns. */
			syncDisabledKeys: function (stepDiv) {
				var taken = $.extend({}, steps.dunde.disabledKeys);
				stepDiv.find(&quot;li.wiktku-dunde-row select&quot;).each(function () {
					var v = $(this).val();
					if (v) taken[v] = true;
				});
				stepDiv.find(&quot;li.wiktku-dunde-row select&quot;).each(function () {
					var self = $(this);
					var own = self.val();
					self.find(&quot;option&quot;).each(function () {
						var code = $(this).val();
						if (!code) return;
						$(this).prop(&quot;disabled&quot;, taken[code] &amp;&amp; code !== own);
					});
					self.trigger(&quot;wiktku:refresh&quot;);
				});
			},

			build: function (stepDiv) {
				if (stepDiv.find(&quot;ul.wiktku-dunde-list&quot;).length) return null;
				var list = $(&quot;&lt;ul class='wiktku-dunde-list wiktku-lang-row-list'&gt;&lt;/ul&gt;&quot;);
				list.append(steps.dunde.buildRow(stepDiv));
				stepDiv.append(list);
				// Attach the searchable picker now the select is in the DOM.
				initSelects(list);
				return null;
			},

			/** Reads all [langcode, words[]] rows from the DOM. */
			getRows: function (stepDiv) {
				var result = [];
				stepDiv.find(&quot;li.wiktku-dunde-row&quot;).each(function () {
					var lang = $(this).find(&quot;select&quot;).val();
					if (!lang) return;
					var words = [];
					$(this).find(&quot;ul.wiktku-dunde-words textarea&quot;).each(function () {
						var v = $.trim($(this).val());
						if (v) words.push(v);
					});
					if (words.length) result.push([lang, words]);
				});
				return result;
			},

			output: function () {
				var stepDiv = $(&quot;#wiktku-start-dunde&quot;);
				var rows = steps.dunde.getRows(stepDiv);
				if (!rows.length) return &quot;&quot;;
				var lines = $.grep($.map(rows, function (row) {
					return wiktkuWikitext.buildDundeLine(row[0], row[1]);
				}), Boolean);
				return &quot;\n==== Dûnde ====\n&quot; + lines.join(&quot;\n&quot;) + &quot;\n&quot;;
			}
		},

		zarava: {
			id: &quot;zarava&quot;,
			name: &quot;bi zaravayên din&quot;,
			question_fmt: &quot;'&quot;+ ctx.pageName + &quot;' di zaravayên din de çawa tê gotin?&quot;,
			visible: function (values) {
				return steps.trans.visible(values);
			},
			disabledKeys: {},
			buildRow: function (group) {
				var row = $(&quot;&lt;li class='wiktku-zarava-row wiktku-lang-row'&gt;&lt;/li&gt;&quot;);
				var langSel = $(mw.html.element(&quot;select&quot;, {
					&quot;class&quot;: &quot;wiktku-start-step-keyfield wiktku-start-narrow&quot; }));
				langSel.attr(&quot;data-placeholder&quot;, &quot;Li zaravayekî bigere&quot;);
				populateMenus(langSel, steps.zarava.keys || [], steps.zarava.disabledKeys);

				langSel.on(&quot;change&quot;, function () {
					steps.zarava.onLangChange(group, row);
					refresh();
				});

				var wordList = $(&quot;&lt;ul class='wiktku-zarava-words wiktku-lang-row-words'&gt;&lt;/ul&gt;&quot;);
				var firstWord = steps.zarava.makeWordInput();
				wordList.append($(&quot;&lt;li&gt;&lt;/li&gt;&quot;).append(firstWord));

				row.append(langSel).append(wordList);
				return row;
			},

			makeWordInput: function () {
				var input = $(&quot;&lt;textarea&gt;&lt;/textarea&gt;&quot;)
					.attr(&quot;name&quot;, &quot;wiktku-zarava-word-&quot; + $.now() + &quot;-&quot; + Math.random().toString(36).substr(2, 9))
					.attr(&quot;rows&quot;, 1)
					.attr(&quot;class&quot;, &quot;wiktku-dfn-subfield wiktku-start-narrow&quot;)
					.attr(&quot;placeholder&quot;, &quot;Tercime…&quot;);
				input.on(&quot;input&quot;, function () {
					var list = $(this).closest(&quot;ul.wiktku-zarava-words&quot;);
					var item = $(this).parent();
					var val = $.trim($(this).val());
					if (val &amp;&amp; item.is(list.children(&quot;li:last-child&quot;))) {
						var next = steps.zarava.makeWordInput();
						list.append($(&quot;&lt;li&gt;&lt;/li&gt;&quot;).append(next));
					}
				});
				// Blur, not input -- refresh() re-syncs the whole form, same
				// reasoning as the Mane textareas' blur-only refresh below.
				input.on(&quot;blur&quot;, function () { refresh(); });
				return input;
			},

			onLangChange: function (group, row) {
				var list = group.find(&quot;ul.wiktku-zarava-list&quot;);
				var isLast = row.is(list.children(&quot;li.wiktku-zarava-row:last-child&quot;));
				if (isLast) {
					var newRow = steps.zarava.buildRow(group);
					list.append(newRow);
					// Attach the searchable picker now the row is in the DOM.
					initSelects(newRow);
				}
				steps.zarava.syncDisabledKeys(group);
			},

			/** Disables already-selected dialects in all other dropdowns within one group. */
			syncDisabledKeys: function (group) {
				var taken = $.extend({}, steps.zarava.disabledKeys);
				group.find(&quot;li.wiktku-zarava-row select&quot;).each(function () {
					var v = $(this).val();
					if (v) taken[v] = true;
				});
				group.find(&quot;li.wiktku-zarava-row select&quot;).each(function () {
					var self = $(this);
					var own = self.val();
					self.find(&quot;option&quot;).each(function () {
						var code = $(this).val();
						if (!code) return;
						$(this).prop(&quot;disabled&quot;, taken[code] &amp;&amp; code !== own);
					});
					self.trigger(&quot;wiktku:refresh&quot;);
				});
			},

			/** Builds (or fetches) the .wiktku-zarava-group for one gloss. */
			buildGroup: function (stepDiv, gi) {
				var group = $(&quot;&lt;div class='wiktku-zarava-group'&gt;&lt;/div&gt;&quot;).attr(&quot;data-gloss-pos&quot;, gi);
				var list = $(&quot;&lt;ul class='wiktku-zarava-list wiktku-lang-row-list'&gt;&lt;/ul&gt;&quot;);
				list.append(steps.zarava.buildRow(group));
				group.append(list);
				stepDiv.append(group);
				// Attach the searchable picker now the select is in the DOM.
				initSelects(list);
				return group;
			},

			/** Syncs one .wiktku-zarava-group per current gloss (same logic as steps.trans.build). */
			build: function (stepDiv) {
				var glosses = steps.trans.glossList();

				if (!glosses.length) {
					stepDiv.find(&quot;.wiktku-zarava-group&quot;).remove();
					return null;
				}

				var existingGroups = stepDiv.find(&quot;.wiktku-zarava-group&quot;);
				if (existingGroups.length &gt; glosses.length) {
					existingGroups.slice(glosses.length).remove();
				}

				$.each(glosses, function (gi, gloss) {
					var group = stepDiv.find(&quot;.wiktku-zarava-group[data-gloss-pos='&quot; + gi + &quot;']&quot;);
					if (!group.length) group = steps.zarava.buildGroup(stepDiv, gi);

					var label = group.find(&quot;.wiktku-zarava-group-label&quot;);
					if (glosses.length &gt; 1) {
						if (!label.length) {
							label = $(&quot;&lt;div class='wiktku-zarava-group-label'&gt;&lt;/div&gt;&quot;);
							group.prepend(label);
						}
						label.text(gloss.index + &quot; &quot; + gloss.text);
					} else if (label.length) {
						label.remove();
					}
				});

				return null;
			},

			/** Reads the dialect rows for a single gloss group. */
			getGroupTranslations: function (group) {
				var result = [];
				group.find(&quot;li.wiktku-zarava-row&quot;).each(function () {
					var lang = $(this).find(&quot;select&quot;).val();
					if (!lang) return;
					var words = [];
					$(this).find(&quot;ul.wiktku-zarava-words textarea&quot;).each(function () {
						var v = $.trim($(this).val());
						if (v) words.push(v);
					});
					if (words.length) result.push([lang, words]);
				});
				return result;
			},

			/** Reads all rows from the DOM, grouped by gloss position. */
			getTranslations: function (stepDiv) {
				var result = [];
				stepDiv.find(&quot;.wiktku-zarava-group&quot;).each(function () {
					result.push(steps.zarava.getGroupTranslations($(this)));
				});
				return result;
			},

			output: function (values) {
				return values.lang === &quot;ku&quot; ? glossBoxes(&quot;zarava&quot;, &quot;Bi zaravayên din&quot;) : &quot;&quot;;
			}
		},
		trans: {
			id: &quot;trans&quot;,
			name: &quot;werger&quot;,
			question_fmt: &quot;Tercimeyên vê maneyê bi zimanên din binivîse&quot;,
			visible: function (values) {
				if (!(values.lang === &quot;ku&quot; &amp;&amp; values.pos)) return false;
				// Hide only when every sense is a filled template sense (no plain
				// gloss to attach translations to). A mix, or nothing filled in
				// yet, still shows Werger.
				var dfnSenses = steps.dfn.getSenses($(&quot;#wiktku-start-dfn&quot;));
				var hasRealSense = dfnSenses.some(function (s) {
					return !s.tpl &amp;&amp; (s.mane !== &quot;&quot; || senseHasExtraContent(s));
				});
				var hasFilledTplSense = dfnSenses.some(function (s) {
					return s.tpl &amp;&amp; s.tplTitle;
				});
				return hasRealSense || !hasFilledTplSense;
			},
			disabledKeys: {
				&quot;navz&quot;: true,
				&quot;ku&quot;: true,
				&quot;ckb&quot;: true,
				&quot;sdh&quot;: true,
				&quot;lki&quot;: true,
				&quot;hac&quot;: true,
				&quot;zza&quot;: true },

			// Language dropdown + growing word-input list, scoped to one gloss's
			// group (each gloss has its own group and row list).
			buildRow: function (group) {
				var row = $(&quot;&lt;li class='wiktku-trans-row wiktku-lang-row'&gt;&lt;/li&gt;&quot;);

				// Language selector — the searchable picker is applied after insertion into DOM.
				var langSel = $(mw.html.element(&quot;select&quot;, {
					&quot;class&quot;: &quot;wiktku-start-step-keyfield wiktku-start-narrow&quot; }));
				langSel.attr(&quot;data-placeholder&quot;, &quot;Li zimanekî bigere&quot;);
				populateMenus(langSel, steps.trans.keys || [], steps.trans.disabledKeys);

				// When a language is chosen, ensure a next empty row exists.
				langSel.on(&quot;change&quot;, function () {
					steps.trans.onLangChange(group, row);
					refresh();
				});

				// Word list for this language.
				var wordList = $(&quot;&lt;ul class='wiktku-trans-words wiktku-lang-row-words'&gt;&lt;/ul&gt;&quot;);
				var firstWord = steps.trans.makeWordInput();
				wordList.append($(&quot;&lt;li&gt;&lt;/li&gt;&quot;).append(firstWord));

				// The searchable picker is attached by initSelects() once the row
				// is in the DOM (see onLangChange/buildGroup below).
				row.append(langSel).append(wordList);
				return row;
			},

			makeWordInput: function () {
				var input = $(&quot;&lt;textarea&gt;&lt;/textarea&gt;&quot;)
					.attr(&quot;name&quot;, &quot;wiktku-trans-word-&quot; + $.now() + &quot;-&quot; + Math.random().toString(36).substr(2, 9))
					.attr(&quot;rows&quot;, 1)
					.attr(&quot;class&quot;, &quot;wiktku-dfn-subfield wiktku-start-narrow&quot;)
					.attr(&quot;placeholder&quot;, &quot;Tercime…&quot;);
				input.on(&quot;input&quot;, function () {
					var list = $(this).closest(&quot;ul.wiktku-trans-words&quot;);
					var item = $(this).parent();
					var val = $.trim($(this).val());
					if (val &amp;&amp; item.is(list.children(&quot;li:last-child&quot;))) {
						var next = steps.trans.makeWordInput();
						list.append($(&quot;&lt;li&gt;&lt;/li&gt;&quot;).append(next));
					}
				});
				// Blur, not input -- refresh() re-syncs the whole form, same
				// reasoning as the Mane textareas' blur-only refresh below.
				input.on(&quot;blur&quot;, function () { refresh(); });
				return input;
			},

			onLangChange: function (group, row) {
				var list = group.find(&quot;ul.wiktku-trans-list&quot;);
				var isLast = row.is(list.children(&quot;li.wiktku-trans-row:last-child&quot;));
				if (isLast) {
					var newRow = steps.trans.buildRow(group);
					list.append(newRow);
					// Attach the searchable picker now the row is in the DOM.
					initSelects(newRow);
				}
				// Keep disabled keys in sync across this gloss's lang selectors
				// only — the same language can be used for different senses.
				steps.trans.syncDisabledKeys(group);
			},

			/** Disables already-selected languages in all other dropdowns within one group. */
			syncDisabledKeys: function (group) {
				var taken = $.extend({}, steps.trans.disabledKeys);
				group.find(&quot;li.wiktku-trans-row select&quot;).each(function () {
					var v = $(this).val();
					if (v) taken[v] = true;
				});
				group.find(&quot;li.wiktku-trans-row select&quot;).each(function () {
					var self = $(this);
					var own = self.val();
					self.find(&quot;option&quot;).each(function () {
						var code = $(this).val();
						if (!code) return;
						$(this).prop(&quot;disabled&quot;, taken[code] &amp;&amp; code !== own);
					});
					self.trigger(&quot;wiktku:refresh&quot;);
				});
			},

			// Builds (or fetches) the .wiktku-trans-group for one gloss.
			buildGroup: function (stepDiv, gi) {
				var group = $(&quot;&lt;div class='wiktku-trans-group'&gt;&lt;/div&gt;&quot;).attr(&quot;data-gloss-pos&quot;, gi);
				var list = $(&quot;&lt;ul class='wiktku-trans-list wiktku-lang-row-list'&gt;&lt;/ul&gt;&quot;);
				list.append(steps.trans.buildRow(group));
				group.append(list);
				stepDiv.append(group);
				// Attach the searchable picker now the select is in the DOM.
				initSelects(list);
				return group;
			},

			// Syncs one .wiktku-trans-group per current gloss, keyed by
			// data-gloss-pos so groups stay matched across rebuilds.
			build: function (stepDiv) {
				var glosses = steps.trans.glossList();

				if (!glosses.length) {
					stepDiv.find(&quot;.wiktku-trans-group&quot;).remove();
					return null;
				}

				// Drop groups for glosses that no longer exist (always from the
				// tail — groups are only ever appended in gloss order below).
				var existingGroups = stepDiv.find(&quot;.wiktku-trans-group&quot;);
				if (existingGroups.length &gt; glosses.length) {
					existingGroups.slice(glosses.length).remove();
				}

				$.each(glosses, function (gi, gloss) {
					var group = stepDiv.find(&quot;.wiktku-trans-group[data-gloss-pos='&quot; + gi + &quot;']&quot;);
					if (!group.length) group = steps.trans.buildGroup(stepDiv, gi);

					// Only label groups when there's more than one gloss to
					// distinguish between — a single gloss needs no caption.
					var label = group.find(&quot;.wiktku-trans-group-label&quot;);
					if (glosses.length &gt; 1) {
						if (!label.length) {
							label = $(&quot;&lt;div class='wiktku-trans-group-label'&gt;&lt;/div&gt;&quot;);
							group.prepend(label);
						}
						label.text(gloss.index + &quot; &quot; + gloss.text);
					} else if (label.length) {
						label.remove();
					}
				});

				return null;
			},

			/** Reads the translation rows for a single gloss group. */
			getGroupTranslations: function (group) {
				var result = [];
				group.find(&quot;li.wiktku-trans-row&quot;).each(function () {
					var lang = $(this).find(&quot;select&quot;).val();
					if (!lang) return;
					var words = [];
					$(this).find(&quot;ul.wiktku-trans-words textarea&quot;).each(function () {
						var v = $.trim($(this).val());
						if (v) words.push(v);
					});
					if (words.length) result.push([lang, words]);
				});
				return result;
			},

			// Reads all translation rows, grouped by gloss position.
			getTranslations: function (stepDiv) {
				var result = [];
				stepDiv.find(&quot;.wiktku-trans-group&quot;).each(function () {
					result.push(steps.trans.getGroupTranslations($(this)));
				});
				return result;
			},

			// Builds the numbered &quot;{ index, gloss }&quot; list, one per dfn sense
			// with a real mane (skips template senses). index is 1-based and
			// matches the sense's position in the &quot;#&quot; definition list.
			// When nothing's filled in, returns one placeholder entry so
			// Werger still has a group to attach to; when every sense is a
			// filled template sense, stays empty (matches trans.visible()).
			glossList: function () {
				var dfnSenses = steps.dfn.getSenses($(&quot;#wiktku-start-dfn&quot;));
				var glosses = [];
				var hasFilledTplSense = false;
				$.each(dfnSenses, function (i, s) {
					if (s.tpl) {
						if (s.tplTitle) hasFilledTplSense = true;
						return; // template sense — no gloss to caption with
					}
					var dfn = s.mane;
					if (!dfn) {
						// No mane, but other fields are filled — still gets a
						// gloss group since dfn.getOutput() emits {{mane?}} for it.
						if (senseHasExtraContent(s)) glosses.push({ index: i + 1, text: &quot;&quot; });
						return;
					}
					if (dfn[0] !== dfn[0].toLowerCase()) dfn = decapitalize(dfn);
					dfn = stripWikilinks(dfn).replace(/[.…?!)\]،؟]+$/, &quot;&quot;);
					glosses.push({ index: i + 1, text: dfn });
				});
				if (!glosses.length &amp;&amp; !hasFilledTplSense) {
					glosses.push({ index: 1, text: &quot;&quot; });
				}
				return glosses;
			},

			output: function (values) {
				return values.lang === &quot;ku&quot; ? glossBoxes(&quot;trans&quot;, &quot;Werger&quot;) : &quot;&quot;;
			}
		},
		cavkani: {
			id: &quot;cavkani&quot;,
			name: &quot;çavkanî&quot;,
			question_fmt: &quot;Çavkaniyên din (ne jêgirtin) lê zêde bike&quot;,
			visible: function (values) {
				return !!values.pos;
			},
			// Fills the insert-dropdown from the members of [[Kategorî:Çavkanî]].
			refreshTplSelect: function () {
				var sel = $(&quot;#wiktku-start-cavkani .wiktku-tpl-insert-select&quot;);
				if (!sel.length) return;
				sel.find(&quot;option[value!='']&quot;).remove();
				$.each(ctx.catSrcTemplates || [], function (_, entry) {
					sel.append($(&quot;&lt;option&gt;&lt;/option&gt;&quot;).val(entry.target).text(entry.label));
				});
				markTemplateOptions(sel, function (opt) { return opt.val(); });
				// Tell the picker the option list changed.
				sel.trigger(&quot;wiktku:refresh&quot;);
			},
			build: function (stepDiv) {
				if (stepDiv.find(&quot;.wiktku-cavkani-wrap&quot;).length) return null;

				var wrap = $(&quot;&lt;div class='wiktku-cavkani-wrap'&gt;&lt;/div&gt;&quot;);

				var ta = $(&quot;&lt;textarea&gt;&lt;/textarea&gt;&quot;)
					.attr(&quot;name&quot;, &quot;wiktku-cavkani-&quot; + $.now())
					.attr(&quot;class&quot;, &quot;wiktku-start-step-field wiktku-cavkani-text&quot;)
					.attr(&quot;rows&quot;, 4)
					.attr(&quot;placeholder&quot;, wiktkuUtil.msg.pickOrTypeTemplate);

				// Template insert dropdown, populated from [[Kategorî:Çavkanî]] —
				// options refreshed once the category members are fetched.
				var sel = $(&quot;&lt;select class='wiktku-tpl-insert-select'&gt;&lt;/select&gt;&quot;);
				sel.attr(&quot;data-placeholder&quot;, wiktkuUtil.msg.addTemplate);
				sel.append($(&quot;&lt;option value=''&gt;— şablonek lê zêde bike —&lt;/option&gt;&quot;));
				var status = $(&quot;&lt;span class='wiktku-cavkani-status'&gt;&lt;/span&gt;&quot;);

				// Same param dialog DefSideBoxes' own Çavkanî picker opens: the chosen template's
				// TemplateData becomes a form, so &quot;rûpel=&quot;, &quot;sernav=&quot; and the rest are filled in before
				// anything lands in the box, instead of a bare {{Ç:…}} to go back and complete by hand.
				sel.on(&quot;change&quot;, function () {
					var name = $(this).val();
					$(this).val(&quot;&quot;);
					sel.trigger(&quot;wiktku:refresh&quot;);
					if (!name) return;
					wiktkuCite.openTemplateDialog(&quot;{{&quot; + name + &quot;}}&quot;).then(function (edited) {
						if (!edited) {
							return; // cancelled, or removed a call that was never inserted
						}
						insertAtCursor(ta[0], &quot;* &quot; + edited + &quot;\n&quot;);
						ta.trigger(&quot;focus&quot;);
					});
				});

				wrap.append(sel);
				wrap.append(status).append(ta);
				stepDiv.append(wrap);
				// build() runs again for every new beş (see the &quot;+ Beşeke din&quot;
				// handler), after the initial page-wide pass — so this select needs
				// its own init or it stays a plain, unsearchable native &lt;select&gt;.
				initSelects(wrap);

				if (ctx.catSrcTemplates) {
					steps.cavkani.refreshTplSelect();
				} else {
					status.text(wiktkuUtil.msg.templatesLoading);
					fetchCatSrcTemplates().then(function () {
						steps.cavkani.refreshTplSelect();
						status.text(&quot;&quot;);
					}, function () {
						status.text(wiktkuUtil.msg.templatesFailed);
					});
				}
				return ta;
			},
			output: function () {
				var text = $.trim($(&quot;#wiktku-start-cavkani .wiktku-cavkani-text&quot;).val());
				if (!text) return &quot;&quot;;
				return &quot;\n==== Çavkanî ====\n&quot; + text + &quot;\n&quot;;
			}
		},
	});
};
// &lt;/nowiki&gt;</text>
      <sha1>41qu73uqjujtkmhmcblor40h5fepob6</sha1>
    </revision>
  </page>
</mediawiki>