From e64f398223cb559fb260f98e015ca54c96dd56b1 Mon Sep 17 00:00:00 2001 From: CytoDev Date: Tue, 10 May 2016 22:48:02 +0200 Subject: [PATCH] Initial LightDMMock "Class" Also adds images in users' their "home" directory. --- mock/LightDMMock.js | 399 +++++++++++++++++++++++++++++++++++ mock/basileusalex/.face | Bin 0 -> 3304 bytes mock/chairmanzedong/.face | Bin 0 -> 2789 bytes mock/cristocolombo/.face | Bin 0 -> 4030 bytes mock/gorbachev/.face | Bin 0 -> 3023 bytes mock/gustav2/.face | Bin 0 -> 4287 bytes mock/honourablewinston/.face | Bin 0 -> 3016 bytes mock/imperatoraugustus/.face | Bin 0 -> 2839 bytes mock/jackkennedy/.face | Bin 0 -> 3167 bytes mock/khagantemujin/.face | Bin 0 -> 3074 bytes mock/mehmedisani/.face | Bin 0 -> 4138 bytes mock/meijitaitei/.face | Bin 0 -> 2726 bytes mock/napoleonib/.face | Bin 0 -> 3993 bytes mock/peteralexeyevich/.face | Bin 0 -> 4459 bytes mock/redthorvald/.face | Bin 0 -> 4686 bytes mock/silentwill/.face | Bin 0 -> 3258 bytes mock/wilhelm1/.face | Bin 0 -> 3147 bytes 17 files changed, 399 insertions(+) create mode 100644 mock/LightDMMock.js create mode 100644 mock/basileusalex/.face create mode 100644 mock/chairmanzedong/.face create mode 100644 mock/cristocolombo/.face create mode 100644 mock/gorbachev/.face create mode 100644 mock/gustav2/.face create mode 100644 mock/honourablewinston/.face create mode 100644 mock/imperatoraugustus/.face create mode 100644 mock/jackkennedy/.face create mode 100644 mock/khagantemujin/.face create mode 100644 mock/mehmedisani/.face create mode 100644 mock/meijitaitei/.face create mode 100644 mock/napoleonib/.face create mode 100644 mock/peteralexeyevich/.face create mode 100644 mock/redthorvald/.face create mode 100644 mock/silentwill/.face create mode 100644 mock/wilhelm1/.face diff --git a/mock/LightDMMock.js b/mock/LightDMMock.js new file mode 100644 index 0000000..96159a6 --- /dev/null +++ b/mock/LightDMMock.js @@ -0,0 +1,399 @@ +/** + * LightDMMock "class" + * + * @author Roel Walraven + * + * A LightDM Mock that is tightly based on the source C code of + * Antergos' lightdm-webkit2-greeter. Please note that the deprecation errors + * are intrusive for a reason. + * + * Usage: + * Include the file in your theme that needs mocking + * + * Create a new instance of LightDMMock + * var lightdm = lightdm || new LightDMMock(autofill, timeout, autoGuest); + * + * @param {boolean} autofill [wether or not the arrays for users, languages, + * layouts, and sessions need to be filled with mock + * data. I advise to test both to make your theme + * less prone to crashing.] + * @param {number} timeout [Value to use for simulated autologin (this value + * is in seconds).] + * @param {boolean} autoGuest [Wether or not to simulate automatic guest login. + * This will also enable a guest account + * in lightdm.has_guest_account] + */ +"use strict"; + +function LightDMMock(autofill, timeout, autoGuest) { + this.hostname = null; + this.users = null; + this.default_language = window.deprecationNotifier("property", "lightdm.language"); + this.language = null; + this.languages = null; + this.default_layout = window.deprecationNotifier("property", "lightdm.layout"); + this.layouts = null; + this.layout = null; + this.sessions = null; + this.num_users = 0; + this.default_session = null; + this.timed_login_user = window.deprecationNotifier("property", "lightdm.autologin_user"); + this.timed_login_delay = window.deprecationNotifier("property", "lightdm.autologin_timeout"); + this.authentication_user = null; + this.in_authentication = false; + this.is_authenticated = false; + this.can_suspend = false; + this.can_hibernate = false; + this.can_restart = false; + this.can_shutdown = false; + this.lock_hint = false; + this.has_guest_account = false; + this.hide_users = false; + this.select_user = null; + this.select_guest = false; + this.autologin_user = null; + this.autologin_guest = false; + this.autologin_timeout = 0; + + if(autofill) { + this.users = JSON.parse(atob("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")); + this.languages = JSON.parse(atob("W3sibmFtZSI6IkVuZ2xpc2giLCJjb2RlIjoiZW4iLCJ0ZXJyaXRvcnkiOm51bGx9XQ==")); + this.layouts = JSON.parse(atob("[{"name":"us","short_description":"en","description":"English (US)"},{"name":"us\tchr","short_description":"chr","description":"Cherokee"},{"name":"us\teuro","short_description":"","description":"English (US, with euro on 5)"},{"name":"us\tintl","short_description":"","description":"English (US, international with dead keys)"},{"name":"us\talt-intl","short_description":"","description":"English (US, alternative international)"},{"name":"us\tcolemak","short_description":"","description":"English (Colemak)"},{"name":"us\tdvorak","short_description":"","description":"English (Dvorak)"},{"name":"us\tdvorak-intl","short_description":"","description":"English (Dvorak, international with dead keys)"},{"name":"us\tdvorak-alt-intl","short_description":"","description":"English (Dvorak alternative international no dead keys)"},{"name":"us\tdvorak-l","short_description":"","description":"English (left handed Dvorak)"},{"name":"us\tdvorak-r","short_description":"","description":"English (right handed Dvorak)"},{"name":"us\tdvorak-classic","short_description":"","description":"English (classic Dvorak)"},{"name":"us\tdvp","short_description":"","description":"English (programmer Dvorak)"},{"name":"us\trus","short_description":"ru","description":"Russian (US, phonetic)"},{"name":"us\tmac","short_description":"","description":"English (Macintosh)"},{"name":"us\taltgr-intl","short_description":"","description":"English (international AltGr dead keys)"},{"name":"us\tolpc2","short_description":"","description":"English (the divide/multiply keys toggle the layout)"},{"name":"us\thbs","short_description":"","description":"Serbo-Croatian (US)"},{"name":"us\tworkman","short_description":"","description":"English (Workman)"},{"name":"us\tworkman-intl","short_description":"","description":"English (Workman, international with dead keys)"},{"name":"af","short_description":"fa","description":"Afghani"},{"name":"af\tps","short_description":"ps","description":"Pashto"},{"name":"af\tuz","short_description":"uz","description":"Uzbek (Afghanistan)"},{"name":"af\tolpc-ps","short_description":"ps","description":"Pashto (Afghanistan, OLPC)"},{"name":"af\tfa-olpc","short_description":"fa","description":"Persian (Afghanistan, Dari OLPC)"},{"name":"af\tuz-olpc","short_description":"uz","description":"Uzbek (Afghanistan, OLPC)"},{"name":"ara","short_description":"ar","description":"Arabic"},{"name":"ara\tazerty","short_description":"","description":"Arabic (azerty)"},{"name":"ara\tazerty_digits","short_description":"","description":"Arabic (azerty/digits)"},{"name":"ara\tdigits","short_description":"","description":"Arabic (digits)"},{"name":"ara\tqwerty","short_description":"","description":"Arabic (qwerty)"},{"name":"ara\tqwerty_digits","short_description":"","description":"Arabic (qwerty/digits)"},{"name":"ara\tbuckwalter","short_description":"","description":"Arabic (Buckwalter)"},{"name":"al","short_description":"sq","description":"Albanian"},{"name":"am","short_description":"hy","description":"Armenian"},{"name":"am\tphonetic","short_description":"","description":"Armenian (phonetic)"},{"name":"am\tphonetic-alt","short_description":"","description":"Armenian (alternative phonetic)"},{"name":"am\teastern","short_description":"","description":"Armenian (eastern)"},{"name":"am\twestern","short_description":"","description":"Armenian (western)"},{"name":"am\teastern-alt","short_description":"","description":"Armenian (alternative eastern)"},{"name":"at","short_description":"de","description":"German (Austria)"},{"name":"at\tnodeadkeys","short_description":"","description":"German (Austria, eliminate dead keys)"},{"name":"at\tsundeadkeys","short_description":"","description":"German (Austria, Sun dead keys)"},{"name":"at\tmac","short_description":"","description":"German (Austria, Macintosh)"},{"name":"az","short_description":"az","description":"Azerbaijani"},{"name":"az\tcyrillic","short_description":"","description":"Azerbaijani (Cyrillic)"},{"name":"by","short_description":"by","description":"Belarusian"},{"name":"by\tlegacy","short_description":"","description":"Belarusian (legacy)"},{"name":"by\tlatin","short_description":"","description":"Belarusian (Latin)"},{"name":"be","short_description":"be","description":"Belgian"},{"name":"be\toss","short_description":"","description":"Belgian (alternative)"},{"name":"be\toss_latin9","short_description":"","description":"Belgian (alternative, Latin-9 only)"},{"name":"be\toss_sundeadkeys","short_description":"","description":"Belgian (alternative, Sun dead keys)"},{"name":"be\tiso-alternate","short_description":"","description":"Belgian (ISO alternate)"},{"name":"be\tnodeadkeys","short_description":"","description":"Belgian (eliminate dead keys)"},{"name":"be\tsundeadkeys","short_description":"","description":"Belgian (Sun dead keys)"},{"name":"be\twang","short_description":"","description":"Belgian (Wang model 724 azerty)"},{"name":"bd","short_description":"bn","description":"Bangla"},{"name":"bd\tprobhat","short_description":"","description":"Bangla (Probhat)"},{"name":"in","short_description":"in","description":"Indian"},{"name":"in\tben","short_description":"bn","description":"Bangla (India)"},{"name":"in\tben_probhat","short_description":"bn","description":"Bangla (India, Probhat)"},{"name":"in\tben_baishakhi","short_description":"","description":"Bangla (India, Baishakhi)"},{"name":"in\tben_bornona","short_description":"","description":"Bangla (India, Bornona)"},{"name":"in\tben_gitanjali","short_description":"","description":"Bangla (India, Uni Gitanjali)"},{"name":"in\tben_inscript","short_description":"","description":"Bangla (India, Baishakhi Inscript)"},{"name":"in\tguj","short_description":"gu","description":"Gujarati"},{"name":"in\tguru","short_description":"pa","description":"Punjabi (Gurmukhi)"},{"name":"in\tjhelum","short_description":"pa","description":"Punjabi (Gurmukhi Jhelum)"},{"name":"in\tkan","short_description":"kn","description":"Kannada"},{"name":"in\tkan-kagapa","short_description":"kn","description":"Kannada (KaGaPa phonetic)"},{"name":"in\tmal","short_description":"ml","description":"Malayalam"},{"name":"in\tmal_lalitha","short_description":"ml","description":"Malayalam (Lalitha)"},{"name":"in\tmal_enhanced","short_description":"ml","description":"Malayalam (enhanced Inscript with Rupee Sign)"},{"name":"in\tori","short_description":"or","description":"Oriya"},{"name":"in\ttam_unicode","short_description":"ta","description":"Tamil (Unicode)"},{"name":"in\ttam_keyboard_with_numerals","short_description":"ta","description":"Tamil (keyboard with numerals)"},{"name":"in\ttam_TAB","short_description":"ta","description":"Tamil (TAB typewriter)"},{"name":"in\ttam_TSCII","short_description":"ta","description":"Tamil (TSCII typewriter)"},{"name":"in\ttam","short_description":"ta","description":"Tamil"},{"name":"in\ttel","short_description":"te","description":"Telugu"},{"name":"in\ttel-kagapa","short_description":"te","description":"Telugu (KaGaPa phonetic)"},{"name":"in\turd-phonetic","short_description":"ur","description":"Urdu (phonetic)"},{"name":"in\turd-phonetic3","short_description":"ur","description":"Urdu (alternative phonetic)"},{"name":"in\turd-winkeys","short_description":"ur","description":"Urdu (WinKeys)"},{"name":"in\tbolnagri","short_description":"hi","description":"Hindi (Bolnagri)"},{"name":"in\thin-wx","short_description":"hi","description":"Hindi (Wx)"},{"name":"in\thin-kagapa","short_description":"hi","description":"Hindi (KaGaPa phonetic)"},{"name":"in\tsan-kagapa","short_description":"sa","description":"Sanskrit (KaGaPa phonetic)"},{"name":"in\tmar-kagapa","short_description":"mr","description":"Marathi (KaGaPa phonetic)"},{"name":"in\teng","short_description":"en","description":"English (India, with RupeeSign)"},{"name":"ba","short_description":"bs","description":"Bosnian"},{"name":"ba\talternatequotes","short_description":"","description":"Bosnian (use guillemets for quotes)"},{"name":"ba\tunicode","short_description":"","description":"Bosnian (use Bosnian digraphs)"},{"name":"ba\tunicodeus","short_description":"","description":"Bosnian (US keyboard with Bosnian digraphs)"},{"name":"ba\tus","short_description":"","description":"Bosnian (US keyboard with Bosnian letters)"},{"name":"br","short_description":"pt","description":"Portuguese (Brazil)"},{"name":"br\tnodeadkeys","short_description":"","description":"Portuguese (Brazil, eliminate dead keys)"},{"name":"br\tdvorak","short_description":"","description":"Portuguese (Brazil, Dvorak)"},{"name":"br\tnativo","short_description":"","description":"Portuguese (Brazil, nativo)"},{"name":"br\tnativo-us","short_description":"","description":"Portuguese (Brazil, nativo for US keyboards)"},{"name":"br\tnativo-epo","short_description":"","description":"Portuguese (Brazil, nativo for Esperanto)"},{"name":"bg","short_description":"bg","description":"Bulgarian"},{"name":"bg\tphonetic","short_description":"","description":"Bulgarian (traditional phonetic)"},{"name":"bg\tbas_phonetic","short_description":"","description":"Bulgarian (new phonetic)"},{"name":"ma","short_description":"ar","description":"Arabic (Morocco)"},{"name":"ma\tfrench","short_description":"fr","description":"French (Morocco)"},{"name":"ma\ttifinagh","short_description":"ber","description":"Berber (Morocco, Tifinagh)"},{"name":"ma\ttifinagh-alt","short_description":"ber","description":"Berber (Morocco, Tifinagh alternative)"},{"name":"ma\ttifinagh-alt-phonetic","short_description":"ber","description":"Berber (Morocco, Tifinagh alternative phonetic)"},{"name":"ma\ttifinagh-extended","short_description":"ber","description":"Berber (Morocco, Tifinagh extended)"},{"name":"ma\ttifinagh-phonetic","short_description":"ber","description":"Berber (Morocco, Tifinagh phonetic)"},{"name":"ma\ttifinagh-extended-phonetic","short_description":"ber","description":"Berber (Morocco, Tifinagh extended phonetic)"},{"name":"cm","short_description":"cm","description":"English (Cameroon)"},{"name":"cm\tfrench","short_description":"","description":"French (Cameroon)"},{"name":"cm\tqwerty","short_description":"","description":"Cameroon Multilingual (qwerty)"},{"name":"cm\tazerty","short_description":"","description":"Cameroon Multilingual (azerty)"},{"name":"cm\tdvorak","short_description":"","description":"Cameroon Multilingual (Dvorak)"},{"name":"mm","short_description":"my","description":"Burmese"},{"name":"ca","short_description":"fr","description":"French (Canada)"},{"name":"ca\tfr-dvorak","short_description":"fr","description":"French (Canada, Dvorak)"},{"name":"ca\tfr-legacy","short_description":"fr","description":"French (Canada, legacy)"},{"name":"ca\tmultix","short_description":"","description":"Canadian Multilingual"},{"name":"ca\tmulti","short_description":"","description":"Canadian Multilingual (first part)"},{"name":"ca\tmulti-2gr","short_description":"","description":"Canadian Multilingual (second part)"},{"name":"ca\tike","short_description":"ike","description":"Inuktitut"},{"name":"ca\teng","short_description":"en","description":"English (Canada)"},{"name":"cd","short_description":"fr","description":"French (Democratic Republic of the Congo)"},{"name":"cn","short_description":"zh","description":"Chinese"},{"name":"cn\ttib","short_description":"","description":"Tibetan"},{"name":"cn\ttib_asciinum","short_description":"","description":"Tibetan (with ASCII numerals)"},{"name":"cn\tuig","short_description":"","description":"Uyghur"},{"name":"hr","short_description":"hr","description":"Croatian"},{"name":"hr\talternatequotes","short_description":"","description":"Croatian (use guillemets for quotes)"},{"name":"hr\tunicode","short_description":"","description":"Croatian (use Croatian digraphs)"},{"name":"hr\tunicodeus","short_description":"","description":"Croatian (US keyboard with Croatian digraphs)"},{"name":"hr\tus","short_description":"","description":"Croatian (US keyboard with Croatian letters)"},{"name":"cz","short_description":"cs","description":"Czech"},{"name":"cz\tbksl","short_description":"","description":"Czech (with <\\|> key)"},{"name":"cz\tqwerty","short_description":"","description":"Czech (qwerty)"},{"name":"cz\tqwerty_bksl","short_description":"","description":"Czech (qwerty, extended Backslash)"},{"name":"cz\tucw","short_description":"","description":"Czech (UCW layout, accented letters only)"},{"name":"cz\tdvorak-ucw","short_description":"","description":"Czech (US Dvorak with CZ UCW support)"},{"name":"dk","short_description":"da","description":"Danish"},{"name":"dk\tnodeadkeys","short_description":"","description":"Danish (eliminate dead keys)"},{"name":"dk\tmac","short_description":"","description":"Danish (Macintosh)"},{"name":"dk\tmac_nodeadkeys","short_description":"","description":"Danish (Macintosh, eliminate dead keys)"},{"name":"dk\tdvorak","short_description":"","description":"Danish (Dvorak)"},{"name":"nl","short_description":"nl","description":"Dutch"},{"name":"nl\tsundeadkeys","short_description":"","description":"Dutch (Sun dead keys)"},{"name":"nl\tmac","short_description":"","description":"Dutch (Macintosh)"},{"name":"nl\tstd","short_description":"","description":"Dutch (standard)"},{"name":"bt","short_description":"dz","description":"Dzongkha"},{"name":"ee","short_description":"et","description":"Estonian"},{"name":"ee\tnodeadkeys","short_description":"","description":"Estonian (eliminate dead keys)"},{"name":"ee\tdvorak","short_description":"","description":"Estonian (Dvorak)"},{"name":"ee\tus","short_description":"","description":"Estonian (US keyboard with Estonian letters)"},{"name":"ir","short_description":"fa","description":"Persian"},{"name":"ir\tpes_keypad","short_description":"","description":"Persian (with Persian Keypad)"},{"name":"ir\tku","short_description":"ku","description":"Kurdish (Iran, Latin Q)"},{"name":"ir\tku_f","short_description":"ku","description":"Kurdish (Iran, F)"},{"name":"ir\tku_alt","short_description":"ku","description":"Kurdish (Iran, Latin Alt-Q)"},{"name":"ir\tku_ara","short_description":"ku","description":"Kurdish (Iran, Arabic-Latin)"},{"name":"iq","short_description":"ar","description":"Iraqi"},{"name":"iq\tku","short_description":"ku","description":"Kurdish (Iraq, Latin Q)"},{"name":"iq\tku_f","short_description":"ku","description":"Kurdish (Iraq, F)"},{"name":"iq\tku_alt","short_description":"ku","description":"Kurdish (Iraq, Latin Alt-Q)"},{"name":"iq\tku_ara","short_description":"ku","description":"Kurdish (Iraq, Arabic-Latin)"},{"name":"fo","short_description":"fo","description":"Faroese"},{"name":"fo\tnodeadkeys","short_description":"","description":"Faroese (eliminate dead keys)"},{"name":"fi","short_description":"fi","description":"Finnish"},{"name":"fi\tclassic","short_description":"","description":"Finnish (classic)"},{"name":"fi\tnodeadkeys","short_description":"","description":"Finnish (classic, eliminate dead keys)"},{"name":"fi\tsmi","short_description":"","description":"Northern Saami (Finland)"},{"name":"fi\tmac","short_description":"","description":"Finnish (Macintosh)"},{"name":"fr","short_description":"fr","description":"French"},{"name":"fr\tnodeadkeys","short_description":"","description":"French (eliminate dead keys)"},{"name":"fr\tsundeadkeys","short_description":"","description":"French (Sun dead keys)"},{"name":"fr\toss","short_description":"","description":"French (alternative)"},{"name":"fr\toss_latin9","short_description":"","description":"French (alternative, Latin-9 only)"},{"name":"fr\toss_nodeadkeys","short_description":"","description":"French (alternative, eliminate dead keys)"},{"name":"fr\toss_sundeadkeys","short_description":"","description":"French (alternative, Sun dead keys)"},{"name":"fr\tlatin9","short_description":"","description":"French (legacy, alternative)"},{"name":"fr\tlatin9_nodeadkeys","short_description":"","description":"French (legacy, alternative, eliminate dead keys)"},{"name":"fr\tlatin9_sundeadkeys","short_description":"","description":"French (legacy, alternative, Sun dead keys)"},{"name":"fr\tbepo","short_description":"","description":"French (Bepo, ergonomic, Dvorak way)"},{"name":"fr\tbepo_latin9","short_description":"","description":"French (Bepo, ergonomic, Dvorak way, Latin-9 only)"},{"name":"fr\tdvorak","short_description":"","description":"French (Dvorak)"},{"name":"fr\tmac","short_description":"","description":"French (Macintosh)"},{"name":"fr\tbre","short_description":"","description":"French (Breton)"},{"name":"fr\toci","short_description":"","description":"Occitan"},{"name":"fr\tgeo","short_description":"","description":"Georgian (France, AZERTY Tskapo)"},{"name":"gh","short_description":"en","description":"English (Ghana)"},{"name":"gh\tgeneric","short_description":"","description":"English (Ghana, multilingual)"},{"name":"gh\takan","short_description":"ak","description":"Akan"},{"name":"gh\tewe","short_description":"ee","description":"Ewe"},{"name":"gh\tfula","short_description":"ff","description":"Fula"},{"name":"gh\tga","short_description":"gaa","description":"Ga"},{"name":"gh\thausa","short_description":"ha","description":"Hausa"},{"name":"gh\tavn","short_description":"avn","description":"Avatime"},{"name":"gh\tgillbt","short_description":"","description":"English (Ghana, GILLBT)"},{"name":"gn","short_description":"fr","description":"French (Guinea)"},{"name":"ge","short_description":"ka","description":"Georgian"},{"name":"ge\tergonomic","short_description":"","description":"Georgian (ergonomic)"},{"name":"ge\tmess","short_description":"","description":"Georgian (MESS)"},{"name":"ge\tru","short_description":"ru","description":"Russian (Georgia)"},{"name":"ge\tos","short_description":"","description":"Ossetian (Georgia)"},{"name":"de","short_description":"de","description":"German"},{"name":"de\tdeadacute","short_description":"","description":"German (dead acute)"},{"name":"de\tdeadgraveacute","short_description":"","description":"German (dead grave acute)"},{"name":"de\tnodeadkeys","short_description":"","description":"German (eliminate dead keys)"},{"name":"de\tT3","short_description":"","description":"German (T3)"},{"name":"de\tro","short_description":"","description":"Romanian (Germany)"},{"name":"de\tro_nodeadkeys","short_description":"","description":"Romanian (Germany, eliminate dead keys)"},{"name":"de\tdvorak","short_description":"","description":"German (Dvorak)"},{"name":"de\tsundeadkeys","short_description":"","description":"German (Sun dead keys)"},{"name":"de\tneo","short_description":"","description":"German (Neo 2)"},{"name":"de\tmac","short_description":"","description":"German (Macintosh)"},{"name":"de\tmac_nodeadkeys","short_description":"","description":"German (Macintosh, eliminate dead keys)"},{"name":"de\tdsb","short_description":"","description":"Lower Sorbian"},{"name":"de\tdsb_qwertz","short_description":"","description":"Lower Sorbian (qwertz)"},{"name":"de\tqwerty","short_description":"","description":"German (qwerty)"},{"name":"de\tru","short_description":"ru","description":"Russian (Germany, phonetic)"},{"name":"de\tlegacy","short_description":"","description":"German (legacy)"},{"name":"gr","short_description":"gr","description":"Greek"},{"name":"gr\tsimple","short_description":"","description":"Greek (simple)"},{"name":"gr\textended","short_description":"","description":"Greek (extended)"},{"name":"gr\tnodeadkeys","short_description":"","description":"Greek (eliminate dead keys)"},{"name":"gr\tpolytonic","short_description":"","description":"Greek (polytonic)"},{"name":"hu","short_description":"hu","description":"Hungarian"},{"name":"hu\tstandard","short_description":"","description":"Hungarian (standard)"},{"name":"hu\tnodeadkeys","short_description":"","description":"Hungarian (eliminate dead keys)"},{"name":"hu\tqwerty","short_description":"","description":"Hungarian (qwerty)"},{"name":"hu\t101_qwertz_comma_dead","short_description":"","description":"Hungarian (101/qwertz/comma/dead keys)"},{"name":"hu\t101_qwertz_comma_nodead","short_description":"","description":"Hungarian (101/qwertz/comma/eliminate dead keys)"},{"name":"hu\t101_qwertz_dot_dead","short_description":"","description":"Hungarian (101/qwertz/dot/dead keys)"},{"name":"hu\t101_qwertz_dot_nodead","short_description":"","description":"Hungarian (101/qwertz/dot/eliminate dead keys)"},{"name":"hu\t101_qwerty_comma_dead","short_description":"","description":"Hungarian (101/qwerty/comma/dead keys)"},{"name":"hu\t101_qwerty_comma_nodead","short_description":"","description":"Hungarian (101/qwerty/comma/eliminate dead keys)"},{"name":"hu\t101_qwerty_dot_dead","short_description":"","description":"Hungarian (101/qwerty/dot/dead keys)"},{"name":"hu\t101_qwerty_dot_nodead","short_description":"","description":"Hungarian (101/qwerty/dot/eliminate dead keys)"},{"name":"hu\t102_qwertz_comma_dead","short_description":"","description":"Hungarian (102/qwertz/comma/dead keys)"},{"name":"hu\t102_qwertz_comma_nodead","short_description":"","description":"Hungarian (102/qwertz/comma/eliminate dead keys)"},{"name":"hu\t102_qwertz_dot_dead","short_description":"","description":"Hungarian (102/qwertz/dot/dead keys)"},{"name":"hu\t102_qwertz_dot_nodead","short_description":"","description":"Hungarian (102/qwertz/dot/eliminate dead keys)"},{"name":"hu\t102_qwerty_comma_dead","short_description":"","description":"Hungarian (102/qwerty/comma/dead keys)"},{"name":"hu\t102_qwerty_comma_nodead","short_description":"","description":"Hungarian (102/qwerty/comma/eliminate dead keys)"},{"name":"hu\t102_qwerty_dot_dead","short_description":"","description":"Hungarian (102/qwerty/dot/dead keys)"},{"name":"hu\t102_qwerty_dot_nodead","short_description":"","description":"Hungarian (102/qwerty/dot/eliminate dead keys)"},{"name":"is","short_description":"is","description":"Icelandic"},{"name":"is\tSundeadkeys","short_description":"","description":"Icelandic (Sun dead keys)"},{"name":"is\tnodeadkeys","short_description":"","description":"Icelandic (eliminate dead keys)"},{"name":"is\tmac","short_description":"","description":"Icelandic (Macintosh)"},{"name":"is\tdvorak","short_description":"","description":"Icelandic (Dvorak)"},{"name":"il","short_description":"he","description":"Hebrew"},{"name":"il\tlyx","short_description":"","description":"Hebrew (lyx)"},{"name":"il\tphonetic","short_description":"","description":"Hebrew (phonetic)"},{"name":"il\tbiblical","short_description":"","description":"Hebrew (Biblical, Tiro)"},{"name":"it","short_description":"it","description":"Italian"},{"name":"it\tnodeadkeys","short_description":"","description":"Italian (eliminate dead keys)"},{"name":"it\tmac","short_description":"","description":"Italian (Macintosh)"},{"name":"it\tus","short_description":"","description":"Italian (US keyboard with Italian letters)"},{"name":"it\tgeo","short_description":"","description":"Georgian (Italy)"},{"name":"it\tibm","short_description":"","description":"Italian (IBM 142)"},{"name":"jp","short_description":"ja","description":"Japanese"},{"name":"jp\tkana","short_description":"","description":"Japanese (Kana)"},{"name":"jp\tkana86","short_description":"","description":"Japanese (Kana 86)"},{"name":"jp\tOADG109A","short_description":"","description":"Japanese (OADG 109A)"},{"name":"jp\tmac","short_description":"","description":"Japanese (Macintosh)"},{"name":"jp\tdvorak","short_description":"","description":"Japanese (Dvorak)"},{"name":"kg","short_description":"ki","description":"Kyrgyz"},{"name":"kg\tphonetic","short_description":"","description":"Kyrgyz (phonetic)"},{"name":"kh","short_description":"km","description":"Khmer (Cambodia)"},{"name":"kz","short_description":"kk","description":"Kazakh"},{"name":"kz\truskaz","short_description":"ru","description":"Russian (Kazakhstan, with Kazakh)"},{"name":"kz\tkazrus","short_description":"","description":"Kazakh (with Russian)"},{"name":"la","short_description":"lo","description":"Lao"},{"name":"la\tstea","short_description":"","description":"Lao (STEA proposed standard layout)"},{"name":"latam","short_description":"es","description":"Spanish (Latin American)"},{"name":"latam\tnodeadkeys","short_description":"","description":"Spanish (Latin American, eliminate dead keys)"},{"name":"latam\tdeadtilde","short_description":"","description":"Spanish (Latin American, include dead tilde)"},{"name":"latam\tsundeadkeys","short_description":"","description":"Spanish (Latin American, Sun dead keys)"},{"name":"lt","short_description":"lt","description":"Lithuanian"},{"name":"lt\tstd","short_description":"","description":"Lithuanian (standard)"},{"name":"lt\tus","short_description":"","description":"Lithuanian (US keyboard with Lithuanian letters)"},{"name":"lt\tibm","short_description":"","description":"Lithuanian (IBM LST 1205-92)"},{"name":"lt\tlekp","short_description":"","description":"Lithuanian (LEKP)"},{"name":"lt\tlekpa","short_description":"","description":"Lithuanian (LEKPa)"},{"name":"lv","short_description":"lv","description":"Latvian"},{"name":"lv\tapostrophe","short_description":"","description":"Latvian (apostrophe variant)"},{"name":"lv\ttilde","short_description":"","description":"Latvian (tilde variant)"},{"name":"lv\tfkey","short_description":"","description":"Latvian (F variant)"},{"name":"lv\tmodern","short_description":"","description":"Latvian (modern)"},{"name":"lv\tergonomic","short_description":"","description":"Latvian (ergonomic, ŪGJRMV)"},{"name":"lv\tadapted","short_description":"","description":"Latvian (adapted)"},{"name":"mao","short_description":"mi","description":"Maori"},{"name":"me","short_description":"sr","description":"Montenegrin"},{"name":"me\tcyrillic","short_description":"","description":"Montenegrin (Cyrillic)"},{"name":"me\tcyrillicyz","short_description":"","description":"Montenegrin (Cyrillic, Z and ZHE swapped)"},{"name":"me\tlatinunicode","short_description":"","description":"Montenegrin (Latin Unicode)"},{"name":"me\tlatinyz","short_description":"","description":"Montenegrin (Latin qwerty)"},{"name":"me\tlatinunicodeyz","short_description":"","description":"Montenegrin (Latin Unicode qwerty)"},{"name":"me\tcyrillicalternatequotes","short_description":"","description":"Montenegrin (Cyrillic with guillemets)"},{"name":"me\tlatinalternatequotes","short_description":"","description":"Montenegrin (Latin with guillemets)"},{"name":"mk","short_description":"mk","description":"Macedonian"},{"name":"mk\tnodeadkeys","short_description":"","description":"Macedonian (eliminate dead keys)"},{"name":"mt","short_description":"mt","description":"Maltese"},{"name":"mt\tus","short_description":"","description":"Maltese (with US layout)"},{"name":"mn","short_description":"mn","description":"Mongolian"},{"name":"no","short_description":"no","description":"Norwegian"},{"name":"no\tnodeadkeys","short_description":"","description":"Norwegian (eliminate dead keys)"},{"name":"no\tdvorak","short_description":"","description":"Norwegian (Dvorak)"},{"name":"no\tsmi","short_description":"","description":"Northern Saami (Norway)"},{"name":"no\tsmi_nodeadkeys","short_description":"","description":"Northern Saami (Norway, eliminate dead keys)"},{"name":"no\tmac","short_description":"","description":"Norwegian (Macintosh)"},{"name":"no\tmac_nodeadkeys","short_description":"","description":"Norwegian (Macintosh, eliminate dead keys)"},{"name":"no\tcolemak","short_description":"","description":"Norwegian (Colemak)"},{"name":"pl","short_description":"pl","description":"Polish"},{"name":"pl\tlegacy","short_description":"","description":"Polish (legacy)"},{"name":"pl\tqwertz","short_description":"","description":"Polish (qwertz)"},{"name":"pl\tdvorak","short_description":"","description":"Polish (Dvorak)"},{"name":"pl\tdvorak_quotes","short_description":"","description":"Polish (Dvorak, Polish quotes on quotemark key)"},{"name":"pl\tdvorak_altquotes","short_description":"","description":"Polish (Dvorak, Polish quotes on key 1)"},{"name":"pl\tcsb","short_description":"","description":"Kashubian"},{"name":"pl\tszl","short_description":"","description":"Silesian"},{"name":"pl\tru_phonetic_dvorak","short_description":"ru","description":"Russian (Poland, phonetic Dvorak)"},{"name":"pl\tdvp","short_description":"","description":"Polish (programmer Dvorak)"},{"name":"pt","short_description":"pt","description":"Portuguese"},{"name":"pt\tnodeadkeys","short_description":"","description":"Portuguese (eliminate dead keys)"},{"name":"pt\tsundeadkeys","short_description":"","description":"Portuguese (Sun dead keys)"},{"name":"pt\tmac","short_description":"","description":"Portuguese (Macintosh)"},{"name":"pt\tmac_nodeadkeys","short_description":"","description":"Portuguese (Macintosh, eliminate dead keys)"},{"name":"pt\tmac_sundeadkeys","short_description":"","description":"Portuguese (Macintosh, Sun dead keys)"},{"name":"pt\tnativo","short_description":"","description":"Portuguese (Nativo)"},{"name":"pt\tnativo-us","short_description":"","description":"Portuguese (Nativo for US keyboards)"},{"name":"pt\tnativo-epo","short_description":"","description":"Esperanto (Portugal, Nativo)"},{"name":"ro","short_description":"ro","description":"Romanian"},{"name":"ro\tcedilla","short_description":"","description":"Romanian (cedilla)"},{"name":"ro\tstd","short_description":"","description":"Romanian (standard)"},{"name":"ro\tstd_cedilla","short_description":"","description":"Romanian (standard cedilla)"},{"name":"ro\twinkeys","short_description":"","description":"Romanian (WinKeys)"},{"name":"ru","short_description":"ru","description":"Russian"},{"name":"ru\tphonetic","short_description":"","description":"Russian (phonetic)"},{"name":"ru\tphonetic_winkeys","short_description":"","description":"Russian (phonetic WinKeys)"},{"name":"ru\ttypewriter","short_description":"","description":"Russian (typewriter)"},{"name":"ru\tlegacy","short_description":"","description":"Russian (legacy)"},{"name":"ru\ttypewriter-legacy","short_description":"","description":"Russian (typewriter, legacy)"},{"name":"ru\ttt","short_description":"","description":"Tatar"},{"name":"ru\tos_legacy","short_description":"","description":"Ossetian (legacy)"},{"name":"ru\tos_winkeys","short_description":"","description":"Ossetian (WinKeys)"},{"name":"ru\tcv","short_description":"","description":"Chuvash"},{"name":"ru\tcv_latin","short_description":"","description":"Chuvash (Latin)"},{"name":"ru\tudm","short_description":"","description":"Udmurt"},{"name":"ru\tkom","short_description":"","description":"Komi"},{"name":"ru\tsah","short_description":"","description":"Yakut"},{"name":"ru\txal","short_description":"","description":"Kalmyk"},{"name":"ru\tdos","short_description":"","description":"Russian (DOS)"},{"name":"ru\tmac","short_description":"","description":"Russian (Macintosh)"},{"name":"ru\tsrp","short_description":"","description":"Serbian (Russia)"},{"name":"ru\tbak","short_description":"","description":"Bashkirian"},{"name":"ru\tchm","short_description":"","description":"Mari"},{"name":"rs","short_description":"sr","description":"Serbian"},{"name":"rs\tyz","short_description":"","description":"Serbian (Cyrillic, Z and ZHE swapped)"},{"name":"rs\tlatin","short_description":"","description":"Serbian (Latin)"},{"name":"rs\tlatinunicode","short_description":"","description":"Serbian (Latin Unicode)"},{"name":"rs\tlatinyz","short_description":"","description":"Serbian (Latin qwerty)"},{"name":"rs\tlatinunicodeyz","short_description":"","description":"Serbian (Latin Unicode qwerty)"},{"name":"rs\talternatequotes","short_description":"","description":"Serbian (Cyrillic with guillemets)"},{"name":"rs\tlatinalternatequotes","short_description":"","description":"Serbian (Latin with guillemets)"},{"name":"rs\true","short_description":"","description":"Pannonian Rusyn (homophonic)"},{"name":"si","short_description":"sl","description":"Slovenian"},{"name":"si\talternatequotes","short_description":"","description":"Slovenian (use guillemets for quotes)"},{"name":"si\tus","short_description":"","description":"Slovenian (US keyboard with Slovenian letters)"},{"name":"sk","short_description":"sk","description":"Slovak"},{"name":"sk\tbksl","short_description":"","description":"Slovak (extended Backslash)"},{"name":"sk\tqwerty","short_description":"","description":"Slovak (qwerty)"},{"name":"sk\tqwerty_bksl","short_description":"","description":"Slovak (qwerty, extended Backslash)"},{"name":"es","short_description":"es","description":"Spanish"},{"name":"es\tnodeadkeys","short_description":"","description":"Spanish (eliminate dead keys)"},{"name":"es\tdeadtilde","short_description":"","description":"Spanish (include dead tilde)"},{"name":"es\tsundeadkeys","short_description":"","description":"Spanish (Sun dead keys)"},{"name":"es\tdvorak","short_description":"","description":"Spanish (Dvorak)"},{"name":"es\tast","short_description":"","description":"Asturian (Spain, with bottom-dot H and bottom-dot L)"},{"name":"es\tcat","short_description":"","description":"Catalan (Spain, with middle-dot L)"},{"name":"es\tmac","short_description":"","description":"Spanish (Macintosh)"},{"name":"se","short_description":"sv","description":"Swedish"},{"name":"se\tnodeadkeys","short_description":"","description":"Swedish (eliminate dead keys)"},{"name":"se\tdvorak","short_description":"","description":"Swedish (Dvorak)"},{"name":"se\trus","short_description":"ru","description":"Russian (Sweden, phonetic)"},{"name":"se\trus_nodeadkeys","short_description":"ru","description":"Russian (Sweden, phonetic, eliminate dead keys)"},{"name":"se\tsmi","short_description":"","description":"Northern Saami (Sweden)"},{"name":"se\tmac","short_description":"","description":"Swedish (Macintosh)"},{"name":"se\tsvdvorak","short_description":"","description":"Swedish (Svdvorak)"},{"name":"se\tswl","short_description":"","description":"Swedish Sign Language"},{"name":"ch","short_description":"de","description":"German (Switzerland)"},{"name":"ch\tlegacy","short_description":"","description":"German (Switzerland, legacy)"},{"name":"ch\tde_nodeadkeys","short_description":"de","description":"German (Switzerland, eliminate dead keys)"},{"name":"ch\tde_sundeadkeys","short_description":"de","description":"German (Switzerland, Sun dead keys)"},{"name":"ch\tfr","short_description":"fr","description":"French (Switzerland)"},{"name":"ch\tfr_nodeadkeys","short_description":"fr","description":"French (Switzerland, eliminate dead keys)"},{"name":"ch\tfr_sundeadkeys","short_description":"fr","description":"French (Switzerland, Sun dead keys)"},{"name":"ch\tfr_mac","short_description":"fr","description":"French (Switzerland, Macintosh)"},{"name":"ch\tde_mac","short_description":"de","description":"German (Switzerland, Macintosh)"},{"name":"sy","short_description":"ar","description":"Arabic (Syria)"},{"name":"sy\tsyc","short_description":"syc","description":"Syriac"},{"name":"sy\tsyc_phonetic","short_description":"syc","description":"Syriac (phonetic)"},{"name":"sy\tku","short_description":"ku","description":"Kurdish (Syria, Latin Q)"},{"name":"sy\tku_f","short_description":"ku","description":"Kurdish (Syria, F)"},{"name":"sy\tku_alt","short_description":"ku","description":"Kurdish (Syria, Latin Alt-Q)"},{"name":"tj","short_description":"tg","description":"Tajik"},{"name":"tj\tlegacy","short_description":"","description":"Tajik (legacy)"},{"name":"lk","short_description":"si","description":"Sinhala (phonetic)"},{"name":"lk\ttam_unicode","short_description":"ta","description":"Tamil (Sri Lanka, Unicode)"},{"name":"lk\ttam_TAB","short_description":"","description":"Tamil (Sri Lanka, TAB Typewriter)"},{"name":"th","short_description":"th","description":"Thai"},{"name":"th\ttis","short_description":"","description":"Thai (TIS-820.2538)"},{"name":"th\tpat","short_description":"","description":"Thai (Pattachote)"},{"name":"tr","short_description":"tr","description":"Turkish"},{"name":"tr\tf","short_description":"","description":"Turkish (F)"},{"name":"tr\talt","short_description":"","description":"Turkish (Alt-Q)"},{"name":"tr\tsundeadkeys","short_description":"","description":"Turkish (Sun dead keys)"},{"name":"tr\tku","short_description":"ku","description":"Kurdish (Turkey, Latin Q)"},{"name":"tr\tku_f","short_description":"ku","description":"Kurdish (Turkey, F)"},{"name":"tr\tku_alt","short_description":"ku","description":"Kurdish (Turkey, Latin Alt-Q)"},{"name":"tr\tintl","short_description":"","description":"Turkish (international with dead keys)"},{"name":"tr\tcrh","short_description":"crh","description":"Crimean Tatar (Turkish Q)"},{"name":"tr\tcrh_f","short_description":"crh","description":"Crimean Tatar (Turkish F)"},{"name":"tr\tcrh_alt","short_description":"crh","description":"Crimean Tatar (Turkish Alt-Q)"},{"name":"tw","short_description":"zh","description":"Taiwanese"},{"name":"tw\tindigenous","short_description":"","description":"Taiwanese (indigenous)"},{"name":"tw\tsaisiyat","short_description":"xsy","description":"Saisiyat (Taiwan)"},{"name":"ua","short_description":"uk","description":"Ukrainian"},{"name":"ua\tphonetic","short_description":"","description":"Ukrainian (phonetic)"},{"name":"ua\ttypewriter","short_description":"","description":"Ukrainian (typewriter)"},{"name":"ua\twinkeys","short_description":"","description":"Ukrainian (WinKeys)"},{"name":"ua\tlegacy","short_description":"","description":"Ukrainian (legacy)"},{"name":"ua\trstu","short_description":"","description":"Ukrainian (standard RSTU)"},{"name":"ua\trstu_ru","short_description":"","description":"Russian (Ukraine, standard RSTU)"},{"name":"ua\thomophonic","short_description":"","description":"Ukrainian (homophonic)"},{"name":"gb","short_description":"en","description":"English (UK)"},{"name":"gb\textd","short_description":"","description":"English (UK, extended WinKeys)"},{"name":"gb\tintl","short_description":"","description":"English (UK, international with dead keys)"},{"name":"gb\tdvorak","short_description":"","description":"English (UK, Dvorak)"},{"name":"gb\tdvorakukp","short_description":"","description":"English (UK, Dvorak with UK punctuation)"},{"name":"gb\tmac","short_description":"","description":"English (UK, Macintosh)"},{"name":"gb\tmac_intl","short_description":"","description":"English (UK, Macintosh international)"},{"name":"gb\tcolemak","short_description":"","description":"English (UK, Colemak)"},{"name":"uz","short_description":"uz","description":"Uzbek"},{"name":"uz\tlatin","short_description":"","description":"Uzbek (Latin)"},{"name":"vn","short_description":"vi","description":"Vietnamese"},{"name":"kr","short_description":"ko","description":"Korean"},{"name":"kr\tkr104","short_description":"","description":"Korean (101/104 key compatible)"},{"name":"nec_vndr/jp","short_description":"ja","description":"Japanese (PC-98xx Series)"},{"name":"ie","short_description":"ie","description":"Irish"},{"name":"ie\tCloGaelach","short_description":"","description":"CloGaelach"},{"name":"ie\tUnicodeExpert","short_description":"","description":"Irish (UnicodeExpert)"},{"name":"ie\togam","short_description":"","description":"Ogham"},{"name":"ie\togam_is434","short_description":"","description":"Ogham (IS434)"},{"name":"pk","short_description":"ur","description":"Urdu (Pakistan)"},{"name":"pk\turd-crulp","short_description":"","description":"Urdu (Pakistan, CRULP)"},{"name":"pk\turd-nla","short_description":"","description":"Urdu (Pakistan, NLA)"},{"name":"pk\tara","short_description":"ar","description":"Arabic (Pakistan)"},{"name":"pk\tsnd","short_description":"sd","description":"Sindhi"},{"name":"mv","short_description":"dv","description":"Dhivehi"},{"name":"za","short_description":"en","description":"English (South Africa)"},{"name":"epo","short_description":"eo","description":"Esperanto"},{"name":"epo\tlegacy","short_description":"","description":"Esperanto (displaced semicolon and quote, obsolete)"},{"name":"np","short_description":"ne","description":"Nepali"},{"name":"ng","short_description":"en","description":"English (Nigeria)"},{"name":"ng\tigbo","short_description":"ig","description":"Igbo"},{"name":"ng\tyoruba","short_description":"yo","description":"Yoruba"},{"name":"ng\thausa","short_description":"ha","description":"Hausa"},{"name":"et","short_description":"am","description":"Amharic"},{"name":"sn","short_description":"wo","description":"Wolof"},{"name":"brai","short_description":"brl","description":"Braille"},{"name":"brai\tleft_hand","short_description":"","description":"Braille (left hand)"},{"name":"brai\tright_hand","short_description":"","description":"Braille (right hand)"},{"name":"tm","short_description":"tk","description":"Turkmen"},{"name":"tm\talt","short_description":"","description":"Turkmen (Alt-Q)"},{"name":"ml","short_description":"bm","description":"Bambara"},{"name":"ml\tfr-oss","short_description":"fr","description":"French (Mali, alternative)"},{"name":"ml\tus-mac","short_description":"en","description":"English (Mali, US Macintosh)"},{"name":"ml\tus-intl","short_description":"en","description":"English (Mali, US international)"},{"name":"tz","short_description":"sw","description":"Swahili (Tanzania)"},{"name":"ke","short_description":"sw","description":"Swahili (Kenya)"},{"name":"ke\tkik","short_description":"ki","description":"Kikuyu"},{"name":"bw","short_description":"tn","description":"Tswana"},{"name":"ph","short_description":"ph","description":"Filipino"},{"name":"ph\tqwerty-bay","short_description":"","description":"Filipino (QWERTY Baybayin)"},{"name":"ph\tcapewell-dvorak","short_description":"","description":"Filipino (Capewell-Dvorak Latin)"},{"name":"ph\tcapewell-dvorak-bay","short_description":"","description":"Filipino (Capewell-Dvorak Baybayin)"},{"name":"ph\tcapewell-qwerf2k6","short_description":"","description":"Filipino (Capewell-QWERF 2006 Latin)"},{"name":"ph\tcapewell-qwerf2k6-bay","short_description":"","description":"Filipino (Capewell-QWERF 2006 Baybayin)"},{"name":"ph\tcolemak","short_description":"","description":"Filipino (Colemak Latin)"},{"name":"ph\tcolemak-bay","short_description":"","description":"Filipino (Colemak Baybayin)"},{"name":"ph\tdvorak","short_description":"","description":"Filipino (Dvorak Latin)"},{"name":"ph\tdvorak-bay","short_description":"","description":"Filipino (Dvorak Baybayin)"},{"name":"md","short_description":"md","description":"Moldavian"},{"name":"md\tgag","short_description":"gag","description":"Moldavian (Gagauz)"}]")); + this.sessions = JSON.parse(atob("W3sibmFtZSI6IkxYREUiLCJrZXkiOiJMWERFIiwiY29tbWVudCI6IkxYREUgLSBMaWdodHdlaWdodCBYMTEgZGVza3RvcCBlbnZpcm9ubWVudCJ9LHsibmFtZSI6Ik9wZW5ib3giLCJrZXkiOiJvcGVuYm94IiwiY29tbWVudCI6IkxvZyBpbiB1c2luZyB0aGUgT3BlbmJveCB3aW5kb3cgbWFuYWdlciAod2l0aG91dCBhIHNlc3Npb24gbWFuYWdlcikifSx7Im5hbWUiOiJUV00iLCJrZXkiOiJ0d20iLCJjb21tZW50IjoiVGhlIFRhYiBXaW5kb3cgTWFuYWdlciJ9LHsibmFtZSI6IlRpbnl3bSIsImtleSI6InRpbnl3bSIsImNvbW1lbnQiOiJSaWRpY3Vsb3VzbHkgdGlueSB3aW5kb3cgbWFuYWdlciJ9XQ")); + this.language = this.languages[0].name; + this.layout = this.layouts[0].name; + this.default_session = this.sessions[0].name; + this.layout = this.layouts[0].name; + this.num_users = this.users.length; + + if(typeof timeout === "number" && timeout > 0) { + this.autologin_user = (!autoGuest) ? this.users[0].name : null; + this.autologin_guest = autoGuest; + this.autologin_timeout = timeout * 1000; + + setTimeout(function() { + if(autoGuest || this.autologin_user !== null) + window.autologin_timer_expired(); + }.bind(this), this.timed_login_delay); + } + + for(var i = 0; i <= this.users; i++) { + this.users[i].logged_in = Boolean(Math.floor(Math.random() * 2)); + this.users[i].session = this.sessions[Math.floor((Math.random() * this.sessions.length))].name; + } + } +} + +// var lightdm = new LightDMMock(); + +/** + * Deprecated method. + */ +LightDMMock.prototype.cancel_timed_login = window.deprecationNotifier("method", "lightdm.cancel_autologin()"); + +/** + * Cancels the authentication of the autologin user. The older function + * lightdm.cancel_timed_login() has been deprecated. + */ +LightDMMock.prototype.cancel_autologin = function() { + window.checkArguments(arguments, 0, []); + + this.autologin_user = null; + this.autologin_guest = false; + this.autologin_timeout = 0; +}; + +/** + * Deprecated method. + */ +LightDMMock.prototype.start_authentication = window.deprecationNotifier("method", "lightdm.authenticate(username)"); + +/** + * Specifies the username of the user we'd like to start authenticating as. + * Note that if you call lightdm.authenticate with no argument, LightDM + * (via PAM) will issue a show_prompt() call to ask for the username. The + * older function lightdm.start_authentication() has been deprecated. + * + * @param {String} username [username to authenticate] + */ +LightDMMock.prototype.authenticate = function(username) { + window.checkArguments(arguments, 1, ["string"]); + + if(this.in_authentication) { + window.show_message("Already authenticating " + this.authentication_user, "error"); + return; + } + + var exists = false; + + for(var i = 0; i <= this.users.length; i++) { + if(this.users.name === username) + exists = true; + } + + if(!exists) { + window.show_message("Invalid username", "error"); + return; + } + + this.authentication_user = username; + this.in_authentication = true; + + window.show_prompt("Password:", "password"); +}; + +/** + * Authenticates as the guest user. + */ +LightDMMock.prototype.authenticate_as_guest = function() { + window.checkArguments(arguments, 0, []); + + if(!this.has_guest_account) + throw new IlligalUsageException("Guest accounts are turned off. Make sure you check the value of 'lightdm.has_guest_account' before calling this function."); + + if(this.in_authentication) { + window.show_message("Already authenticating" + this.authentication_user, "error"); + return; + } + + this.authentication_user = "guest"; + this.in_authentication = true; +}; + +/** + * When LightDM has prompted for input, provide the response to LightDM. The + * deprecated function was "provide_secret". This is still available for + * backwards compatibility, but authors of greeters should move + * to using lightdm.respond(). + * + * @param {String} text [the response to the challange, usually a password] + */ +LightDMMock.prototype.respond = function(text) { + window.checkArguments(arguments, 1, ["string"]); + + if(!this.in_authentication) + throw new IlligalUsageException("LightDM is currently not in the authentication phase. Make sure to call 'lightdm.authenticate(username)' before calling this function."); + + if(text === "password") { + this.is_authenticated = true; + window.authentication_complete(); + } else { + window.show_message("Invalid password", "error"); + } +}; + +/** + * Deprecated method. + */ +LightDMMock.prototype.provide_secret = window.deprecationNotifier("method", "lightdm.respond(text)"); + +/** + * Cancels the authentication of any user currently in the + * process of authenticating. + */ +LightDMMock.prototype.cancel_authentication = function() { + window.checkArguments(arguments, 0, []); + + this.authentication_user = null; + this.in_authentication = false; +}; + +/** + * Suspends the system, if the greeter has the authority to do so. + */ +LightDMMock.prototype.suspend = function() { + window.checkArguments(arguments, 0, []); + + if(!this.can_suspend) + throw new IlligalUsageException("LightDM cannot suspend the system. Make sure you check the value of 'lightdm.can_suspend' before calling this function."); + + window.alert("System suspended."); + document.location.reload(true); +}; + +/** + * Hibernates the system, if the greeter has the authority to do so. + */ +LightDMMock.prototype.hibernate = function() { + window.checkArguments(arguments, 0, []); + + if(!this.can_hibernate) + throw new IlligalUsageException("LightDM cannot hibernate the system. Make sure you check the value of 'lightdm.can_hibernate' before calling this function."); + + window.alert("System hibernated."); + document.location.reload(true); +}; + +/** + * Shuts down the system, if the greeter has the authority to do so. + */ +LightDMMock.prototype.shutdown = function() { + window.checkArguments(arguments, 0, []); + + if(!this.can_shutdown) + throw new IlligalUsageException("LightDM cannot shut down the system. Make sure you check the value of 'lightdm.can_shutdown' before calling this function."); + + window.alert("System shut down."); + document.location.reload(true); +}; + +/** + * Restarts the system, if the greeter has the authority to do so. + */ +LightDMMock.prototype.restart = function() { + window.checkArguments(arguments, 0, []); + + if(!this.can_restart) + throw new IlligalUsageException("LightDM cannot restart the system. Make sure you check the value of 'lightdm.can_restart' before calling this function."); + + window.alert("System restarted."); + document.location.reload(true); +}; + +/** + * Will set the language for the current LightDM session. + * + * @param {String} lang [the language to change to] + */ +LightDMMock.prototype.set_language = function(lang) { + window.checkArguments(arguments, 1, ["string"]); + + this.language = lang; +}; + +/** + * Deprecated method. + */ +LightDMMock.prototype.login = window.deprecationNotifier("method", "lightdm.start_session_sync(session)"); + +/** + * Once LightDM has successfully authenticated the user, start the user's + * session by calling this function. "session" is the authenticated user's + * session. If no session is passed, start the authenticated user with the + * system default session. The older function lightdm.login(user, session) + * has been deprecated. + * + * @param {String} session [the session name to start] + */ +LightDMMock.prototype.start_session_sync = function(session) { + window.checkArguments(arguments, 1, ["string"]); + + if(!this.in_authentication) + throw new IlligalUsageException("LightDM is currently not in the authentication phase. Make sure to call 'lightdm.authenticate(username)' before calling this function."); + + if(!this.is_authenticated) + throw new IlligalUsageException("LightDM has no authenticated users to log in. Make sure to call 'lightdm.respond()' before calling this function."); + + window.alert("LightDM has started a " + session + " session for " + this.authentication_user); +}; + +/** + * Returns the value of a named hint provided by LightDM. + * + * @param {String} hint_name [name of the hint to show] + */ +LightDMMock.prototype.get_hint = function(hint_name) { + window.checkArguments(arguments, 1, ["string"]); + + // @fixme: I have no clue how to simulate this... +}; + + +/****************************************************************************** + * Throwables * +*******************************************************************************/ + +/** + * Throwable IlligalUsageException + * + * @param {string} message [description of illigal usage] + */ +function IlligalUsageException(message) { + this.name = "IlligalUsageException"; + this.message = message; + this.toString = function() { + return "[" + this.name + "] " + this.message; + }; +} + +/** + * Throwable DeprecationException + * + * @param {String} type [method||property] + * @param {String} alternative [alternative method or property to use] + */ +function DeprecationException(type, alternative) { + this.name = "DeprecationException"; + this.message = "This " + type + " is deprecated. Consider using '" + alternative + "' instead."; + this.toString = function() { + return "[" + this.name + "] " + this.message; + }; +} + +/** + * Throwable IncompatibleArgumentCountException + * + * @param {Number} expected [expected length of arguments] + * @param {Number} received [found length of arguments] + */ +function IncompatibleArgumentCountException(expected, received) { + this.name = "IncompatibleArgumentCountException"; + this.message = "Incorrect number of arguments in function call. Expected " + expected + ", found " + received; + this.toString = function() { + return "[" + this.name + "] " + this.message; + }; +} + +/** + * Throwable IncompatibleArgumentTypesException + * + * @param {Number} type [argument number (non-zero)] + * @param {String} expected [expected type] + * @param {String} received [found type] + */ +function IncompatibleArgumentTypesException(number, expected, received) { + this.name = "IncompatibleArgumentTypesException"; + this.message = "Argument " + number + " is of a wrong type. Expected '" + expected + "', found '" + received + "'"; + this.toString = function() { + return "[" + this.name + "] " + this.message; + }; +} + + +/****************************************************************************** + * Helpers * +*******************************************************************************/ + +/** + * global helper deprecationNotifier + * throws ~balls~ errors at users who use deprecated methods and properties. + * + * @param {String} type [method||property] + * @param {String} alternative [alternative method or property to use] + * + * @throws {DeprecationException} + */ +window.deprecationNotifier = function(type, alternative) { + throw new DeprecationException(type, alternative); +}; + +/** + * global helper checkArguments + * throws ~tables~ errors at users who call methods + * with erroneous arguments. + * + * @param {Array} args [the arguments passed to the original method] + * @param {Number} length [the expected amount of arguments] + * @param {Arrray} types [the expected types of the arguments] + * + * @throws {IncompatibleArgumentTypesException} + */ +window.checkArguments = function(args, length, types) { + if(args.length -1 !== length) + throw new IncompatibleArgumentCountException(length, args.length -1); + + for(var i = 1; i <= types.length; i++) { + if(typeof args[i] !== types[i-1]) + throw new IncompatibleArgumentTypesException(i, types[i-1], typeof args[i]); + } +}; diff --git a/mock/basileusalex/.face b/mock/basileusalex/.face new file mode 100644 index 0000000000000000000000000000000000000000..2a427b57367c2dc21cde05238c4b7a9c8a126478 GIT binary patch literal 3304 zcmZutc{tST7yr%-W6Wa9u4ORDM3ylU*Nnuy<%J^<`(Qu8_)sVm48^y9 z1wpvDpxjV66bk1@AyE7%J`n+a{(Ty?kAKI1@jnm$_t&YLaGDiza|KqHPRfjrTWiVf{sXsJWXSFKEy2akHvnw|exF_$(`>cFZ+3+R5x zgu28h3OS&h4q+O{woQ$P{Nd0>0hRcR*u-C-Mf`_K#XlGnh=ikIE>Xndj zynZ_V0U1IM5{h~oX+!oHR^ThZYLVgvOkLZu+cuGTEdy_>n?vry3thgv^|4!y6 zLuC95?N(m^pVJwh2NNSTqjIfvJKZq4>b!(-H_h*E>bCU@3&Q}_debT;mkIO91inj? zo)++Udm9|qSlckRA%<&7-#!Y5%or13C69sTZQ6Zv6*ewu1XmEx9;$rQ(N;KJ<%Y=r z^YZd`ZjI9YR4?(uUNe2~JwV`ULZ1E6b#Tm;=cSc%B9b{Db6G+fF&C!E0d*oTeTEv+ zWaUD{gz?87XFd4kLhnp}pv@vl`W3}Xl53Jlw`9zTM~UijdM_24h*x!Hqqaz2y30={ zG~_zoES{$A5**^~rkDAreb*&wFt;XHTVK)wNMBs!Kh3JnEcxsi}O~=ctX}}3`yc#Ba ztp{7FQPZ`JIi#XWeb^9SYyoNh=0D?CE{uwVnhCBW3 z{`u9WFKo_mIk>}*QuZZW%7flV#7Q)4L{BE9RO0dzqTDVGW`z}u_=zc7RXi(16&}CN zN4I_vdbc?fR}re`U*z^RVh@m7>~Vv1viq`XM}x-R>su~2hTDXl{3^eSRbTWUtsQ`Z$ z+5O@+V_4VS^|)!3Lr>E$d`CnPyXu~eOy;{f(9^FhL&p7=a}Q8eo%fHQ4PddXnW!V@ zt^A%4eH62lT;ozLa}FSEYC`8i6?OS5FOMGoT3lYPjL`Q}8i{)ES^nxmTSxp1{=7YwOxXi+ zPh24d>-jJrqtckB2@Nsiv{Fi+6h(eRVcP59ZSQf=@V@*Qo#r0?4bZY~1Ap`Uoah#clfa3ce zjORnoIos;^^WxFJuq$F^>E*T{HA)3<_~@)n0e_^u%DYQ>p~2OY#SITWe(Lp?q)m#P2aK*b;LMg>^(dwk)Y8sc{(J|b>+2c1wjodUk znV0n=4?4v;aaGQ4e`wDx+t4nL@X1JaM}M;Vu}FbMuVX&*POkpx^7_kgnhf;c7?eCw{3ZW$eg$r­z!B-ry zEAY>&uTpdveB4_Qh&FFYM>>R4gm1~1*0g;fPnPp-ttF&{2@6$NFpwex+brVO2y=Gt#KV z>{*Jh242-DQQ0%U$1Pm!9=Zi?IMqRf|@RUL)q&4?huoVjyX})7jS$ z&$;d+JTB3LA>=s|>Mduq>Ti!~#&|LByj>b@6wZUv+m%)(7_1v|mrXKfHhN=d~%ey5w*YeTIl~7$Ux2B#S)qBU9ai%4|zxDv1H)D_)GCYfAsg}DtKFKJT6z4bF zc~e3tkfXo(k<{n)DBI~XhgUc1%7d>AH47snX5P#UEwjfX$4fJ}g(D@NNWYNpoA0CD zlyEPfb(Nwh$~+TO?ULfmcE=jMXGrrgF|$Hl*JU0l-=_=|RdW2lcxcb}3{|2t&iF61 z5B`jN>-?&F!gZ^ssCmpnVFi(1FOj?(E^!(Rb*Ln@tLkVZC>Kr!Rt*Ue+aH&^KVB3$ zy%kdGg(X%rQT?|aa3l7S{ATeBzyW_sqf+_0jA(#cq@jxDnobGGvO@8KoreKACJbz` zV|>w6>4uqZ-s=hKZD_a}CVvyQv$WARWL|HVhE_?MoVR08hmiz>a|Op{(H}C;ZQQF~ zn}2_1_1o-0`R1en!oVJ2?6^j-R3KZ`v~r9fIGM1ZI~PYKKi$f%?IG0?VE0{`w#ToD zJ33AGuqiih#;LcLno!FsZ))$Z+-V5wo9g}kmY>0%M+uKLNmB$dobp|ErXW|~3QkCU zER3~PBHHj%QViega_STQ8Z90&Y?qzJsOKa~NyWf$JHh>tCVo3t?9T5V>V6mKS)q3L zn?s;Caal=WJvn{xD+|_aob_0UnnSBjOjE?BFxm0)(BaQFR$`}8QU-HmhD+rl%&rbJ zq`qRl;GNaUyA!d~C3ahdSZ9@%bWXY*WN(qkr9&((@itz^@YVWHB&0Z^Hw-7K{;p+N zwpZ$mY)b$hINBj%b6(bzGXwoUyO& zOttUQvo=*yVzR+ByOB_s&&(#TJJX=8&NoARHea*t7fdi)bEp>6aWsf-9M91{_0SUtcf3+qvTaM`c2n_x(ppR8}9MKOQ zoa%E-!YlhB1pSYGOy1rD{y@sQo`M@aTS}G)H*xi;>5_=!l&i66xZr{T`uVg0XL2 zD0q7%XVhuip1Y|kxR!JBov({z_a|a+$CI-P7J@Ytq{HOxNL41 T)H`=LwlVBjth1iU-iQAHg?Pw3 literal 0 HcmV?d00001 diff --git a/mock/chairmanzedong/.face b/mock/chairmanzedong/.face new file mode 100644 index 0000000000000000000000000000000000000000..bcf0546149126ced918cb738fc03125c9a92e269 GIT binary patch literal 2789 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 GQ~v^vmAef9 literal 0 HcmV?d00001 diff --git a/mock/cristocolombo/.face b/mock/cristocolombo/.face new file mode 100644 index 0000000000000000000000000000000000000000..6705fd42776c889fa607430a1b7f0adb9480eba8 GIT binary patch literal 4030 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 literal 0 HcmV?d00001 diff --git a/mock/gustav2/.face b/mock/gustav2/.face new file mode 100644 index 0000000000000000000000000000000000000000..aa35fcd6218273a6d8cd03f6427ce839528b8569 GIT binary patch literal 4287 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 THp$#P@cj3#o8G+n#lrspK@f;o literal 0 HcmV?d00001 diff --git a/mock/honourablewinston/.face b/mock/honourablewinston/.face new file mode 100644 index 0000000000000000000000000000000000000000..8f226c90115468f22c97f67a5c7b7d97eae703d5 GIT binary patch literal 3016 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 O^tiC6Ut%}sbmBk#&uLfy literal 0 HcmV?d00001 diff --git a/mock/meijitaitei/.face b/mock/meijitaitei/.face new file mode 100644 index 0000000000000000000000000000000000000000..6c4fb1ca90598fbe5b48e1f28badf992f77dc053 GIT binary patch literal 2726 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

