Reorganized core/ directory, it was too fatty already

-Removed FuncRef, since Callable makes it obsolete
-Removed int_types.h as its obsolete in c++11+
-Changed color names code

1 files changed, 1303 insertions, 0 deletions

diff --git a/core/string/translation.cpp b/core/string/translation.cpp
new file mode 100644
index 0000000000..df8a26e5ce
--- /dev/null
+++ b/core/string/translation.cpp
@@ -0,0 +1,1303 @@
+/*************************************************************************/
+/*  translation.cpp                                                      */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "translation.h"
+
+#include "core/config/project_settings.h"
+#include "core/io/resource_loader.h"
+#include "core/os/os.h"
+
+// ISO 639-1 language codes, with the addition of glibc locales with their
+// regional identifiers. This list must match the language names (in English)
+// of locale_names.
+//
+// References:
+// - https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes
+// - https://lh.2xlibre.net/locales/
+
+static const char *locale_list[] = {
+	"aa", //  Afar
+	"aa_DJ", //  Afar (Djibouti)
+	"aa_ER", //  Afar (Eritrea)
+	"aa_ET", //  Afar (Ethiopia)
+	"af", //  Afrikaans
+	"af_ZA", //  Afrikaans (South Africa)
+	"agr_PE", //  Aguaruna (Peru)
+	"ak_GH", //  Akan (Ghana)
+	"am_ET", //  Amharic (Ethiopia)
+	"an_ES", //  Aragonese (Spain)
+	"anp_IN", //  Angika (India)
+	"ar", //  Arabic
+	"ar_AE", //  Arabic (United Arab Emirates)
+	"ar_BH", //  Arabic (Bahrain)
+	"ar_DZ", //  Arabic (Algeria)
+	"ar_EG", //  Arabic (Egypt)
+	"ar_IN", //  Arabic (India)
+	"ar_IQ", //  Arabic (Iraq)
+	"ar_JO", //  Arabic (Jordan)
+	"ar_KW", //  Arabic (Kuwait)
+	"ar_LB", //  Arabic (Lebanon)
+	"ar_LY", //  Arabic (Libya)
+	"ar_MA", //  Arabic (Morocco)
+	"ar_OM", //  Arabic (Oman)
+	"ar_QA", //  Arabic (Qatar)
+	"ar_SA", //  Arabic (Saudi Arabia)
+	"ar_SD", //  Arabic (Sudan)
+	"ar_SS", //  Arabic (South Soudan)
+	"ar_SY", //  Arabic (Syria)
+	"ar_TN", //  Arabic (Tunisia)
+	"ar_YE", //  Arabic (Yemen)
+	"as_IN", //  Assamese (India)
+	"ast_ES", //  Asturian (Spain)
+	"ayc_PE", //  Southern Aymara (Peru)
+	"ay_PE", //  Aymara (Peru)
+	"az_AZ", //  Azerbaijani (Azerbaijan)
+	"be", //  Belarusian
+	"be_BY", //  Belarusian (Belarus)
+	"bem_ZM", //  Bemba (Zambia)
+	"ber_DZ", //  Berber languages (Algeria)
+	"ber_MA", //  Berber languages (Morocco)
+	"bg", //  Bulgarian
+	"bg_BG", //  Bulgarian (Bulgaria)
+	"bhb_IN", //  Bhili (India)
+	"bho_IN", //  Bhojpuri (India)
+	"bi_TV", //  Bislama (Tuvalu)
+	"bn", //  Bengali
+	"bn_BD", //  Bengali (Bangladesh)
+	"bn_IN", //  Bengali (India)
+	"bo", //  Tibetan
+	"bo_CN", //  Tibetan (China)
+	"bo_IN", //  Tibetan (India)
+	"br_FR", //  Breton (France)
+	"brx_IN", //  Bodo (India)
+	"bs_BA", //  Bosnian (Bosnia and Herzegovina)
+	"byn_ER", //  Bilin (Eritrea)
+	"ca", //  Catalan
+	"ca_AD", //  Catalan (Andorra)
+	"ca_ES", //  Catalan (Spain)
+	"ca_FR", //  Catalan (France)
+	"ca_IT", //  Catalan (Italy)
+	"ce_RU", //  Chechen (Russia)
+	"chr_US", //  Cherokee (United States)
+	"cmn_TW", //  Mandarin Chinese (Taiwan)
+	"crh_UA", //  Crimean Tatar (Ukraine)
+	"csb_PL", //  Kashubian (Poland)
+	"cs", //  Czech
+	"cs_CZ", //  Czech (Czech Republic)
+	"cv_RU", //  Chuvash (Russia)
+	"cy_GB", //  Welsh (United Kingdom)
+	"da", //  Danish
+	"da_DK", //  Danish (Denmark)
+	"de", //  German
+	"de_AT", //  German (Austria)
+	"de_BE", //  German (Belgium)
+	"de_CH", //  German (Switzerland)
+	"de_DE", //  German (Germany)
+	"de_IT", //  German (Italy)
+	"de_LU", //  German (Luxembourg)
+	"doi_IN", //  Dogri (India)
+	"dv_MV", //  Dhivehi (Maldives)
+	"dz_BT", //  Dzongkha (Bhutan)
+	"el", //  Greek
+	"el_CY", //  Greek (Cyprus)
+	"el_GR", //  Greek (Greece)
+	"en", //  English
+	"en_AG", //  English (Antigua and Barbuda)
+	"en_AU", //  English (Australia)
+	"en_BW", //  English (Botswana)
+	"en_CA", //  English (Canada)
+	"en_DK", //  English (Denmark)
+	"en_GB", //  English (United Kingdom)
+	"en_HK", //  English (Hong Kong)
+	"en_IE", //  English (Ireland)
+	"en_IL", //  English (Israel)
+	"en_IN", //  English (India)
+	"en_NG", //  English (Nigeria)
+	"en_NZ", //  English (New Zealand)
+	"en_PH", //  English (Philippines)
+	"en_SG", //  English (Singapore)
+	"en_US", //  English (United States)
+	"en_ZA", //  English (South Africa)
+	"en_ZM", //  English (Zambia)
+	"en_ZW", //  English (Zimbabwe)
+	"eo", //  Esperanto
+	"es", //  Spanish
+	"es_AR", //  Spanish (Argentina)
+	"es_BO", //  Spanish (Bolivia)
+	"es_CL", //  Spanish (Chile)
+	"es_CO", //  Spanish (Colombia)
+	"es_CR", //  Spanish (Costa Rica)
+	"es_CU", //  Spanish (Cuba)
+	"es_DO", //  Spanish (Dominican Republic)
+	"es_EC", //  Spanish (Ecuador)
+	"es_ES", //  Spanish (Spain)
+	"es_GT", //  Spanish (Guatemala)
+	"es_HN", //  Spanish (Honduras)
+	"es_MX", //  Spanish (Mexico)
+	"es_NI", //  Spanish (Nicaragua)
+	"es_PA", //  Spanish (Panama)
+	"es_PE", //  Spanish (Peru)
+	"es_PR", //  Spanish (Puerto Rico)
+	"es_PY", //  Spanish (Paraguay)
+	"es_SV", //  Spanish (El Salvador)
+	"es_US", //  Spanish (United States)
+	"es_UY", //  Spanish (Uruguay)
+	"es_VE", //  Spanish (Venezuela)
+	"et", //  Estonian
+	"et_EE", //  Estonian (Estonia)
+	"eu", //  Basque
+	"eu_ES", //  Basque (Spain)
+	"fa", //  Persian
+	"fa_IR", //  Persian (Iran)
+	"ff_SN", //  Fulah (Senegal)
+	"fi", //  Finnish
+	"fi_FI", //  Finnish (Finland)
+	"fil", //  Filipino
+	"fil_PH", //  Filipino (Philippines)
+	"fo_FO", //  Faroese (Faroe Islands)
+	"fr", //  French
+	"fr_BE", //  French (Belgium)
+	"fr_CA", //  French (Canada)
+	"fr_CH", //  French (Switzerland)
+	"fr_FR", //  French (France)
+	"fr_LU", //  French (Luxembourg)
+	"fur_IT", //  Friulian (Italy)
+	"fy_DE", //  Western Frisian (Germany)
+	"fy_NL", //  Western Frisian (Netherlands)
+	"ga", //  Irish
+	"ga_IE", //  Irish (Ireland)
+	"gd_GB", //  Scottish Gaelic (United Kingdom)
+	"gez_ER", //  Geez (Eritrea)
+	"gez_ET", //  Geez (Ethiopia)
+	"gl_ES", //  Galician (Spain)
+	"gu_IN", //  Gujarati (India)
+	"gv_GB", //  Manx (United Kingdom)
+	"hak_TW", //  Hakka Chinese (Taiwan)
+	"ha_NG", //  Hausa (Nigeria)
+	"he", //  Hebrew
+	"he_IL", //  Hebrew (Israel)
+	"hi", //  Hindi
+	"hi_IN", //  Hindi (India)
+	"hne_IN", //  Chhattisgarhi (India)
+	"hr", //  Croatian
+	"hr_HR", //  Croatian (Croatia)
+	"hsb_DE", //  Upper Sorbian (Germany)
+	"ht_HT", //  Haitian (Haiti)
+	"hu", //  Hungarian
+	"hu_HU", //  Hungarian (Hungary)
+	"hus_MX", //  Huastec (Mexico)
+	"hy_AM", //  Armenian (Armenia)
+	"ia_FR", //  Interlingua (France)
+	"id", //  Indonesian
+	"id_ID", //  Indonesian (Indonesia)
+	"ig_NG", //  Igbo (Nigeria)
+	"ik_CA", //  Inupiaq (Canada)
+	"is", //  Icelandic
+	"is_IS", //  Icelandic (Iceland)
+	"it", //  Italian
+	"it_CH", //  Italian (Switzerland)
+	"it_IT", //  Italian (Italy)
+	"iu_CA", //  Inuktitut (Canada)
+	"ja", //  Japanese
+	"ja_JP", //  Japanese (Japan)
+	"kab_DZ", //  Kabyle (Algeria)
+	"ka", //  Georgian
+	"ka_GE", //  Georgian (Georgia)
+	"kk_KZ", //  Kazakh (Kazakhstan)
+	"kl_GL", //  Kalaallisut (Greenland)
+	"km_KH", //  Central Khmer (Cambodia)
+	"kn_IN", //  Kannada (India)
+	"kok_IN", //  Konkani (India)
+	"ko", //  Korean
+	"ko_KR", //  Korean (South Korea)
+	"ks_IN", //  Kashmiri (India)
+	"ku", //  Kurdish
+	"ku_TR", //  Kurdish (Turkey)
+	"kw_GB", //  Cornish (United Kingdom)
+	"ky_KG", //  Kirghiz (Kyrgyzstan)
+	"lb_LU", //  Luxembourgish (Luxembourg)
+	"lg_UG", //  Ganda (Uganda)
+	"li_BE", //  Limburgan (Belgium)
+	"li_NL", //  Limburgan (Netherlands)
+	"lij_IT", //  Ligurian (Italy)
+	"ln_CD", //  Lingala (Congo)
+	"lo_LA", //  Lao (Laos)
+	"lt", //  Lithuanian
+	"lt_LT", //  Lithuanian (Lithuania)
+	"lv", //  Latvian
+	"lv_LV", //  Latvian (Latvia)
+	"lzh_TW", //  Literary Chinese (Taiwan)
+	"mag_IN", //  Magahi (India)
+	"mai_IN", //  Maithili (India)
+	"mg_MG", //  Malagasy (Madagascar)
+	"mh_MH", //  Marshallese (Marshall Islands)
+	"mhr_RU", //  Eastern Mari (Russia)
+	"mi", //  Māori
+	"mi_NZ", //  Māori (New Zealand)
+	"miq_NI", //  Mískito (Nicaragua)
+	"mk", //  Macedonian
+	"mk_MK", //  Macedonian (Macedonia)
+	"ml", //  Malayalam
+	"ml_IN", //  Malayalam (India)
+	"mni_IN", //  Manipuri (India)
+	"mn_MN", //  Mongolian (Mongolia)
+	"mr_IN", //  Marathi (India)
+	"ms", //  Malay
+	"ms_MY", //  Malay (Malaysia)
+	"mt", //  Maltese
+	"mt_MT", //  Maltese (Malta)
+	"my_MM", //  Burmese (Myanmar)
+	"myv_RU", //  Erzya (Russia)
+	"nah_MX", //  Nahuatl languages (Mexico)
+	"nan_TW", //  Min Nan Chinese (Taiwan)
+	"nb", //  Norwegian Bokmål
+	"nb_NO", //  Norwegian Bokmål (Norway)
+	"nds_DE", //  Low German (Germany)
+	"nds_NL", //  Low German (Netherlands)
+	"ne_NP", //  Nepali (Nepal)
+	"nhn_MX", //  Central Nahuatl (Mexico)
+	"niu_NU", //  Niuean (Niue)
+	"niu_NZ", //  Niuean (New Zealand)
+	"nl", //  Dutch
+	"nl_AW", //  Dutch (Aruba)
+	"nl_BE", //  Dutch (Belgium)
+	"nl_NL", //  Dutch (Netherlands)
+	"nn", //  Norwegian Nynorsk
+	"nn_NO", //  Norwegian Nynorsk (Norway)
+	"nr_ZA", //  South Ndebele (South Africa)
+	"nso_ZA", //  Pedi (South Africa)
+	"oc_FR", //  Occitan (France)
+	"om", //  Oromo
+	"om_ET", //  Oromo (Ethiopia)
+	"om_KE", //  Oromo (Kenya)
+	"or_IN", //  Oriya (India)
+	"os_RU", //  Ossetian (Russia)
+	"pa_IN", //  Panjabi (India)
+	"pap", //  Papiamento
+	"pap_AN", //  Papiamento (Netherlands Antilles)
+	"pap_AW", //  Papiamento (Aruba)
+	"pap_CW", //  Papiamento (Curaçao)
+	"pa_PK", //  Panjabi (Pakistan)
+	"pl", //  Polish
+	"pl_PL", //  Polish (Poland)
+	"pr", //  Pirate
+	"ps_AF", //  Pushto (Afghanistan)
+	"pt", //  Portuguese
+	"pt_BR", //  Portuguese (Brazil)
+	"pt_PT", //  Portuguese (Portugal)
+	"quy_PE", //  Ayacucho Quechua (Peru)
+	"quz_PE", //  Cusco Quechua (Peru)
+	"raj_IN", //  Rajasthani (India)
+	"ro", //  Romanian
+	"ro_RO", //  Romanian (Romania)
+	"ru", //  Russian
+	"ru_RU", //  Russian (Russia)
+	"ru_UA", //  Russian (Ukraine)
+	"rw_RW", //  Kinyarwanda (Rwanda)
+	"sa_IN", //  Sanskrit (India)
+	"sat_IN", //  Santali (India)
+	"sc_IT", //  Sardinian (Italy)
+	"sco", //  Scots
+	"sd_IN", //  Sindhi (India)
+	"se_NO", //  Northern Sami (Norway)
+	"sgs_LT", //  Samogitian (Lithuania)
+	"shs_CA", //  Shuswap (Canada)
+	"sid_ET", //  Sidamo (Ethiopia)
+	"si", //  Sinhala
+	"si_LK", //  Sinhala (Sri Lanka)
+	"sk", //  Slovak
+	"sk_SK", //  Slovak (Slovakia)
+	"sl", //  Slovenian
+	"sl_SI", //  Slovenian (Slovenia)
+	"so", //  Somali
+	"so_DJ", //  Somali (Djibouti)
+	"so_ET", //  Somali (Ethiopia)
+	"so_KE", //  Somali (Kenya)
+	"so_SO", //  Somali (Somalia)
+	"son_ML", //  Songhai languages (Mali)
+	"sq", //  Albanian
+	"sq_AL", //  Albanian (Albania)
+	"sq_KV", //  Albanian (Kosovo)
+	"sq_MK", //  Albanian (Macedonia)
+	"sr", //  Serbian
+	"sr_Cyrl", //  Serbian (Cyrillic)
+	"sr_Latn", //  Serbian (Latin)
+	"sr_ME", //  Serbian (Montenegro)
+	"sr_RS", //  Serbian (Serbia)
+	"ss_ZA", //  Swati (South Africa)
+	"st_ZA", //  Southern Sotho (South Africa)
+	"sv", //  Swedish
+	"sv_FI", //  Swedish (Finland)
+	"sv_SE", //  Swedish (Sweden)
+	"sw_KE", //  Swahili (Kenya)
+	"sw_TZ", //  Swahili (Tanzania)
+	"szl_PL", //  Silesian (Poland)
+	"ta", //  Tamil
+	"ta_IN", //  Tamil (India)
+	"ta_LK", //  Tamil (Sri Lanka)
+	"tcy_IN", //  Tulu (India)
+	"te", //  Telugu
+	"te_IN", //  Telugu (India)
+	"tg_TJ", //  Tajik (Tajikistan)
+	"the_NP", //  Chitwania Tharu (Nepal)
+	"th", //  Thai
+	"th_TH", //  Thai (Thailand)
+	"ti", //  Tigrinya
+	"ti_ER", //  Tigrinya (Eritrea)
+	"ti_ET", //  Tigrinya (Ethiopia)
+	"tig_ER", //  Tigre (Eritrea)
+	"tk_TM", //  Turkmen (Turkmenistan)
+	"tl_PH", //  Tagalog (Philippines)
+	"tn_ZA", //  Tswana (South Africa)
+	"tr", //  Turkish
+	"tr_CY", //  Turkish (Cyprus)
+	"tr_TR", //  Turkish (Turkey)
+	"ts_ZA", //  Tsonga (South Africa)
+	"tt_RU", //  Tatar (Russia)
+	"ug_CN", //  Uighur (China)
+	"uk", //  Ukrainian
+	"uk_UA", //  Ukrainian (Ukraine)
+	"unm_US", //  Unami (United States)
+	"ur", //  Urdu
+	"ur_IN", //  Urdu (India)
+	"ur_PK", //  Urdu (Pakistan)
+	"uz", //  Uzbek
+	"uz_UZ", //  Uzbek (Uzbekistan)
+	"ve_ZA", //  Venda (South Africa)
+	"vi", //  Vietnamese
+	"vi_VN", //  Vietnamese (Vietnam)
+	"wa_BE", //  Walloon (Belgium)
+	"wae_CH", //  Walser (Switzerland)
+	"wal_ET", //  Wolaytta (Ethiopia)
+	"wo_SN", //  Wolof (Senegal)
+	"xh_ZA", //  Xhosa (South Africa)
+	"yi_US", //  Yiddish (United States)
+	"yo_NG", //  Yoruba (Nigeria)
+	"yue_HK", //  Yue Chinese (Hong Kong)
+	"zh", //  Chinese
+	"zh_CN", //  Chinese (China)
+	"zh_HK", //  Chinese (Hong Kong)
+	"zh_SG", //  Chinese (Singapore)
+	"zh_TW", //  Chinese (Taiwan)
+	"zu_ZA", //  Zulu (South Africa)
+	nullptr
+};
+
+static const char *locale_names[] = {
+	"Afar",
+	"Afar (Djibouti)",
+	"Afar (Eritrea)",
+	"Afar (Ethiopia)",
+	"Afrikaans",
+	"Afrikaans (South Africa)",
+	"Aguaruna (Peru)",
+	"Akan (Ghana)",
+	"Amharic (Ethiopia)",
+	"Aragonese (Spain)",
+	"Angika (India)",
+	"Arabic",
+	"Arabic (United Arab Emirates)",
+	"Arabic (Bahrain)",
+	"Arabic (Algeria)",
+	"Arabic (Egypt)",
+	"Arabic (India)",
+	"Arabic (Iraq)",
+	"Arabic (Jordan)",
+	"Arabic (Kuwait)",
+	"Arabic (Lebanon)",
+	"Arabic (Libya)",
+	"Arabic (Morocco)",
+	"Arabic (Oman)",
+	"Arabic (Qatar)",
+	"Arabic (Saudi Arabia)",
+	"Arabic (Sudan)",
+	"Arabic (South Soudan)",
+	"Arabic (Syria)",
+	"Arabic (Tunisia)",
+	"Arabic (Yemen)",
+	"Assamese (India)",
+	"Asturian (Spain)",
+	"Southern Aymara (Peru)",
+	"Aymara (Peru)",
+	"Azerbaijani (Azerbaijan)",
+	"Belarusian",
+	"Belarusian (Belarus)",
+	"Bemba (Zambia)",
+	"Berber languages (Algeria)",
+	"Berber languages (Morocco)",
+	"Bulgarian",
+	"Bulgarian (Bulgaria)",
+	"Bhili (India)",
+	"Bhojpuri (India)",
+	"Bislama (Tuvalu)",
+	"Bengali",
+	"Bengali (Bangladesh)",
+	"Bengali (India)",
+	"Tibetan",
+	"Tibetan (China)",
+	"Tibetan (India)",
+	"Breton (France)",
+	"Bodo (India)",
+	"Bosnian (Bosnia and Herzegovina)",
+	"Bilin (Eritrea)",
+	"Catalan",
+	"Catalan (Andorra)",
+	"Catalan (Spain)",
+	"Catalan (France)",
+	"Catalan (Italy)",
+	"Chechen (Russia)",
+	"Cherokee (United States)",
+	"Mandarin Chinese (Taiwan)",
+	"Crimean Tatar (Ukraine)",
+	"Kashubian (Poland)",
+	"Czech",
+	"Czech (Czech Republic)",
+	"Chuvash (Russia)",
+	"Welsh (United Kingdom)",
+	"Danish",
+	"Danish (Denmark)",
+	"German",
+	"German (Austria)",
+	"German (Belgium)",
+	"German (Switzerland)",
+	"German (Germany)",
+	"German (Italy)",
+	"German (Luxembourg)",
+	"Dogri (India)",
+	"Dhivehi (Maldives)",
+	"Dzongkha (Bhutan)",
+	"Greek",
+	"Greek (Cyprus)",
+	"Greek (Greece)",
+	"English",
+	"English (Antigua and Barbuda)",
+	"English (Australia)",
+	"English (Botswana)",
+	"English (Canada)",
+	"English (Denmark)",
+	"English (United Kingdom)",
+	"English (Hong Kong)",
+	"English (Ireland)",
+	"English (Israel)",
+	"English (India)",
+	"English (Nigeria)",
+	"English (New Zealand)",
+	"English (Philippines)",
+	"English (Singapore)",
+	"English (United States)",
+	"English (South Africa)",
+	"English (Zambia)",
+	"English (Zimbabwe)",
+	"Esperanto",
+	"Spanish",
+	"Spanish (Argentina)",
+	"Spanish (Bolivia)",
+	"Spanish (Chile)",
+	"Spanish (Colombia)",
+	"Spanish (Costa Rica)",
+	"Spanish (Cuba)",
+	"Spanish (Dominican Republic)",
+	"Spanish (Ecuador)",
+	"Spanish (Spain)",
+	"Spanish (Guatemala)",
+	"Spanish (Honduras)",
+	"Spanish (Mexico)",
+	"Spanish (Nicaragua)",
+	"Spanish (Panama)",
+	"Spanish (Peru)",
+	"Spanish (Puerto Rico)",
+	"Spanish (Paraguay)",
+	"Spanish (El Salvador)",
+	"Spanish (United States)",
+	"Spanish (Uruguay)",
+	"Spanish (Venezuela)",
+	"Estonian",
+	"Estonian (Estonia)",
+	"Basque",
+	"Basque (Spain)",
+	"Persian",
+	"Persian (Iran)",
+	"Fulah (Senegal)",
+	"Finnish",
+	"Finnish (Finland)",
+	"Filipino",
+	"Filipino (Philippines)",
+	"Faroese (Faroe Islands)",
+	"French",
+	"French (Belgium)",
+	"French (Canada)",
+	"French (Switzerland)",
+	"French (France)",
+	"French (Luxembourg)",
+	"Friulian (Italy)",
+	"Western Frisian (Germany)",
+	"Western Frisian (Netherlands)",
+	"Irish",
+	"Irish (Ireland)",
+	"Scottish Gaelic (United Kingdom)",
+	"Geez (Eritrea)",
+	"Geez (Ethiopia)",
+	"Galician (Spain)",
+	"Gujarati (India)",
+	"Manx (United Kingdom)",
+	"Hakka Chinese (Taiwan)",
+	"Hausa (Nigeria)",
+	"Hebrew",
+	"Hebrew (Israel)",
+	"Hindi",
+	"Hindi (India)",
+	"Chhattisgarhi (India)",
+	"Croatian",
+	"Croatian (Croatia)",
+	"Upper Sorbian (Germany)",
+	"Haitian (Haiti)",
+	"Hungarian",
+	"Hungarian (Hungary)",
+	"Huastec (Mexico)",
+	"Armenian (Armenia)",
+	"Interlingua (France)",
+	"Indonesian",
+	"Indonesian (Indonesia)",
+	"Igbo (Nigeria)",
+	"Inupiaq (Canada)",
+	"Icelandic",
+	"Icelandic (Iceland)",
+	"Italian",
+	"Italian (Switzerland)",
+	"Italian (Italy)",
+	"Inuktitut (Canada)",
+	"Japanese",
+	"Japanese (Japan)",
+	"Kabyle (Algeria)",
+	"Georgian",
+	"Georgian (Georgia)",
+	"Kazakh (Kazakhstan)",
+	"Kalaallisut (Greenland)",
+	"Central Khmer (Cambodia)",
+	"Kannada (India)",
+	"Konkani (India)",
+	"Korean",
+	"Korean (South Korea)",
+	"Kashmiri (India)",
+	"Kurdish",
+	"Kurdish (Turkey)",
+	"Cornish (United Kingdom)",
+	"Kirghiz (Kyrgyzstan)",
+	"Luxembourgish (Luxembourg)",
+	"Ganda (Uganda)",
+	"Limburgan (Belgium)",
+	"Limburgan (Netherlands)",
+	"Ligurian (Italy)",
+	"Lingala (Congo)",
+	"Lao (Laos)",
+	"Lithuanian",
+	"Lithuanian (Lithuania)",
+	"Latvian",
+	"Latvian (Latvia)",
+	"Literary Chinese (Taiwan)",
+	"Magahi (India)",
+	"Maithili (India)",
+	"Malagasy (Madagascar)",
+	"Marshallese (Marshall Islands)",
+	"Eastern Mari (Russia)",
+	"Māori",
+	"Māori (New Zealand)",
+	"Mískito (Nicaragua)",
+	"Macedonian",
+	"Macedonian (Macedonia)",
+	"Malayalam",
+	"Malayalam (India)",
+	"Manipuri (India)",
+	"Mongolian (Mongolia)",
+	"Marathi (India)",
+	"Malay",
+	"Malay (Malaysia)",
+	"Maltese",
+	"Maltese (Malta)",
+	"Burmese (Myanmar)",
+	"Erzya (Russia)",
+	"Nahuatl languages (Mexico)",
+	"Min Nan Chinese (Taiwan)",
+	"Norwegian Bokmål",
+	"Norwegian Bokmål (Norway)",
+	"Low German (Germany)",
+	"Low German (Netherlands)",
+	"Nepali (Nepal)",
+	"Central Nahuatl (Mexico)",
+	"Niuean (Niue)",
+	"Niuean (New Zealand)",
+	"Dutch",
+	"Dutch (Aruba)",
+	"Dutch (Belgium)",
+	"Dutch (Netherlands)",
+	"Norwegian Nynorsk",
+	"Norwegian Nynorsk (Norway)",
+	"South Ndebele (South Africa)",
+	"Pedi (South Africa)",
+	"Occitan (France)",
+	"Oromo",
+	"Oromo (Ethiopia)",
+	"Oromo (Kenya)",
+	"Oriya (India)",
+	"Ossetian (Russia)",
+	"Panjabi (India)",
+	"Papiamento",
+	"Papiamento (Netherlands Antilles)",
+	"Papiamento (Aruba)",
+	"Papiamento (Curaçao)",
+	"Panjabi (Pakistan)",
+	"Polish",
+	"Polish (Poland)",
+	"Pirate",
+	"Pushto (Afghanistan)",
+	"Portuguese",
+	"Portuguese (Brazil)",
+	"Portuguese (Portugal)",
+	"Ayacucho Quechua (Peru)",
+	"Cusco Quechua (Peru)",
+	"Rajasthani (India)",
+	"Romanian",
+	"Romanian (Romania)",
+	"Russian",
+	"Russian (Russia)",
+	"Russian (Ukraine)",
+	"Kinyarwanda (Rwanda)",
+	"Sanskrit (India)",
+	"Santali (India)",
+	"Sardinian (Italy)",
+	"Scots (Scotland)",
+	"Sindhi (India)",
+	"Northern Sami (Norway)",
+	"Samogitian (Lithuania)",
+	"Shuswap (Canada)",
+	"Sidamo (Ethiopia)",
+	"Sinhala",
+	"Sinhala (Sri Lanka)",
+	"Slovak",
+	"Slovak (Slovakia)",
+	"Slovenian",
+	"Slovenian (Slovenia)",
+	"Somali",
+	"Somali (Djibouti)",
+	"Somali (Ethiopia)",
+	"Somali (Kenya)",
+	"Somali (Somalia)",
+	"Songhai languages (Mali)",
+	"Albanian",
+	"Albanian (Albania)",
+	"Albanian (Kosovo)",
+	"Albanian (Macedonia)",
+	"Serbian",
+	"Serbian (Cyrillic)",
+	"Serbian (Latin)",
+	"Serbian (Montenegro)",
+	"Serbian (Serbia)",
+	"Swati (South Africa)",
+	"Southern Sotho (South Africa)",
+	"Swedish",
+	"Swedish (Finland)",
+	"Swedish (Sweden)",
+	"Swahili (Kenya)",
+	"Swahili (Tanzania)",
+	"Silesian (Poland)",
+	"Tamil",
+	"Tamil (India)",
+	"Tamil (Sri Lanka)",
+	"Tulu (India)",
+	"Telugu",
+	"Telugu (India)",
+	"Tajik (Tajikistan)",
+	"Chitwania Tharu (Nepal)",
+	"Thai",
+	"Thai (Thailand)",
+	"Tigrinya",
+	"Tigrinya (Eritrea)",
+	"Tigrinya (Ethiopia)",
+	"Tigre (Eritrea)",
+	"Turkmen (Turkmenistan)",
+	"Tagalog (Philippines)",
+	"Tswana (South Africa)",
+	"Turkish",
+	"Turkish (Cyprus)",
+	"Turkish (Turkey)",
+	"Tsonga (South Africa)",
+	"Tatar (Russia)",
+	"Uighur (China)",
+	"Ukrainian",
+	"Ukrainian (Ukraine)",
+	"Unami (United States)",
+	"Urdu",
+	"Urdu (India)",
+	"Urdu (Pakistan)",
+	"Uzbek",
+	"Uzbek (Uzbekistan)",
+	"Venda (South Africa)",
+	"Vietnamese",
+	"Vietnamese (Vietnam)",
+	"Walloon (Belgium)",
+	"Walser (Switzerland)",
+	"Wolaytta (Ethiopia)",
+	"Wolof (Senegal)",
+	"Xhosa (South Africa)",
+	"Yiddish (United States)",
+	"Yoruba (Nigeria)",
+	"Yue Chinese (Hong Kong)",
+	"Chinese",
+	"Chinese (China)",
+	"Chinese (Hong Kong)",
+	"Chinese (Singapore)",
+	"Chinese (Taiwan)",
+	"Zulu (South Africa)",
+	nullptr
+};
+
+// Windows has some weird locale identifiers which do not honor the ISO 639-1
+// standardized nomenclature. Whenever those don't conflict with existing ISO
+// identifiers, we override them.
+//
+// Reference:
+// - https://msdn.microsoft.com/en-us/library/windows/desktop/ms693062(v=vs.85).aspx
+
+static const char *locale_renames[][2] = {
+	{ "in", "id" }, //  Indonesian
+	{ "iw", "he" }, //  Hebrew
+	{ "no", "nb" }, //  Norwegian Bokmål
+	{ nullptr, nullptr }
+};
+
+///////////////////////////////////////////////
+
+Dictionary Translation::_get_messages() const {
+	Dictionary d;
+	for (const Map<StringName, StringName>::Element *E = translation_map.front(); E; E = E->next()) {
+		d[E->key()] = E->value();
+	}
+	return d;
+}
+
+Vector<String> Translation::_get_message_list() const {
+	Vector<String> msgs;
+	msgs.resize(translation_map.size());
+	int idx = 0;
+	for (const Map<StringName, StringName>::Element *E = translation_map.front(); E; E = E->next()) {
+		msgs.set(idx, E->key());
+		idx += 1;
+	}
+
+	return msgs;
+}
+
+void Translation::_set_messages(const Dictionary &p_messages) {
+	List<Variant> keys;
+	p_messages.get_key_list(&keys);
+	for (auto E = keys.front(); E; E = E->next()) {
+		translation_map[E->get()] = p_messages[E->get()];
+	}
+}
+
+void Translation::set_locale(const String &p_locale) {
+	String univ_locale = TranslationServer::standardize_locale(p_locale);
+
+	if (!TranslationServer::is_locale_valid(univ_locale)) {
+		String trimmed_locale = TranslationServer::get_language_code(univ_locale);
+
+		ERR_FAIL_COND_MSG(!TranslationServer::is_locale_valid(trimmed_locale), "Invalid locale: " + trimmed_locale + ".");
+
+		locale = trimmed_locale;
+	} else {
+		locale = univ_locale;
+	}
+
+	if (OS::get_singleton()->get_main_loop()) {
+		OS::get_singleton()->get_main_loop()->notification(MainLoop::NOTIFICATION_TRANSLATION_CHANGED);
+	}
+}
+
+void Translation::add_message(const StringName &p_src_text, const StringName &p_xlated_text, const StringName &p_context) {
+	translation_map[p_src_text] = p_xlated_text;
+}
+
+void Translation::add_plural_message(const StringName &p_src_text, const Vector<String> &p_plural_xlated_texts, const StringName &p_context) {
+	WARN_PRINT("Translation class doesn't handle plural messages. Calling add_plural_message() on a Translation instance is probably a mistake. \nUse a derived Translation class that handles plurals, such as TranslationPO class");
+	ERR_FAIL_COND_MSG(p_plural_xlated_texts.empty(), "Parameter vector p_plural_xlated_texts passed in is empty.");
+	translation_map[p_src_text] = p_plural_xlated_texts[0];
+}
+
+StringName Translation::get_message(const StringName &p_src_text, const StringName &p_context) const {
+	if (p_context != StringName()) {
+		WARN_PRINT("Translation class doesn't handle context. Using context in get_message() on a Translation instance is probably a mistake. \nUse a derived Translation class that handles context, such as TranslationPO class");
+	}
+
+	const Map<StringName, StringName>::Element *E = translation_map.find(p_src_text);
+	if (!E) {
+		return StringName();
+	}
+
+	return E->get();
+}
+
+StringName Translation::get_plural_message(const StringName &p_src_text, const StringName &p_plural_text, int p_n, const StringName &p_context) const {
+	WARN_PRINT("Translation class doesn't handle plural messages. Calling get_plural_message() on a Translation instance is probably a mistake. \nUse a derived Translation class that handles plurals, such as TranslationPO class");
+	return get_message(p_src_text);
+}
+
+void Translation::erase_message(const StringName &p_src_text, const StringName &p_context) {
+	if (p_context != StringName()) {
+		WARN_PRINT("Translation class doesn't handle context. Using context in erase_message() on a Translation instance is probably a mistake. \nUse a derived Translation class that handles context, such as TranslationPO class");
+	}
+
+	translation_map.erase(p_src_text);
+}
+
+void Translation::get_message_list(List<StringName> *r_messages) const {
+	for (const Map<StringName, StringName>::Element *E = translation_map.front(); E; E = E->next()) {
+		r_messages->push_back(E->key());
+	}
+}
+
+int Translation::get_message_count() const {
+	return translation_map.size();
+}
+
+void Translation::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_locale", "locale"), &Translation::set_locale);
+	ClassDB::bind_method(D_METHOD("get_locale"), &Translation::get_locale);
+	ClassDB::bind_method(D_METHOD("add_message", "src_message", "xlated_message", "context"), &Translation::add_message, DEFVAL(""));
+	ClassDB::bind_method(D_METHOD("add_plural_message", "src_message", "xlated_messages", "context"), &Translation::add_plural_message, DEFVAL(""));
+	ClassDB::bind_method(D_METHOD("get_message", "src_message", "context"), &Translation::get_message, DEFVAL(""));
+	ClassDB::bind_method(D_METHOD("get_plural_message", "src_message", "src_plural_message", "n", "context"), &Translation::get_plural_message, DEFVAL(""));
+	ClassDB::bind_method(D_METHOD("erase_message", "src_message", "context"), &Translation::erase_message, DEFVAL(""));
+	ClassDB::bind_method(D_METHOD("get_message_list"), &Translation::_get_message_list);
+	ClassDB::bind_method(D_METHOD("get_message_count"), &Translation::get_message_count);
+	ClassDB::bind_method(D_METHOD("_set_messages"), &Translation::_set_messages);
+	ClassDB::bind_method(D_METHOD("_get_messages"), &Translation::_get_messages);
+
+	ADD_PROPERTY(PropertyInfo(Variant::DICTIONARY, "messages", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL), "_set_messages", "_get_messages");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "locale"), "set_locale", "get_locale");
+}
+
+///////////////////////////////////////////////
+
+bool TranslationServer::is_locale_valid(const String &p_locale) {
+	const char **ptr = locale_list;
+
+	while (*ptr) {
+		if (*ptr == p_locale) {
+			return true;
+		}
+		ptr++;
+	}
+
+	return false;
+}
+
+String TranslationServer::standardize_locale(const String &p_locale) {
+	// Replaces '-' with '_' for macOS Sierra-style locales
+	String univ_locale = p_locale.replace("-", "_");
+
+	// Handles known non-ISO locale names used e.g. on Windows
+	int idx = 0;
+	while (locale_renames[idx][0] != nullptr) {
+		if (locale_renames[idx][0] == univ_locale) {
+			univ_locale = locale_renames[idx][1];
+			break;
+		}
+		idx++;
+	}
+
+	return univ_locale;
+}
+
+String TranslationServer::get_language_code(const String &p_locale) {
+	ERR_FAIL_COND_V_MSG(p_locale.length() < 2, p_locale, "Invalid locale '" + p_locale + "'.");
+	// Most language codes are two letters, but some are three,
+	// so we have to look for a regional code separator ('_' or '-')
+	// to extract the left part.
+	// For example we get 'nah_MX' as input and should return 'nah'.
+	int split = p_locale.find("_");
+	if (split == -1) {
+		split = p_locale.find("-");
+	}
+	if (split == -1) { // No separator, so the locale is already only a language code.
+		return p_locale;
+	}
+	return p_locale.left(split);
+}
+
+void TranslationServer::set_locale(const String &p_locale) {
+	String univ_locale = standardize_locale(p_locale);
+
+	if (!is_locale_valid(univ_locale)) {
+		String trimmed_locale = get_language_code(univ_locale);
+		print_verbose(vformat("Unsupported locale '%s', falling back to '%s'.", p_locale, trimmed_locale));
+
+		if (!is_locale_valid(trimmed_locale)) {
+			ERR_PRINT(vformat("Unsupported locale '%s', falling back to 'en'.", trimmed_locale));
+			locale = "en";
+		} else {
+			locale = trimmed_locale;
+		}
+	} else {
+		locale = univ_locale;
+	}
+
+	if (OS::get_singleton()->get_main_loop()) {
+		OS::get_singleton()->get_main_loop()->notification(MainLoop::NOTIFICATION_TRANSLATION_CHANGED);
+	}
+
+	ResourceLoader::reload_translation_remaps();
+}
+
+String TranslationServer::get_locale() const {
+	return locale;
+}
+
+String TranslationServer::get_locale_name(const String &p_locale) const {
+	if (!locale_name_map.has(p_locale)) {
+		return String();
+	}
+	return locale_name_map[p_locale];
+}
+
+Array TranslationServer::get_loaded_locales() const {
+	Array locales;
+	for (const Set<Ref<Translation>>::Element *E = translations.front(); E; E = E->next()) {
+		const Ref<Translation> &t = E->get();
+		ERR_FAIL_COND_V(t.is_null(), Array());
+		String l = t->get_locale();
+
+		locales.push_back(l);
+	}
+
+	return locales;
+}
+
+Vector<String> TranslationServer::get_all_locales() {
+	Vector<String> locales;
+
+	const char **ptr = locale_list;
+
+	while (*ptr) {
+		locales.push_back(*ptr);
+		ptr++;
+	}
+
+	return locales;
+}
+
+Vector<String> TranslationServer::get_all_locale_names() {
+	Vector<String> locales;
+
+	const char **ptr = locale_names;
+
+	while (*ptr) {
+		locales.push_back(String::utf8(*ptr));
+		ptr++;
+	}
+
+	return locales;
+}
+
+void TranslationServer::add_translation(const Ref<Translation> &p_translation) {
+	translations.insert(p_translation);
+}
+
+void TranslationServer::remove_translation(const Ref<Translation> &p_translation) {
+	translations.erase(p_translation);
+}
+
+Ref<Translation> TranslationServer::get_translation_object(const String &p_locale) {
+	Ref<Translation> res;
+	String lang = get_language_code(p_locale);
+	bool near_match_found = false;
+
+	for (const Set<Ref<Translation>>::Element *E = translations.front(); E; E = E->next()) {
+		const Ref<Translation> &t = E->get();
+		ERR_FAIL_COND_V(t.is_null(), nullptr);
+		String l = t->get_locale();
+
+		// Exact match.
+		if (l == p_locale) {
+			return t;
+		}
+
+		// If near match found, keep that match, but keep looking to try to look for perfect match.
+		if (get_language_code(l) == lang && !near_match_found) {
+			res = t;
+			near_match_found = true;
+		}
+	}
+	return res;
+}
+
+void TranslationServer::clear() {
+	translations.clear();
+}
+
+StringName TranslationServer::translate(const StringName &p_message, const StringName &p_context) const {
+	// Match given message against the translation catalog for the project locale.
+
+	if (!enabled) {
+		return p_message;
+	}
+
+	ERR_FAIL_COND_V_MSG(locale.length() < 2, p_message, "Could not translate message as configured locale '" + locale + "' is invalid.");
+
+	StringName res = _get_message_from_translations(p_message, p_context, locale, false);
+
+	if (!res && fallback.length() >= 2) {
+		res = _get_message_from_translations(p_message, p_context, fallback, false);
+	}
+
+	if (!res) {
+		return p_message;
+	}
+
+	return res;
+}
+
+StringName TranslationServer::translate_plural(const StringName &p_message, const StringName &p_message_plural, int p_n, const StringName &p_context) const {
+	if (!enabled) {
+		if (p_n == 1) {
+			return p_message;
+		}
+		return p_message_plural;
+	}
+
+	ERR_FAIL_COND_V_MSG(locale.length() < 2, p_message, "Could not translate message as configured locale '" + locale + "' is invalid.");
+
+	StringName res = _get_message_from_translations(p_message, p_context, locale, true, p_message_plural, p_n);
+
+	if (!res && fallback.length() >= 2) {
+		res = _get_message_from_translations(p_message, p_context, fallback, true, p_message_plural, p_n);
+	}
+
+	if (!res) {
+		if (p_n == 1) {
+			return p_message;
+		}
+		return p_message_plural;
+	}
+
+	return res;
+}
+
+StringName TranslationServer::_get_message_from_translations(const StringName &p_message, const StringName &p_context, const String &p_locale, bool plural, const String &p_message_plural, int p_n) const {
+	// Locale can be of the form 'll_CC', i.e. language code and regional code,
+	// e.g. 'en_US', 'en_GB', etc. It might also be simply 'll', e.g. 'en'.
+	// To find the relevant translation, we look for those with locale starting
+	// with the language code, and then if any is an exact match for the long
+	// form. If not found, we fall back to a near match (another locale with
+	// same language code).
+
+	// Note: ResourceLoader::_path_remap reproduces this locale near matching
+	// logic, so be sure to propagate changes there when changing things here.
+
+	StringName res;
+	String lang = get_language_code(p_locale);
+	bool near_match = false;
+
+	for (const Set<Ref<Translation>>::Element *E = translations.front(); E; E = E->next()) {
+		const Ref<Translation> &t = E->get();
+		ERR_FAIL_COND_V(t.is_null(), p_message);
+		String l = t->get_locale();
+
+		bool exact_match = (l == p_locale);
+		if (!exact_match) {
+			if (near_match) {
+				continue; // Only near-match once, but keep looking for exact matches.
+			}
+			if (get_language_code(l) != lang) {
+				continue; // Language code does not match.
+			}
+		}
+
+		StringName r;
+		if (!plural) {
+			r = t->get_message(p_message, p_context);
+		} else {
+			r = t->get_plural_message(p_message, p_message_plural, p_n, p_context);
+		}
+
+		if (!r) {
+			continue;
+		}
+		res = r;
+
+		if (exact_match) {
+			break;
+		} else {
+			near_match = true;
+		}
+	}
+
+	return res;
+}
+
+TranslationServer *TranslationServer::singleton = nullptr;
+
+bool TranslationServer::_load_translations(const String &p_from) {
+	if (ProjectSettings::get_singleton()->has_setting(p_from)) {
+		Vector<String> translations = ProjectSettings::get_singleton()->get(p_from);
+
+		int tcount = translations.size();
+
+		if (tcount) {
+			const String *r = translations.ptr();
+
+			for (int i = 0; i < tcount; i++) {
+				Ref<Translation> tr = ResourceLoader::load(r[i]);
+				if (tr.is_valid()) {
+					add_translation(tr);
+				}
+			}
+		}
+		return true;
+	}
+
+	return false;
+}
+
+void TranslationServer::setup() {
+	String test = GLOBAL_DEF("locale/test", "");
+	test = test.strip_edges();
+	if (test != "") {
+		set_locale(test);
+	} else {
+		set_locale(OS::get_singleton()->get_locale());
+	}
+	fallback = GLOBAL_DEF("locale/fallback", "en");
+#ifdef TOOLS_ENABLED
+	{
+		String options = "";
+		int idx = 0;
+		while (locale_list[idx]) {
+			if (idx > 0) {
+				options += ",";
+			}
+			options += locale_list[idx];
+			idx++;
+		}
+		ProjectSettings::get_singleton()->set_custom_property_info("locale/fallback", PropertyInfo(Variant::STRING, "locale/fallback", PROPERTY_HINT_ENUM, options));
+	}
+#endif
+}
+
+void TranslationServer::set_tool_translation(const Ref<Translation> &p_translation) {
+	tool_translation = p_translation;
+}
+
+StringName TranslationServer::tool_translate(const StringName &p_message, const StringName &p_context) const {
+	if (tool_translation.is_valid()) {
+		StringName r = tool_translation->get_message(p_message, p_context);
+		if (r) {
+			return r;
+		}
+	}
+	return p_message;
+}
+
+StringName TranslationServer::tool_translate_plural(const StringName &p_message, const StringName &p_message_plural, int p_n, const StringName &p_context) const {
+	if (tool_translation.is_valid()) {
+		StringName r = tool_translation->get_plural_message(p_message, p_message_plural, p_n, p_context);
+		if (r) {
+			return r;
+		}
+	}
+
+	if (p_n == 1) {
+		return p_message;
+	}
+	return p_message_plural;
+}
+
+void TranslationServer::set_doc_translation(const Ref<Translation> &p_translation) {
+	doc_translation = p_translation;
+}
+
+StringName TranslationServer::doc_translate(const StringName &p_message, const StringName &p_context) const {
+	if (doc_translation.is_valid()) {
+		StringName r = doc_translation->get_message(p_message, p_context);
+		if (r) {
+			return r;
+		}
+	}
+	return p_message;
+}
+
+StringName TranslationServer::doc_translate_plural(const StringName &p_message, const StringName &p_message_plural, int p_n, const StringName &p_context) const {
+	if (doc_translation.is_valid()) {
+		StringName r = doc_translation->get_plural_message(p_message, p_message_plural, p_n, p_context);
+		if (r) {
+			return r;
+		}
+	}
+
+	if (p_n == 1) {
+		return p_message;
+	}
+	return p_message_plural;
+}
+
+void TranslationServer::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_locale", "locale"), &TranslationServer::set_locale);
+	ClassDB::bind_method(D_METHOD("get_locale"), &TranslationServer::get_locale);
+
+	ClassDB::bind_method(D_METHOD("get_locale_name", "locale"), &TranslationServer::get_locale_name);
+
+	ClassDB::bind_method(D_METHOD("translate", "message", "context"), &TranslationServer::translate, DEFVAL(""));
+	ClassDB::bind_method(D_METHOD("translate_plural", "message", "plural_message", "n", "context"), &TranslationServer::translate_plural, DEFVAL(""));
+
+	ClassDB::bind_method(D_METHOD("add_translation", "translation"), &TranslationServer::add_translation);
+	ClassDB::bind_method(D_METHOD("remove_translation", "translation"), &TranslationServer::remove_translation);
+	ClassDB::bind_method(D_METHOD("get_translation_object", "locale"), &TranslationServer::get_translation_object);
+
+	ClassDB::bind_method(D_METHOD("clear"), &TranslationServer::clear);
+
+	ClassDB::bind_method(D_METHOD("get_loaded_locales"), &TranslationServer::get_loaded_locales);
+}
+
+void TranslationServer::load_translations() {
+	String locale = get_locale();
+	_load_translations("locale/translations"); //all
+	_load_translations("locale/translations_" + locale.substr(0, 2));
+
+	if (locale.substr(0, 2) != locale) {
+		_load_translations("locale/translations_" + locale);
+	}
+}
+
+TranslationServer::TranslationServer() {
+	singleton = this;
+
+	for (int i = 0; locale_list[i]; ++i) {
+		locale_name_map.insert(locale_list[i], String::utf8(locale_names[i]));
+	}
+}