E7lF^j3`mfCtZ+VpxU@x1j&} zQ-RJM`a(QySxL+Aw)K2*VZVH6V{KIoLiNiLvSccuB${au);RqsZ$@|fbKS32Kt855 zJ1Bs^&Zuw1WT?t7e1ik{k6YfK?c+>tWBsYZx8TF8M0ffInx&Gv4Wzs z-R0tOPhlrc1?EcpF|DM^$2}7&?I>Je6uiB`cCy^BX&b*dtDUlMPVTy`!>EJZx0iO( zGl1}sz!>mf8IG$Aue(YJcM1s}e0V!kiT3B2b_sjzT{?TKl9l;dwmlqf7A9TKv_(v3MuHdi!Z(Y6zkfeYiUkmAb}2mfIzUL-#o(-)Vau?Ih?`5~PR>&1`$4T~z%a=-WEwyc0HEnojRDOQ6`( z7o$+gfJ(O(#m{N#w9F2MK1~fi_1y~fa|VY#H{YpC_wkLUDK^XM))w$k__hxT`gkvm z9gkc9Etxp-jm);PRUG*5qv6#}ZW7;Pdi<|nYrNU>hSE*uEODCJyq?*g=&)(s zCAUh!LT_tZa{?t&S%3Sh6{nn5Ey~RJ*V}{hJ5{3gc^G6paRAP{2Q>@*Wy$6yh+0#K z>Y?b5C%e)6Hs5j5Ja`Wh5X?9~uN2lh>o#qW*&JBg<7Ec6c+XTnc{Yu z_Ah4iJ5q~i3HIMM8n2v3|Ga2dEJ$IBb2xH} zWa!AFNt;LcQyev%Rx$a7qDZxPBfD8%oBAJYjui9C@T_s9K6fe^ySOERsuj|kyabqS z*QYiLN|V}Ka_5P$y8KTq+b=@i3!#&2BokGhJS{#J*r`l;6k9(X<=LuHqT?m=;=JK( znk4KI-GEwS*Y&SDoI*OX_ZZa#gXz_VUtz2AsD&vqD(j*1v_H4HZMW-hS9mFBNmsTB zPn@K8jOvb$cm8QJEK@T!D0bY7ebolFyY`9D#G!+Si_fy^B%-Tlc|sX<YxglQIh1Tp+RFBb3H9u=r;*DCx8-E6w~$rLEfIEHm#D@g9&TMei2U z@}Gunr`OQTiMYnSUA*lO(#uc~s*7$8iqqwAH1{s51+Pdc?4&fDLPe_<0-q50NO7%k(ie^;5Lz~ z7!*C`9S=S@J6+*_EH(CA4Z1C|bMkawDuMxnk-Q^!eD*Dj->Z;*V)`yM{ z5N7IEtkm>1Y=xso8})*CRzh08tP1=sCCB}8A&T+0X{JLU`dze$lW}BU;TYz6K}Scf zm7uR-DOPtoB2m$Gi4~*l^D15;sLA7&QC?fdT|CZv>kJ#6-9@UO$8iY^cf56np-DS> zuhaWSxz>i9_>8(|*+q&6P@7ZWx|=xNF&10dBV*Fb6~6H+l!GE)8m*)s$7GZ~t*c2< zkGP#w6XRGOysSUi($PPm)vLPvf~r4)Ct=s!f#C$>$Ytx5=6=_m0Aw+{0dmv%$4Xem z^0&owHs$uOjoZuqY!k}j_@<~UVK^dPw0XQZ8fc;wL8hBS*jlRz2nX)cm3R>QkACEV9j=!-(_vC-<* z@5=^lWN($4&|=q-J1=`{kM3?{?4d`vE$L_0Y{NUUJ3Atf^NQo&Sc^4_C8-A23v=9TfVsYBCKP+ zgjJHZwkKFzHQtE4D3+@>R3DiT8zCP)B_T$2VNCtneBh<5o4kIvmVvNSo$RR1Dk=q$4Mbl)X=xwNSK zI$fa{cb3$r0!`!3=-wD~v0D0ux+Sn2Fiq@d@4i?D5mkA0$bX77Z3 z^5sl7)ec7I?Ua;S&eX8hjH{YDzOtkq1?qGr8`X|c@y2QNq%e@c_e_$ z(@sKP0+DBzKzL^#Q}nyc`kDmG zX^^t3VSweaYBVp;-{#?9AcuV^(9Uqh^&Osxh~w3jkM7Bbd>?V0OZBd6tnj$$yO}xi zJxCfyDO&n7DPUP{)ypM+AW&S)OhGY9W{TZV&gDC~um!lFe4bB#or}A)NNu=6?D>lb zo&#NB3C)R9=0I(cwwT+{{sq9eBVuXnZK>@f#4D%rYG~uY@GA8$OD- zVB&Fa3k*{)0!QGUZqz3)6@GLdT)oA5*wFGj&KM8JDrgm3`lK^iRXqFWVuCP)YB6tl zkyEY-b0%xp#RZzfLmrB%O5wNW*C^c)Yp)mgOPDkd>5sdg=r^0N36Cu^`0uvw#@E{E z&7HI|w(s2Ok!M>r`JK-clf$8&Ud+o*kbqHONjq8Lf)X|ZzGDQPxfdUnY7;aBjU zE6E;qnc3q?ghd9~+ixd|& zPY~Mp+}rUzjl#Fw6})l&j}(ObPalek@{Nj-)q=dsvV=E?;BATp8!509x#A5$2d$a=d#-iAEUpK$`IO@b^-M-~&>6m_8q86X za8S|d*F;BQr{_b?1V3Stf;)AJTdHqwtNcOrlD*q?|0Q4;c?rDaO&nLWd)`im-<7i| zlSK(X#{RIZnDe{%$DZpFxTVB?9%rzEV~4zbe!tGM?PS!e=6hQC882?7WHX{B dwPFZYo{5dCTAe=p5RzFhB0k9M;0C{({SWZgE%5*V literal 0 HcmV?d00001 diff --git a/mock/peteralexeyevich/.face b/mock/peteralexeyevich/.face new file mode 100644 index 0000000000000000000000000000000000000000..5a4266a0471ba049d0761311a0d13c938f7ed8ba GIT binary patch literal 4459 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 Goc$k>D{5B& literal 0 HcmV?d00001 diff --git a/mock/silentwill/.face b/mock/silentwill/.face new file mode 100644 index 0000000000000000000000000000000000000000..5a1456c64c7a08687a4a79e46d3360446469d688 GIT binary patch literal 3258 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 KN5b0l@qYow+rQHQ literal 0 HcmV?d00001 diff --git a/mock/wilhelm1/.face b/mock/wilhelm1/.face new file mode 100644 index 0000000000000000000000000000000000000000..1749514c8a61cd7b92fc1bf2645c5b6c98555b6a GIT binary patch literal 3147 zcmb7Dc{tRK7XHn~7{%}qWUCDG-}39B3Y8` zq$!2aWJK8-Yv#`PJoi4&{rA4-pL5Q8p7(wKIZP^Z9^kdL!dL+y5CDK!1u$oT+W-U% zhQkqXI1-NFqItOEoB0fIoG zY%n$i8yf!gKsf$60f8Y2W|E5vfjSC)b}2w=(ok3Il}u`~cS7AMCF0s&a&tOWnDXHk66;~M<3ngY(S)4t44 z0M|b}AA}Du1%AuHZ*g_%rCM%C^Yz$CoRv#)GTTAFA!C0I;ei7NkXJx*QYKO1oJi79Rp83oiWsO12GfcOz7CRq4w3Hs@LUD<|95?ziZ7mz% z;h(a!ZWiS{LP6T6EYzx($F|euXK2>@UJ2iglCAN+&TsYiafKm29&4{oz!x8|ACOWq zT8clGGf+LpP2Pwccv?@VE?y$0Hcf*{}N|1PwH&dff^^|UxGzV90YZ-f8oA3GVn;MU8 zMEs@B4-{ecL&~+LduJ_U2>aQDgN!9;>}QF^Sbd98SDCGgxDy1;um zir)2XwspKd&B$$0E&JQSeV1LvUzSF?#{(WtP_s1AjvB5EQnz*~nYFrH+^oN%b1IJ(=wM_L(g2o2c6QD!7t1m_I^># z$WDM5O%4ki)^O?Yt9_b@n43f3W^#|ZCXq)zQ7TU+)OGTG&h~`2Q}-iq>M@Od=iZQE z3zN5lH1y-@LyZh4B7nKewBC{Oghm@*xuogMlrecz+w{N!eq{bebvMUPN=*K| zt(r6Hcb<;=mgk~N?rE~bVz47D#u+`uv)opwdRZwh%v0HHDAU*Mq934unK*k>W|rDm zQL=vGSWpR~ZM@G}X*Ylrh$Oq;%syZO zJkPZ7LPbpuA5NZ1^mfPcU*?{nB5rRXiniK7@eX6ofHo5f54b>6) zVooL6zr-LVZtXo6x!BC${Ya5rsrPk;++XV2Z9XPaRYvC&g>zI!j`%a5>DgIU$vJYU zMnB5SlGchWizmTS{uufxx1F+&d-omjT`i8S=)!|1C?wyqokKo^c3O^9Qcx|v;R)3TOU!GmwasAdMm3()StXWeuUk$ zM#t6`(q)MYVwdtx5H6~(R9+U>J1G|SWjm>c6w|L+sTE3_^Z@Oep0JUsL?n%u*c9-F zCtbpo0cIeO1dQ>T+rp*D_g7d$$P`=K8n#47KY8BmF}Cr6#}|*c(oQqyp}|vX0bvp| zoruMLrKA_~kDn-RKB~H_ls?s06{IOz7h#2TH)lXYC(xFR9X)B{7Mo|)Dn99<(L%g0 zkMOg(w9W1Ub4^StwFuX^AsjeJ3!{>fa+BLzwqC9uwJ(f+f1YWt7Z*9$FgR%YEA4Uo zY-sVkkcu)oDmUwi;S1pmSK2fM(^b@a-`9Y@=#fhEr90;Okhizr22YpP29{th);^1Q zNqdSnNPn4bIZ-2?SD*8mAx`oJ+xnc=^H-n`3}F=dMTsr2f0cHaxYX7P5vxMwgy22+ zX2L25Kq-W%Gfv(y9=t~xWR2Rq1AP79M-T8nrkHRN`o6o`&BRq9!}YtDT(xo7_1^(eo~b)B#v%H+4r zis&wmBHJzTmOSju(#7EUR8ZAxZ^?vGYTfhn1_6Fs&o>MhSvm%i=h`5s8i` z6_+z#6I5+m{8&xrId2>O*$s0scQ|9rcUU?r z(-$DIL>%lAu;O&7X^pQRpA_$?1qp8I5lELKj2EX> zJ=+JL^OEhsa)BL!OR1Wn;?A_ON2E{k5KLW7|A{;wlveh2Rim1?TEPKWi2=c&0&nr< z0⁢zU{9$-y~&8wXR8Pg?v_Qh%Z)bmE7s`zcQ&CJ9dl~Xf3b$((WYDucV-OdbT}5UaSba^Yq|qHK>1S$HDM!((S^g za~WQ4+KuBKZc%?H-V3=HB$Yp9v$mg|EMcXnbnankN7}-_99{C0o`79m0TTXU0yy}~ zbrA)hGor3yy|E`dT%0tbj--ux%%Z00Xw<-G$t(BJ1e}|N@4-}d+)Rd zMB{DQiVmS7Ag*X8{(9z4Cv92nXA~)^8m0-<hv7A`suYJ}7?an`O&uzb+(L$Fv z`siJ{b#ZQk`wtU{m1y&~L@A(V3>vsiC)}<+Z&@>a&kgr3&)p_o4B$?e=2>>6->6JK v(MKYd(OSpYdmhd;9~J41E>&y@Uzc)Ee9#073tPMDI%m_h#}zot!~FPf{jZf# literal 0 HcmV?d00001