diff --git a/countries.txt b/countries.txt new file mode 100644 index 0000000..8000a83 --- /dev/null +++ b/countries.txt @@ -0,0 +1,249 @@ +Afghanistan AF AFG 004 +Albania AL ALB 008 +Algeria DZ DZA 012 +American Samoa AS ASM 016 +Andorra AD AND 020 +Angola AO AGO 024 +Anguilla AI AIA 660 +Antarctica AQ ATA 010 +Antigua and Barbuda AG ATG 028 +Argentina AR ARG 032 +Armenia AM ARM 051 +Aruba AW ABW 533 +Australia AU AUS 036 +Austria AT AUT 040 +Azerbaijan AZ AZE 031 +Bahamas (the) BS BHS 044 +Bahrain BH BHR 048 +Bangladesh BD BGD 050 +Barbados BB BRB 052 +Belarus BY BLR 112 +Belgium BE BEL 056 +Belize BZ BLZ 084 +Benin BJ BEN 204 +Bermuda BM BMU 060 +Bhutan BT BTN 064 +Bolivia (Plurinational State of) BO BOL 068 +Bonaire, Sint Eustatius and Saba BQ BES 535 +Bosnia and Herzegovina BA BIH 070 +Botswana BW BWA 072 +Bouvet Island BV BVT 074 +Brazil BR BRA 076 +British Indian Ocean Territory (the) IO IOT 086 +Brunei Darussalam BN BRN 096 +Bulgaria BG BGR 100 +Burkina Faso BF BFA 854 +Burundi BI BDI 108 +Cabo Verde CV CPV 132 +Cambodia KH KHM 116 +Cameroon CM CMR 120 +Canada CA CAN 124 +Cayman Islands (the) KY CYM 136 +Central African Republic (the) CF CAF 140 +Chad TD TCD 148 +Chile CL CHL 152 +China CN CHN 156 +Christmas Island CX CXR 162 +Cocos (Keeling) Islands (the) CC CCK 166 +Colombia CO COL 170 +Comoros (the) KM COM 174 +Congo (the Democratic Republic of the) CD COD 180 +Congo (the) CG COG 178 +Cook Islands (the) CK COK 184 +Costa Rica CR CRI 188 +Croatia HR HRV 191 +Cuba CU CUB 192 +Curaçao CW CUW 531 +Cyprus CY CYP 196 +Czechia CZ CZE 203 +Côte d'Ivoire CI CIV 384 +Denmark DK DNK 208 +Djibouti DJ DJI 262 +Dominica DM DMA 212 +Dominican Republic (the) DO DOM 214 +Ecuador EC ECU 218 +Egypt EG EGY 818 +El Salvador SV SLV 222 +Equatorial Guinea GQ GNQ 226 +Eritrea ER ERI 232 +Estonia EE EST 233 +Eswatini SZ SWZ 748 +Ethiopia ET ETH 231 +Falkland Islands (the) [Malvinas] FK FLK 238 +Faroe Islands (the) FO FRO 234 +Fiji FJ FJI 242 +Finland FI FIN 246 +France FR FRA 250 +French Guiana GF GUF 254 +French Polynesia PF PYF 258 +French Southern Territories (the) TF ATF 260 +Gabon GA GAB 266 +Gambia (the) GM GMB 270 +Georgia GE GEO 268 +Germany DE DEU 276 +Ghana GH GHA 288 +Gibraltar GI GIB 292 +Greece GR GRC 300 +Greenland GL GRL 304 +Grenada GD GRD 308 +Guadeloupe GP GLP 312 +Guam GU GUM 316 +Guatemala GT GTM 320 +Guernsey GG GGY 831 +Guinea GN GIN 324 +Guinea-Bissau GW GNB 624 +Guyana GY GUY 328 +Haiti HT HTI 332 +Heard Island and McDonald Islands HM HMD 334 +Holy See (the) VA VAT 336 +Honduras HN HND 340 +Hong Kong HK HKG 344 +Hungary HU HUN 348 +Iceland IS ISL 352 +India IN IND 356 +Indonesia ID IDN 360 +Iran (Islamic Republic of) IR IRN 364 +Iraq IQ IRQ 368 +Ireland IE IRL 372 +Isle of Man IM IMN 833 +Israel IL ISR 376 +Italy IT ITA 380 +Jamaica JM JAM 388 +Japan JP JPN 392 +Jersey JE JEY 832 +Jordan JO JOR 400 +Kazakhstan KZ KAZ 398 +Kenya KE KEN 404 +Kiribati KI KIR 296 +Korea (the Democratic People's Republic of) KP PRK 408 +Korea (the Republic of) KR KOR 410 +Kuwait KW KWT 414 +Kyrgyzstan KG KGZ 417 +Lao People's Democratic Republic (the) LA LAO 418 +Latvia LV LVA 428 +Lebanon LB LBN 422 +Lesotho LS LSO 426 +Liberia LR LBR 430 +Libya LY LBY 434 +Liechtenstein LI LIE 438 +Lithuania LT LTU 440 +Luxembourg LU LUX 442 +Macao MO MAC 446 +Madagascar MG MDG 450 +Malawi MW MWI 454 +Malaysia MY MYS 458 +Maldives MV MDV 462 +Mali ML MLI 466 +Malta MT MLT 470 +Marshall Islands (the) MH MHL 584 +Martinique MQ MTQ 474 +Mauritania MR MRT 478 +Mauritius MU MUS 480 +Mayotte YT MYT 175 +Mexico MX MEX 484 +Micronesia (Federated States of) FM FSM 583 +Moldova (the Republic of) MD MDA 498 +Monaco MC MCO 492 +Mongolia MN MNG 496 +Montenegro ME MNE 499 +Montserrat MS MSR 500 +Morocco MA MAR 504 +Mozambique MZ MOZ 508 +Myanmar MM MMR 104 +Namibia NA NAM 516 +Nauru NR NRU 520 +Nepal NP NPL 524 +Netherlands (the) NL NLD 528 +New Caledonia NC NCL 540 +New Zealand NZ NZL 554 +Nicaragua NI NIC 558 +Niger (the) NE NER 562 +Nigeria NG NGA 566 +Niue NU NIU 570 +Norfolk Island NF NFK 574 +Northern Mariana Islands (the) MP MNP 580 +Norway NO NOR 578 +Oman OM OMN 512 +Pakistan PK PAK 586 +Palau PW PLW 585 +Palestine, State of PS PSE 275 +Panama PA PAN 591 +Papua New Guinea PG PNG 598 +Paraguay PY PRY 600 +Peru PE PER 604 +Philippines (the) PH PHL 608 +Pitcairn PN PCN 612 +Poland PL POL 616 +Portugal PT PRT 620 +Puerto Rico PR PRI 630 +Qatar QA QAT 634 +Republic of North Macedonia MK MKD 807 +Romania RO ROU 642 +Russian Federation (the) RU RUS 643 +Rwanda RW RWA 646 +Réunion RE REU 638 +Saint Barthélemy BL BLM 652 +Saint Helena, Ascension and Tristan da Cunha SH SHN 654 +Saint Kitts and Nevis KN KNA 659 +Saint Lucia LC LCA 662 +Saint Martin (French part) MF MAF 663 +Saint Pierre and Miquelon PM SPM 666 +Saint Vincent and the Grenadines VC VCT 670 +Samoa WS WSM 882 +San Marino SM SMR 674 +Sao Tome and Principe ST STP 678 +Saudi Arabia SA SAU 682 +Senegal SN SEN 686 +Serbia RS SRB 688 +Seychelles SC SYC 690 +Sierra Leone SL SLE 694 +Singapore SG SGP 702 +Sint Maarten (Dutch part) SX SXM 534 +Slovakia SK SVK 703 +Slovenia SI SVN 705 +Solomon Islands SB SLB 090 +Somalia SO SOM 706 +South Africa ZA ZAF 710 +South Georgia and the South Sandwich Islands GS SGS 239 +South Sudan SS SSD 728 +Spain ES ESP 724 +Sri Lanka LK LKA 144 +Sudan (the) SD SDN 729 +Suriname SR SUR 740 +Svalbard and Jan Mayen SJ SJM 744 +Sweden SE SWE 752 +Switzerland CH CHE 756 +Syrian Arab Republic SY SYR 760 +Taiwan (Province of China) TW TWN 158 +Tajikistan TJ TJK 762 +Tanzania, United Republic of TZ TZA 834 +Thailand TH THA 764 +Timor-Leste TL TLS 626 +Togo TG TGO 768 +Tokelau TK TKL 772 +Tonga TO TON 776 +Trinidad and Tobago TT TTO 780 +Tunisia TN TUN 788 +Turkey TR TUR 792 +Turkmenistan TM TKM 795 +Turks and Caicos Islands (the) TC TCA 796 +Tuvalu TV TUV 798 +Uganda UG UGA 800 +Ukraine UA UKR 804 +United Arab Emirates (the) AE ARE 784 +United Kingdom of Great Britain and Northern Ireland (the) GB GBR 826 +United States Minor Outlying Islands (the) UM UMI 581 +United States of America (the) US USA 840 +Uruguay UY URY 858 +Uzbekistan UZ UZB 860 +Vanuatu VU VUT 548 +Venezuela (Bolivarian Republic of) VE VEN 862 +Viet Nam VN VNM 704 +Virgin Islands (British) VG VGB 092 +Virgin Islands (U.S.) VI VIR 850 +Wallis and Futuna WF WLF 876 +Western Sahara EH ESH 732 +Yemen YE YEM 887 +Zambia ZM ZMB 894 +Zimbabwe ZW ZWE 716 +Åland Islands AX ALA 248 diff --git a/languages.txt b/languages.txt new file mode 100644 index 0000000..c4897bb --- /dev/null +++ b/languages.txt @@ -0,0 +1,136 @@ +Abkhazian AB +Afar AA +Afrikaans AF +Albanian SQ +Amharic AM +Arabic AR +Armenian HY +Assamese AS +Aymara AY +Azerbaijani AZ +Bashkir BA +Basque EU +Bengali, Bangla BN +Bhutani DZ +Bihari BH +Bislama BI +Breton BR +Bulgarian BG +Burmese MY +Byelorussian BE +Cambodian KM +Catalan CA +Chinese ZH +Corsican CO +Croatian HR +Czech CS +Danish DA +Dutch NL +English, American EN +Esperanto EO +Estonian ET +Faeroese FO +Fiji FJ +Finnish FI +French FR +Frisian FY +Gaelic (Scots Gaelic) GD +Galician GL +Georgian KA +German DE +Greek EL +Greenlandic KL +Guarani GN +Gujarati GU +Hausa HA +Hebrew IW +Hindi HI +Hungarian HU +Icelandic IS +Indonesian IN +Interlingua IA +Interlingue IE +Inupiak IK +Irish GA +Italian IT +Japanese JA +Javanese JW +Kannada KN +Kashmiri KS +Kazakh KK +Kinyarwanda RW +Kirghiz KY +Kirundi RN +Korean KO +Kurdish KU +Laothian LO +Latin LA +Latvian, Lettish LV +Lingala LN +Lithuanian LT +Macedonian MK +Malagasy MG +Malay MS +Malayalam ML +Maltese MT +Maori MI +Marathi MR +Moldavian MO +Mongolian MN +Nauru NA +Nepali NE +Norwegian NO +Occitan OC +Oriya OR +Oromo, Afan OM +Pashto, Pushto PS +Persian FA +Polish PL +Portuguese PT +Punjabi PA +Quechua QU +Rhaeto-Romance RM +Romanian RO +Russian RU +Samoan SM +Sangro SG +Sanskrit SA +Serbian SR +Serbo-Croatian SH +Sesotho ST +Setswana TN +Shona SN +Sindhi SD +Singhalese SI +Siswati SS +Slovak SK +Slovenian SL +Somali SO +Spanish ES +Sudanese SU +Swahili SW +Swedish SV +Tagalog TL +Tajik TG +Tamil TA +Tatar TT +Tegulu TE +Thai TH +Tibetan BO +Tigrinya TI +Tonga TO +Tsonga TS +Turkish TR +Turkmen TK +Twi TW +Ukrainian UK +Urdu UR +Uzbek UZ +Vietnamese VI +Volapuk VO +Welsh CY +Wolof WO +Xhosa XH +Yiddish JI +Yoruba YO +Zulu ZU diff --git a/rearanged_countries.txt b/rearanged_countries.txt new file mode 100644 index 0000000..287733b --- /dev/null +++ b/rearanged_countries.txt @@ -0,0 +1,249 @@ +AF AFG 004 Afghanistan +AL ALB 008 Albania +DZ DZA 012 Algeria +AS ASM 016 American Samoa +AD AND 020 Andorra +AO AGO 024 Angola +AI AIA 660 Anguilla +AQ ATA 010 Antarctica +AG ATG 028 Antigua and Barbuda +AR ARG 032 Argentina +AM ARM 051 Armenia +AW ABW 533 Aruba +AU AUS 036 Australia +AT AUT 040 Austria +AZ AZE 031 Azerbaijan +BS BHS 044 Bahamas (the) +BH BHR 048 Bahrain +BD BGD 050 Bangladesh +BB BRB 052 Barbados +BY BLR 112 Belarus +BE BEL 056 Belgium +BZ BLZ 084 Belize +BJ BEN 204 Benin +BM BMU 060 Bermuda +BT BTN 064 Bhutan +BO BOL 068 Bolivia (Plurinational State of) +BQ BES 535 Bonaire, Sint Eustatius and Saba +BA BIH 070 Bosnia and Herzegovina +BW BWA 072 Botswana +BV BVT 074 Bouvet Island +BR BRA 076 Brazil +IO IOT 086 British Indian Ocean Territory (the) +BN BRN 096 Brunei Darussalam +BG BGR 100 Bulgaria +BF BFA 854 Burkina Faso +BI BDI 108 Burundi +CV CPV 132 Cabo Verde +KH KHM 116 Cambodia +CM CMR 120 Cameroon +CA CAN 124 Canada +KY CYM 136 Cayman Islands (the) +CF CAF 140 Central African Republic (the) +TD TCD 148 Chad +CL CHL 152 Chile +CN CHN 156 China +CX CXR 162 Christmas Island +CC CCK 166 Cocos (Keeling) Islands (the) +CO COL 170 Colombia +KM COM 174 Comoros (the) +CD COD 180 Congo (the Democratic Republic of the) +CG COG 178 Congo (the) +CK COK 184 Cook Islands (the) +CR CRI 188 Costa Rica +HR HRV 191 Croatia +CU CUB 192 Cuba +CW CUW 531 Curaçao +CY CYP 196 Cyprus +CZ CZE 203 Czechia +CI CIV 384 Côte d'Ivoire +DK DNK 208 Denmark +DJ DJI 262 Djibouti +DM DMA 212 Dominica +DO DOM 214 Dominican Republic (the) +EC ECU 218 Ecuador +EG EGY 818 Egypt +SV SLV 222 El Salvador +GQ GNQ 226 Equatorial Guinea +ER ERI 232 Eritrea +EE EST 233 Estonia +SZ SWZ 748 Eswatini +ET ETH 231 Ethiopia +FK FLK 238 Falkland Islands (the) [Malvinas] +FO FRO 234 Faroe Islands (the) +FJ FJI 242 Fiji +FI FIN 246 Finland +FR FRA 250 France +GF GUF 254 French Guiana +PF PYF 258 French Polynesia +TF ATF 260 French Southern Territories (the) +GA GAB 266 Gabon +GM GMB 270 Gambia (the) +GE GEO 268 Georgia +DE DEU 276 Germany +GH GHA 288 Ghana +GI GIB 292 Gibraltar +GR GRC 300 Greece +GL GRL 304 Greenland +GD GRD 308 Grenada +GP GLP 312 Guadeloupe +GU GUM 316 Guam +GT GTM 320 Guatemala +GG GGY 831 Guernsey +GN GIN 324 Guinea +GW GNB 624 Guinea-Bissau +GY GUY 328 Guyana +HT HTI 332 Haiti +HM HMD 334 Heard Island and McDonald Islands +VA VAT 336 Holy See (the) +HN HND 340 Honduras +HK HKG 344 Hong Kong +HU HUN 348 Hungary +IS ISL 352 Iceland +IN IND 356 India +ID IDN 360 Indonesia +IR IRN 364 Iran (Islamic Republic of) +IQ IRQ 368 Iraq +IE IRL 372 Ireland +IM IMN 833 Isle of Man +IL ISR 376 Israel +IT ITA 380 Italy +JM JAM 388 Jamaica +JP JPN 392 Japan +JE JEY 832 Jersey +JO JOR 400 Jordan +KZ KAZ 398 Kazakhstan +KE KEN 404 Kenya +KI KIR 296 Kiribati +KP PRK 408 Korea (the Democratic People's Republic of) +KR KOR 410 Korea (the Republic of) +KW KWT 414 Kuwait +KG KGZ 417 Kyrgyzstan +LA LAO 418 Lao People's Democratic Republic (the) +LV LVA 428 Latvia +LB LBN 422 Lebanon +LS LSO 426 Lesotho +LR LBR 430 Liberia +LY LBY 434 Libya +LI LIE 438 Liechtenstein +LT LTU 440 Lithuania +LU LUX 442 Luxembourg +MO MAC 446 Macao +MG MDG 450 Madagascar +MW MWI 454 Malawi +MY MYS 458 Malaysia +MV MDV 462 Maldives +ML MLI 466 Mali +MT MLT 470 Malta +MH MHL 584 Marshall Islands (the) +MQ MTQ 474 Martinique +MR MRT 478 Mauritania +MU MUS 480 Mauritius +YT MYT 175 Mayotte +MX MEX 484 Mexico +FM FSM 583 Micronesia (Federated States of) +MD MDA 498 Moldova (the Republic of) +MC MCO 492 Monaco +MN MNG 496 Mongolia +ME MNE 499 Montenegro +MS MSR 500 Montserrat +MA MAR 504 Morocco +MZ MOZ 508 Mozambique +MM MMR 104 Myanmar +NA NAM 516 Namibia +NR NRU 520 Nauru +NP NPL 524 Nepal +NL NLD 528 Netherlands (the) +NC NCL 540 New Caledonia +NZ NZL 554 New Zealand +NI NIC 558 Nicaragua +NE NER 562 Niger (the) +NG NGA 566 Nigeria +NU NIU 570 Niue +NF NFK 574 Norfolk Island +MP MNP 580 Northern Mariana Islands (the) +NO NOR 578 Norway +OM OMN 512 Oman +PK PAK 586 Pakistan +PW PLW 585 Palau +PS PSE 275 Palestine, State of +PA PAN 591 Panama +PG PNG 598 Papua New Guinea +PY PRY 600 Paraguay +PE PER 604 Peru +PH PHL 608 Philippines (the) +PN PCN 612 Pitcairn +PL POL 616 Poland +PT PRT 620 Portugal +PR PRI 630 Puerto Rico +QA QAT 634 Qatar +MK MKD 807 Republic of North Macedonia +RO ROU 642 Romania +RU RUS 643 Russian Federation (the) +RW RWA 646 Rwanda +RE REU 638 Réunion +BL BLM 652 Saint Barthélemy +SH SHN 654 Saint Helena, Ascension and Tristan da Cunha +KN KNA 659 Saint Kitts and Nevis +LC LCA 662 Saint Lucia +MF MAF 663 Saint Martin (French part) +PM SPM 666 Saint Pierre and Miquelon +VC VCT 670 Saint Vincent and the Grenadines +WS WSM 882 Samoa +SM SMR 674 San Marino +ST STP 678 Sao Tome and Principe +SA SAU 682 Saudi Arabia +SN SEN 686 Senegal +RS SRB 688 Serbia +SC SYC 690 Seychelles +SL SLE 694 Sierra Leone +SG SGP 702 Singapore +SX SXM 534 Sint Maarten (Dutch part) +SK SVK 703 Slovakia +SI SVN 705 Slovenia +SB SLB 090 Solomon Islands +SO SOM 706 Somalia +ZA ZAF 710 South Africa +GS SGS 239 South Georgia and the South Sandwich Islands +SS SSD 728 South Sudan +ES ESP 724 Spain +LK LKA 144 Sri Lanka +SD SDN 729 Sudan (the) +SR SUR 740 Suriname +SJ SJM 744 Svalbard and Jan Mayen +SE SWE 752 Sweden +CH CHE 756 Switzerland +SY SYR 760 Syrian Arab Republic +TW TWN 158 Taiwan (Province of China) +TJ TJK 762 Tajikistan +TZ TZA 834 Tanzania, United Republic of +TH THA 764 Thailand +TL TLS 626 Timor-Leste +TG TGO 768 Togo +TK TKL 772 Tokelau +TO TON 776 Tonga +TT TTO 780 Trinidad and Tobago +TN TUN 788 Tunisia +TR TUR 792 Turkey +TM TKM 795 Turkmenistan +TC TCA 796 Turks and Caicos Islands (the) +TV TUV 798 Tuvalu +UG UGA 800 Uganda +UA UKR 804 Ukraine +AE ARE 784 United Arab Emirates (the) +GB GBR 826 United Kingdom of Great Britain and Northern Ireland (the) +UM UMI 581 United States Minor Outlying Islands (the) +US USA 840 United States of America (the) +UY URY 858 Uruguay +UZ UZB 860 Uzbekistan +VU VUT 548 Vanuatu +VE VEN 862 Venezuela (Bolivarian Republic of) +VN VNM 704 Viet Nam +VG VGB 092 Virgin Islands (British) +VI VIR 850 Virgin Islands (U.S.) +WF WLF 876 Wallis and Futuna +EH ESH 732 Western Sahara +YE YEM 887 Yemen +ZM ZMB 894 Zambia +ZW ZWE 716 Zimbabwe +AX ALA 248 Åland Islands diff --git a/src/lib.rs b/src/lib.rs index 49ce2d0..3307af5 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -114,97 +114,3630 @@ use std::{ ffi::OsString, fmt::{self, Display, Formatter}, io::{Error, ErrorKind}, + env, // for environment variables (LANG, LC_ALL) }; +/// output : en_US.UTF-8 +/// en : language +/// US : country +#[allow(dead_code)] +fn get_language_and_country() -> String { + if let Ok(language) = env::var("LC_ALL") { + // possible output : en_US.UTF-8 + return language; + } else if let Ok(language) = env::var("LANG") { + // possible output : en_US.UTF-8 + return language; + } else if let Ok(language) = env::var("LANGUAGE") { + // possible output : en_US.UTF-8 + return language; + } + String::new() +} + + /// This crate's convenience type alias for [`Result`](std::result::Result)s pub type Result = std::result::Result; -/// Region code for a [`Language`] dialect -/// -/// Uses -#[non_exhaustive] -#[repr(u32)] -#[derive(Copy, Clone, Eq, PartialEq, Debug)] -pub enum Region { - // FIXME: V2: u32::from_ne_bytes for region codes, with `\0` for unused - // FIXME: Add aliases up to 3-4 letters, but hidden - /// Any dialect - Any, - /// `US`: United States of America +/// Region code for a [`Language`] dialect +/// +/// Uses +/// +/// https://www.suny.edu/media/suny/content-assets/documents/international-student/InternationalCountryCodes.pdf +/// https://www.iban.com/country-codes +#[non_exhaustive] +#[repr(u32)] +#[derive(Copy, Clone, Eq, PartialEq, Debug)] +pub enum Region { + // FIXME: V2: u32::from_ne_bytes for region codes, with `\0` for unused + // FIXME: Add aliases up to 3-4 letters, but hidden + /// Any dialect + Any, + + /// an u32 code for region + #[doc(hidden)] + Custom(u32), + + /// `AF`: Afghanistan + #[doc(hidden)] + Af, + + /// `AL`: Albania + #[doc(hidden)] + Al, + + /// `DZ`: Algeria + #[doc(hidden)] + Dz, + + /// `AS`: American Samoa + #[doc(hidden)] + As, + + /// `AD`: Andorra + #[doc(hidden)] + Ad, + + /// `AO`: Angola + #[doc(hidden)] + Ao, + + /// `AI`: Anguilla + #[doc(hidden)] + Ai, + + /// `AQ`: Antarctica + #[doc(hidden)] + Aq, + + /// `AG`: Antigua and Barbuda + #[doc(hidden)] + Ag, + + /// `AR`: Argentina + #[doc(hidden)] + Ar, + + /// `AM`: Armenia + #[doc(hidden)] + Am, + + /// `AW`: Aruba + #[doc(hidden)] + Aw, + + /// `AU`: Australia + #[doc(hidden)] + Au, + + /// `AT`: Austria + #[doc(hidden)] + At, + + /// `AZ`: Azerbaijan + #[doc(hidden)] + Az, + + /// `BS`: Bahamas (the) + #[doc(hidden)] + Bs, + + /// `BH`: Bahrain + #[doc(hidden)] + Bh, + + /// `BD`: Bangladesh + #[doc(hidden)] + Bd, + + /// `BB`: Barbados + #[doc(hidden)] + Bb, + + /// `BY`: Belarus + #[doc(hidden)] + By, + + /// `BE`: Belgium + #[doc(hidden)] + Be, + + /// `BZ`: Belize + #[doc(hidden)] + Bz, + + /// `BJ`: Benin + #[doc(hidden)] + Bj, + + /// `BM`: Bermuda + #[doc(hidden)] + Bm, + + /// `BT`: Bhutan + #[doc(hidden)] + Bt, + + /// `BO`: Bolivia (Plurinational State of) + #[doc(hidden)] + Bo, + + /// `BQ`: Bonaire, Sint Eustatius and Saba + #[doc(hidden)] + Bq, + + /// `BA`: Bosnia and Herzegovina + #[doc(hidden)] + Ba, + + /// `BW`: Botswana + #[doc(hidden)] + Bw, + + /// `BV`: Bouvet Island + #[doc(hidden)] + Bv, + + /// `BR`: Brazil + #[doc(hidden)] + Br, + + /// `IO`: British Indian Ocean Territory (the) + #[doc(hidden)] + Io, + + /// `BN`: Brunei Darussalam + #[doc(hidden)] + Bn, + + /// `BG`: Bulgaria + #[doc(hidden)] + Bg, + + /// `BF`: Burkina Faso + #[doc(hidden)] + Bf, + + /// `BI`: Burundi + #[doc(hidden)] + Bi, + + /// `CV`: Cabo Verde + #[doc(hidden)] + Cv, + + /// `KH`: Cambodia + #[doc(hidden)] + Kh, + + /// `CM`: Cameroon + #[doc(hidden)] + Cm, + + /// `CA`: Canada + #[doc(hidden)] + Ca, + + /// `KY`: Cayman Islands (the) + #[doc(hidden)] + Ky, + + /// `CF`: Central African Republic (the) + #[doc(hidden)] + Cf, + + /// `TD`: Chad + #[doc(hidden)] + Td, + + /// `CL`: Chile + #[doc(hidden)] + Cl, + + /// `CN`: China + #[doc(hidden)] + Cn, + + /// `CX`: Christmas Island + #[doc(hidden)] + Cx, + + /// `CC`: Cocos (Keeling) Islands (the) + #[doc(hidden)] + Cc, + + /// `CO`: Colombia + #[doc(hidden)] + Co, + + /// `KM`: Comoros (the) + #[doc(hidden)] + Km, + + /// `CD`: Congo (the Democratic Republic of the) + #[doc(hidden)] + Cd, + + /// `CG`: Congo (the) + #[doc(hidden)] + Cg, + + /// `CK`: Cook Islands (the) + #[doc(hidden)] + Ck, + + /// `CR`: Costa Rica + #[doc(hidden)] + Cr, + + /// `HR`: Croatia + #[doc(hidden)] + Hr, + + /// `CU`: Cuba + #[doc(hidden)] + Cu, + + /// `CW`: Curaçao + #[doc(hidden)] + Cw, + + /// `CY`: Cyprus + #[doc(hidden)] + Cy, + + /// `CZ`: Czechia + #[doc(hidden)] + Cz, + + /// `CI`: Côte d'Ivoire + #[doc(hidden)] + Ci, + + /// `DK`: Denmark + #[doc(hidden)] + Dk, + + /// `DJ`: Djibouti + #[doc(hidden)] + Dj, + + /// `DM`: Dominica + #[doc(hidden)] + Dm, + + /// `DO`: Dominican Republic (the) + #[doc(hidden)] + Do, + + /// `EC`: Ecuador + #[doc(hidden)] + Ec, + + /// `EG`: Egypt + #[doc(hidden)] + Eg, + + /// `SV`: El Salvador + #[doc(hidden)] + Sv, + + /// `GQ`: Equatorial Guinea + #[doc(hidden)] + Gq, + + /// `ER`: Eritrea + #[doc(hidden)] + Er, + + /// `EE`: Estonia + #[doc(hidden)] + Ee, + + /// `SZ`: Eswatini + #[doc(hidden)] + Sz, + + /// `ET`: Ethiopia + #[doc(hidden)] + Et, + + /// `FK`: Falkland Islands (the) [Malvinas] + #[doc(hidden)] + Fk, + + /// `FO`: Faroe Islands (the) + #[doc(hidden)] + Fo, + + /// `FJ`: Fiji + #[doc(hidden)] + Fj, + + /// `FI`: Finland + #[doc(hidden)] + Fi, + + /// `FR`: France + #[doc(hidden)] + Fr, + + /// `GF`: French Guiana + #[doc(hidden)] + Gf, + + /// `PF`: French Polynesia + #[doc(hidden)] + Pf, + + /// `TF`: French Southern Territories (the) + #[doc(hidden)] + Tf, + + /// `GA`: Gabon + #[doc(hidden)] + Ga, + + /// `GM`: Gambia (the) + #[doc(hidden)] + Gm, + + /// `GE`: Georgia + #[doc(hidden)] + Ge, + + /// `DE`: Germany + #[doc(hidden)] + De, + + /// `GH`: Ghana + #[doc(hidden)] + Gh, + + /// `GI`: Gibraltar + #[doc(hidden)] + Gi, + + /// `GR`: Greece + #[doc(hidden)] + Gr, + + /// `GL`: Greenland + #[doc(hidden)] + Gl, + + /// `GD`: Grenada + #[doc(hidden)] + Gd, + + /// `GP`: Guadeloupe + #[doc(hidden)] + Gp, + + /// `GU`: Guam + #[doc(hidden)] + Gu, + + /// `GT`: Guatemala + #[doc(hidden)] + Gt, + + /// `GG`: Guernsey + #[doc(hidden)] + Gg, + + /// `GN`: Guinea + #[doc(hidden)] + Gn, + + /// `GW`: Guinea-Bissau + #[doc(hidden)] + Gw, + + /// `GY`: Guyana + #[doc(hidden)] + Gy, + + /// `HT`: Haiti + #[doc(hidden)] + Ht, + + /// `HM`: Heard Island and McDonald Islands + #[doc(hidden)] + Hm, + + /// `VA`: Holy See (the) + #[doc(hidden)] + Va, + + /// `HN`: Honduras + #[doc(hidden)] + Hn, + + /// `HK`: Hong Kong + #[doc(hidden)] + Hk, + + /// `HU`: Hungary + #[doc(hidden)] + Hu, + + /// `IS`: Iceland + #[doc(hidden)] + Is, + + /// `IN`: India + #[doc(hidden)] + In, + + /// `ID`: Indonesia + #[doc(hidden)] + Id, + + /// `IR`: Iran (Islamic Republic of) + #[doc(hidden)] + Ir, + + /// `IQ`: Iraq + #[doc(hidden)] + Iq, + + /// `IE`: Ireland + #[doc(hidden)] + Ie, + + /// `IM`: Isle of Man + #[doc(hidden)] + Im, + + /// `IL`: Israel + #[doc(hidden)] + Il, + + /// `IT`: Italy + #[doc(hidden)] + It, + + /// `JM`: Jamaica + #[doc(hidden)] + Jm, + + /// `JP`: Japan + #[doc(hidden)] + Jp, + + /// `JE`: Jersey + #[doc(hidden)] + Je, + + /// `JO`: Jordan + #[doc(hidden)] + Jo, + + /// `KZ`: Kazakhstan + #[doc(hidden)] + Kz, + + /// `KE`: Kenya + #[doc(hidden)] + Ke, + + /// `KI`: Kiribati + #[doc(hidden)] + Ki, + + /// `KP`: Korea (the Democratic People's Republic of) + #[doc(hidden)] + Kp, + + /// `KR`: Korea (the Republic of) + #[doc(hidden)] + Kr, + + /// `KW`: Kuwait + #[doc(hidden)] + Kw, + + /// `KG`: Kyrgyzstan + #[doc(hidden)] + Kg, + + /// `LA`: Lao People's Democratic Republic (the) + #[doc(hidden)] + La, + + /// `LV`: Latvia + #[doc(hidden)] + Lv, + + /// `LB`: Lebanon + #[doc(hidden)] + Lb, + + /// `LS`: Lesotho + #[doc(hidden)] + Ls, + + /// `LR`: Liberia + #[doc(hidden)] + Lr, + + /// `LY`: Libya + #[doc(hidden)] + Ly, + + /// `LI`: Liechtenstein + #[doc(hidden)] + Li, + + /// `LT`: Lithuania + #[doc(hidden)] + Lt, + + /// `LU`: Luxembourg + #[doc(hidden)] + Lu, + + /// `MO`: Macao + #[doc(hidden)] + Mo, + + /// `MG`: Madagascar + #[doc(hidden)] + Mg, + + /// `MW`: Malawi + #[doc(hidden)] + Mw, + + /// `MY`: Malaysia + #[doc(hidden)] + My, + + /// `MV`: Maldives + #[doc(hidden)] + Mv, + + /// `ML`: Mali + #[doc(hidden)] + Ml, + + /// `MT`: Malta + #[doc(hidden)] + Mt, + + /// `MH`: Marshall Islands (the) + #[doc(hidden)] + Mh, + + /// `MQ`: Martinique + #[doc(hidden)] + Mq, + + /// `MR`: Mauritania + #[doc(hidden)] + Mr, + + /// `MU`: Mauritius + #[doc(hidden)] + Mu, + + /// `YT`: Mayotte + #[doc(hidden)] + Yt, + + /// `MX`: Mexico + #[doc(hidden)] + Mx, + + /// `FM`: Micronesia (Federated States of) + #[doc(hidden)] + Fm, + + /// `MD`: Moldova (the Republic of) + #[doc(hidden)] + Md, + + /// `MC`: Monaco + #[doc(hidden)] + Mc, + + /// `MN`: Mongolia + #[doc(hidden)] + Mn, + + /// `ME`: Montenegro + #[doc(hidden)] + Me, + + /// `MS`: Montserrat + #[doc(hidden)] + Ms, + + /// `MA`: Morocco + #[doc(hidden)] + Ma, + + /// `MZ`: Mozambique + #[doc(hidden)] + Mz, + + /// `MM`: Myanmar + #[doc(hidden)] + Mm, + + /// `NA`: Namibia + #[doc(hidden)] + Na, + + /// `NR`: Nauru + #[doc(hidden)] + Nr, + + /// `NP`: Nepal + #[doc(hidden)] + Np, + + /// `NL`: Netherlands (the) + #[doc(hidden)] + Nl, + + /// `NC`: New Caledonia + #[doc(hidden)] + Nc, + + /// `NZ`: New Zealand + #[doc(hidden)] + Nz, + + /// `NI`: Nicaragua + #[doc(hidden)] + Ni, + + /// `NE`: Niger (the) + #[doc(hidden)] + Ne, + + /// `NG`: Nigeria + #[doc(hidden)] + Ng, + + /// `NU`: Niue + #[doc(hidden)] + Nu, + + /// `NF`: Norfolk Island + #[doc(hidden)] + Nf, + + /// `MP`: Northern Mariana Islands (the) + #[doc(hidden)] + Mp, + + /// `NO`: Norway + #[doc(hidden)] + No, + + /// `OM`: Oman + #[doc(hidden)] + Om, + + /// `PK`: Pakistan + #[doc(hidden)] + Pk, + + /// `PW`: Palau + #[doc(hidden)] + Pw, + + /// `PS`: Palestine, State of + #[doc(hidden)] + Ps, + + /// `PA`: Panama + #[doc(hidden)] + Pa, + + /// `PG`: Papua New Guinea + #[doc(hidden)] + Pg, + + /// `PY`: Paraguay + #[doc(hidden)] + Py, + + /// `PE`: Peru + #[doc(hidden)] + Pe, + + /// `PH`: Philippines (the) + #[doc(hidden)] + Ph, + + /// `PN`: Pitcairn + #[doc(hidden)] + Pn, + + /// `PL`: Poland + #[doc(hidden)] + Pl, + + /// `PT`: Portugal + #[doc(hidden)] + Pt, + + /// `PR`: Puerto Rico + #[doc(hidden)] + Pr, + + /// `QA`: Qatar + #[doc(hidden)] + Qa, + + /// `MK`: Republic of North Macedonia + #[doc(hidden)] + Mk, + + /// `RO`: Romania + #[doc(hidden)] + Ro, + + /// `RU`: Russian Federation (the) + #[doc(hidden)] + Ru, + + /// `RW`: Rwanda + #[doc(hidden)] + Rw, + + /// `RE`: Réunion + #[doc(hidden)] + Re, + + /// `BL`: Saint Barthélemy + #[doc(hidden)] + Bl, + + /// `SH`: Saint Helena, Ascension and Tristan da Cunha + #[doc(hidden)] + Sh, + + /// `KN`: Saint Kitts and Nevis + #[doc(hidden)] + Kn, + + /// `LC`: Saint Lucia + #[doc(hidden)] + Lc, + + /// `MF`: Saint Martin (French part) + #[doc(hidden)] + Mf, + + /// `PM`: Saint Pierre and Miquelon + #[doc(hidden)] + Pm, + + /// `VC`: Saint Vincent and the Grenadines + #[doc(hidden)] + Vc, + + /// `WS`: Samoa + #[doc(hidden)] + Ws, + + /// `SM`: San Marino + #[doc(hidden)] + Sm, + + /// `ST`: Sao Tome and Principe + #[doc(hidden)] + St, + + /// `SA`: Saudi Arabia + #[doc(hidden)] + Sa, + + /// `SN`: Senegal + #[doc(hidden)] + Sn, + + /// `RS`: Serbia + #[doc(hidden)] + Rs, + + /// `SC`: Seychelles + #[doc(hidden)] + Sc, + + /// `SL`: Sierra Leone + #[doc(hidden)] + Sl, + + /// `SG`: Singapore + #[doc(hidden)] + Sg, + + /// `SX`: Sint Maarten (Dutch part) + #[doc(hidden)] + Sx, + + /// `SK`: Slovakia + #[doc(hidden)] + Sk, + + /// `SI`: Slovenia + #[doc(hidden)] + Si, + + /// `SB`: Solomon Islands + #[doc(hidden)] + Sb, + + /// `SO`: Somalia + #[doc(hidden)] + So, + + /// `ZA`: South Africa + #[doc(hidden)] + Za, + + /// `GS`: South Georgia and the South Sandwich Islands + #[doc(hidden)] + Gs, + + /// `SS`: South Sudan + #[doc(hidden)] + Ss, + + /// `ES`: Spain + #[doc(hidden)] + Es, + + /// `LK`: Sri Lanka + #[doc(hidden)] + Lk, + + /// `SD`: Sudan (the) + #[doc(hidden)] + Sd, + + /// `SR`: Suriname + #[doc(hidden)] + Sr, + + /// `SJ`: Svalbard and Jan Mayen + #[doc(hidden)] + Sj, + + /// `SE`: Sweden + #[doc(hidden)] + Se, + + /// `CH`: Switzerland + #[doc(hidden)] + Ch, + + /// `SY`: Syrian Arab Republic + #[doc(hidden)] + Sy, + + /// `TW`: Taiwan (Province of China) + #[doc(hidden)] + Tw, + + /// `TJ`: Tajikistan + #[doc(hidden)] + Tj, + + /// `TZ`: Tanzania, United Republic of + #[doc(hidden)] + Tz, + + /// `TH`: Thailand + #[doc(hidden)] + Th, + + /// `TL`: Timor-Leste + #[doc(hidden)] + Tl, + + /// `TG`: Togo + #[doc(hidden)] + Tg, + + /// `TK`: Tokelau + #[doc(hidden)] + Tk, + + /// `TO`: Tonga + #[doc(hidden)] + To, + + /// `TT`: Trinidad and Tobago + #[doc(hidden)] + Tt, + + /// `TN`: Tunisia + #[doc(hidden)] + Tn, + + /// `TR`: Turkey + #[doc(hidden)] + Tr, + + /// `TM`: Turkmenistan + #[doc(hidden)] + Tm, + + /// `TC`: Turks and Caicos Islands (the) + #[doc(hidden)] + Tc, + + /// `TV`: Tuvalu + #[doc(hidden)] + Tv, + + /// `UG`: Uganda + #[doc(hidden)] + Ug, + + /// `UA`: Ukraine + #[doc(hidden)] + Ua, + + /// `AE`: United Arab Emirates (the) + #[doc(hidden)] + Ae, + + /// `GB`: United Kingdom of Great Britain and Northern Ireland (the) + #[doc(hidden)] + Gb, + + /// `UM`: United States Minor Outlying Islands (the) + #[doc(hidden)] + Um, + + /// `US`: United States of America (the) + #[doc(hidden)] + Us, + + /// `UY`: Uruguay + #[doc(hidden)] + Uy, + + /// `UZ`: Uzbekistan + #[doc(hidden)] + Uz, + + /// `VU`: Vanuatu + #[doc(hidden)] + Vu, + + /// `VE`: Venezuela (Bolivarian Republic of) + #[doc(hidden)] + Ve, + + /// `VN`: Viet Nam + #[doc(hidden)] + Vn, + + /// `VG`: Virgin Islands (British) + #[doc(hidden)] + Vg, + + /// `VI`: Virgin Islands (U.S.) + #[doc(hidden)] + Vi, + + /// `WF`: Wallis and Futuna + #[doc(hidden)] + Wf, + + /// `EH`: Western Sahara + #[doc(hidden)] + Eh, + + /// `YE`: Yemen + #[doc(hidden)] + Ye, + + /// `ZM`: Zambia + #[doc(hidden)] + Zm, + + /// `ZW`: Zimbabwe + #[doc(hidden)] + Zw, + + /// `AX`: Åland Islands + #[doc(hidden)] + Ax +} + + +impl Display for Region { + fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str(match self { + // Self is a instance of Region + Self::Any => "**", + + // https://www.iban.com/country-codes + Region::Custom(value) => { + match value { + 4 => "AF", // Afghanistan + 8 => "AL", // Albania + 12 => "DZ", // Algeria + 16 => "AS", // American Samoa + 20 => "AD", // Andorra + 24 => "AO", // Angola + 660 => "AI", // Anguilla + 10 => "AQ", // Antarctica + 28 => "AG", // Antigua and Barbuda + 32 => "AR", // Argentina + 51 => "AM", // Armenia + 533 => "AW", // Aruba + 36 => "AU", // Australia + 40 => "AT", // Austria + 31 => "AZ", // Azerbaijan + 44 => "BS", // Bahamas (the) + 48 => "BH", // Bahrain + 50 => "BD", // Bangladesh + 52 => "BB", // Barbados + 112 => "BY", // Belarus + 56 => "BE", // Belgium + 84 => "BZ", // Belize + 204 => "BJ", // Benin + 60 => "BM", // Besrmuda + 64 => "BT", // Bhutan + 68 => "BO", // Bolivia (Plurinational State of) + 535 => "BQ", // Bonaire, Sint Eustatius and Saba + 70 => "BA", // Bosnia and Herzegovina + 72 => "BW", // Botswana + 74 => "BV", // Bouvet Island + 76 => "BR", // Brazil + 86 => "IO", // British Indian Ocean Territory (the) + 96 => "BN", // Brunei Darussalam + 100 => "BG", // Bulgaria + 854 => "BF", // Burkina Faso + 108 => "BI", // Burundi + 132 => "CV", // Cabo Verde + 116 => "KH", // Cambodia + 120 => "CM", // Cameroon + 124 => "CA", // Canada + 136 => "KY", // Cayman Islands (the) + 140 => "CF", // Central African Republic (the) + 148 => "TD", // Chad + 152 => "CL", // Chile + 156 => "CN", // China + 162 => "CX", // Christmas Island + 166 => "CC", // Cocos (Keeling) Islands (the) + 170 => "CO", // Colombia + 174 => "KM", // Comoros (the) + 180 => "CD", // Congo (the Democratic Republic of the) + 178 => "CG", // Congo (the) + 184 => "CK", // Cook Islands (the) + 188 => "CR", // Costa Rica + 191 => "HR", // Croatia + 192 => "CU", // Cuba + 531 => "CW", // Curaçao + 196 => "CY", // Cyprus + 203 => "CZ", // Czechia + 384 => "CI", // Côte d'Ivoire + 208 => "DK", // Denmark + 262 => "DJ", // Djibouti + 212 => "DM", // Dominica + 214 => "DO", // Dominican Republic (the) + 218 => "EC", // Ecuador + 818 => "EG", // Egypt + 222 => "SV", // El Salvador + 226 => "GQ", // Equatorial Guinea + 232 => "ER", // Eritrea + 233 => "EE", // Estonia + 748 => "SZ", // Eswatini + 231 => "ET", // Ethiopia + 238 => "FK", // Falkland Islands (the) [Malvinas] + 234 => "FO", // Faroe Islands (the) + 242 => "FJ", // Fiji + 246 => "FI", // Finland + 250 => "FR", // France + 254 => "GF", // French Guiana + 258 => "PF", // French Polynesia + 260 => "TF", // French Southern Territories (the) + 266 => "GA", // Gabon + 270 => "GM", // Gambia (the) + 268 => "GE", // Georgia + 276 => "DE", // Germany + 288 => "GH", // Ghana + 292 => "GI", // Gibraltar + 300 => "GR", // Greece + 304 => "GL", // Greenland + 308 => "GD", // Grenada + 312 => "GP", // Guadeloupe + 316 => "GU", // Guam + 320 => "GT", // Guatemala + 831 => "GG", // Guernsey + 324 => "GN", // Guinea + 624 => "GW", // Guinea-Bissau + 328 => "GY", // Guyana + 332 => "HT", // Haiti + 334 => "HM", // Heard Island and McDonald Islands + 336 => "VA", // Holy See (the) + 340 => "HN", // Honduras + 344 => "HK", // Hong Kong + 348 => "HU", // Hungary + 352 => "IS", // Iceland + 356 => "IN", // India + 360 => "ID", // Indonesia + 364 => "IR", // Iran (Islamic Republic of) + 368 => "IQ", // Iraq + 372 => "IE", // Ireland + 833 => "IM", // Isle of Man + 376 => "IL", // Israel + 380 => "IT", // Italy + 388 => "JM", // Jamaica + 392 => "JP", // Japan + 832 => "JE", // Jersey + 400 => "JO", // Jordan + 398 => "KZ", // Kazakhstan + 404 => "KE", // Kenya + 296 => "KI", // Kiribati + 408 => "KP", // Korea (the Democratic People's Republic of) + 410 => "KR", // Korea (the Republic of) + 414 => "KW", // Kuwait + 417 => "KG", // Kyrgyzstan + 418 => "LA", // Lao People's Democratic Republic (the) + 428 => "LV", // Latvia + 422 => "LB", // Lebanon + 426 => "LS", // Lesotho + 430 => "LR", // Liberia + 434 => "LY", // Libya + 438 => "LI", // Liechtenstein + 440 => "LT", // Lithuania + 442 => "LU", // Luxembourg + 446 => "MO", // Macao + 450 => "MG", // Madagascar + 454 => "MW", // Malawi + 458 => "MY", // Malaysia + 462 => "MV", // Maldives + 466 => "ML", // Mali + 470 => "MT", // Malta + 584 => "MH", // Marshall Islands (the) + 474 => "MQ", // Martinique + 478 => "MR", // Mauritania + 480 => "MU", // Mauritius + 175 => "YT", // Mayotte + 484 => "MX", // Mexico + 583 => "FM", // Micronesia (Federated States of) + 498 => "MD", // Moldova (the Republic of) + 492 => "MC", // Monaco + 496 => "MN", // Mongolia + 499 => "ME", // Montenegro + 500 => "MS", // Montserrat + 504 => "MA", // Morocco + 508 => "MZ", // Mozambique + 104 => "MM", // Myanmar + 516 => "NA", // Namibia + 520 => "NR", // Nauru + 524 => "NP", // Nepal + 528 => "NL", // Netherlands (the) + 540 => "NC", // New Caledonia + 554 => "NZ", // New Zealand + 558 => "NI", // Nicaragua + 562 => "NE", // Niger (the) + 566 => "NG", // Nigeria + 570 => "NU", // Niue + 574 => "NF", // Norfolk Island + 580 => "MP", // Northern Mariana Islands (the) + 578 => "NO", // Norway + 512 => "OM", // Oman + 586 => "PK", // Pakistan + 585 => "PW", // Palau + 275 => "PS", // Palestine, State of + 591 => "PA", // Panama + 598 => "PG", // Papua New Guinea + 600 => "PY", // Paraguay + 604 => "PE", // Peru + 608 => "PH", // Philippines (the) + 612 => "PN", // Pitcairn + 616 => "PL", // Poland + 620 => "PT", // Portugal + 630 => "PR", // Puerto Rico + 634 => "QA", // Qatar + 807 => "MK", // Republic of North Macedonia + 642 => "RO", // Romania + 643 => "RU", // Russian Federation (the) + 646 => "RW", // Rwanda + 638 => "RE", // Réunion + 652 => "BL", // Saint Barthélemy + 654 => "SH", // Saint Helena, Ascension and Tristan da Cunha + 659 => "KN", // Saint Kitts and Nevis + 662 => "LC", // Saint Lucia + 663 => "MF", // Saint Martin (French part) + 666 => "PM", // Saint Pierre and Miquelon + 670 => "VC", // Saint Vincent and the Grenadines + 882 => "WS", // Samoa + 674 => "SM", // San Marino + 678 => "ST", // Sao Tome and Principe + 682 => "SA", // Saudi Arabia + 686 => "SN", // Senegal + 688 => "RS", // Serbia + 690 => "SC", // Seychelles + 694 => "SL", // Sierra Leone + 702 => "SG", // Singapore + 534 => "SX", // Sint Maarten (Dutch part) + 703 => "SK", // Slovakia + 705 => "SI", // Slovenia + 90 => "SB", // Solomon Islands + 706 => "SO", // Somalia + 710 => "ZA", // South Africa + 239 => "GS", // South Georgia and the South Sandwich Islands + 728 => "SS", // South Sudan + 724 => "ES", // Spain + 144 => "LK", // Sri Lanka + 729 => "SD", // Sudan (the) + 740 => "SR", // Suriname + 744 => "SJ", // Svalbard and Jan Mayen + 752 => "SE", // Sweden + 756 => "CH", // Switzerland + 760 => "SY", // Syrian Arab Republic + 158 => "TW", // Taiwan (Province of China) + 762 => "TJ", // Tajikistan + 834 => "TZ", // Tanzania, United Republic of + 764 => "TH", // Thailand + 626 => "TL", // Timor-Leste + 768 => "TG", // Togo + 772 => "TK", // Tokelau + 776 => "TO", // Tonga + 780 => "TT", // Trinidad and Tobago + 788 => "TN", // Tunisia + 792 => "TR", // Turkey + 795 => "TM", // Turkmenistan + 796 => "TC", // Turks and Caicos Islands (the) + 798 => "TV", // Tuvalu + 800 => "UG", // Uganda + 804 => "UA", // Ukraine + 784 => "AE", // United Arab Emirates (the) + 826 => "GB", // United Kingdom of Great Britain and Northern Ireland (the) + 581 => "UM", // United States Minor Outlying Islands (the) + 840 => "US", // United States of America (the) + 858 => "UY", // Uruguay + 860 => "UZ", // Uzbekistan + 548 => "VU", // Vanuatu + 862 => "VE", // Venezuela (Bolivarian Republic of) + 704 => "VN", // Viet Nam + 92 => "VG", // Virgin Islands (British) + 850 => "VI", // Virgin Islands (U.S.) + 876 => "WF", // Wallis and Futuna + 732 => "EH", // Western Sahara + 887 => "YE", // Yemen + 894 => "ZM", // Zambia + 716 => "ZW", // Zimbabwe + 248 => "AX", // Åland Islands + _ => "**", // unknown for other cases + } + } + + // https://www.iban.com/country-codes + Self::Af => "AF", // Afghanistan + Self::Al => "AL", // Albania + Self::Dz => "DZ", // Algeria + Self::As => "AS", // American Samoa + Self::Ad => "AD", // Andorra + Self::Ao => "AO", // Angola + Self::Ai => "AI", // Anguilla + Self::Aq => "AQ", // Antarctica + Self::Ag => "AG", // Antigua and Barbuda + Self::Ar => "AR", // Argentina + Self::Am => "AM", // Armenia + Self::Aw => "AW", // Aruba + Self::Au => "AU", // Australia + Self::At => "AT", // Austria + Self::Az => "AZ", // Azerbaijan + Self::Bs => "BS", // Bahamas (the) + Self::Bh => "BH", // Bahrain + Self::Bd => "BD", // Bangladesh + Self::Bb => "BB", // Barbados + Self::By => "BY", // Belarus + Self::Be => "BE", // Belgium + Self::Bz => "BZ", // Belize + Self::Bj => "BJ", // Benin + Self::Bm => "BM", // Bermuda + Self::Bt => "BT", // Bhutan + Self::Bo => "BO", // Bolivia (Plurinational State of) + Self::Bq => "BQ", // Bonaire, Sint Eustatius and Saba + Self::Ba => "BA", // Bosnia and Herzegovina + Self::Bw => "BW", // Botswana + Self::Bv => "BV", // Bouvet Island + Self::Br => "BR", // Brazil + Self::Io => "IO", // British Indian Ocean Territory (the) + Self::Bn => "BN", // Brunei Darussalam + Self::Bg => "BG", // Bulgaria + Self::Bf => "BF", // Burkina Faso + Self::Bi => "BI", // Burundi + Self::Cv => "CV", // Cabo Verde + Self::Kh => "KH", // Cambodia + Self::Cm => "CM", // Cameroon + Self::Ca => "CA", // Canada + Self::Ky => "KY", // Cayman Islands (the) + Self::Cf => "CF", // Central African Republic (the) + Self::Td => "TD", // Chad + Self::Cl => "CL", // Chile + Self::Cn => "CN", // China + Self::Cx => "CX", // Christmas Island + Self::Cc => "CC", // Cocos (Keeling) Islands (the) + Self::Co => "CO", // Colombia + Self::Km => "KM", // Comoros (the) + Self::Cd => "CD", // Congo (the Democratic Republic of the) + Self::Cg => "CG", // Congo (the) + Self::Ck => "CK", // Cook Islands (the) + Self::Cr => "CR", // Costa Rica + Self::Hr => "HR", // Croatia + Self::Cu => "CU", // Cuba + Self::Cw => "CW", // Curaçao + Self::Cy => "CY", // Cyprus + Self::Cz => "CZ", // Czechia + Self::Ci => "CI", // Côte d'Ivoire + Self::Dk => "DK", // Denmark + Self::Dj => "DJ", // Djibouti + Self::Dm => "DM", // Dominica + Self::Do => "DO", // Dominican Republic (the) + Self::Ec => "EC", // Ecuador + Self::Eg => "EG", // Egypt + Self::Sv => "SV", // El Salvador + Self::Gq => "GQ", // Equatorial Guinea + Self::Er => "ER", // Eritrea + Self::Ee => "EE", // Estonia + Self::Sz => "SZ", // Eswatini + Self::Et => "ET", // Ethiopia + Self::Fk => "FK", // Falkland Islands (the) [Malvinas] + Self::Fo => "FO", // Faroe Islands (the) + Self::Fj => "FJ", // Fiji + Self::Fi => "FI", // Finland + Self::Fr => "FR", // France + Self::Gf => "GF", // French Guiana + Self::Pf => "PF", // French Polynesia + Self::Tf => "TF", // French Southern Territories (the) + Self::Ga => "GA", // Gabon + Self::Gm => "GM", // Gambia (the) + Self::Ge => "GE", // Georgia + Self::De => "DE", // Germany + Self::Gh => "GH", // Ghana + Self::Gi => "GI", // Gibraltar + Self::Gr => "GR", // Greece + Self::Gl => "GL", // Greenland + Self::Gd => "GD", // Grenada + Self::Gp => "GP", // Guadeloupe + Self::Gu => "GU", // Guam + Self::Gt => "GT", // Guatemala + Self::Gg => "GG", // Guernsey + Self::Gn => "GN", // Guinea + Self::Gw => "GW", // Guinea-Bissau + Self::Gy => "GY", // Guyana + Self::Ht => "HT", // Haiti + Self::Hm => "HM", // Heard Island and McDonald Islands + Self::Va => "VA", // Holy See (the) + Self::Hn => "HN", // Honduras + Self::Hk => "HK", // Hong Kong + Self::Hu => "HU", // Hungary + Self::Is => "IS", // Iceland + Self::In => "IN", // India + Self::Id => "ID", // Indonesia + Self::Ir => "IR", // Iran (Islamic Republic of) + Self::Iq => "IQ", // Iraq + Self::Ie => "IE", // Ireland + Self::Im => "IM", // Isle of Man + Self::Il => "IL", // Israel + Self::It => "IT", // Italy + Self::Jm => "JM", // Jamaica + Self::Jp => "JP", // Japan + Self::Je => "JE", // Jersey + Self::Jo => "JO", // Jordan + Self::Kz => "KZ", // Kazakhstan + Self::Ke => "KE", // Kenya + Self::Ki => "KI", // Kiribati + Self::Kp => "KP", // Korea (the Democratic People's Republic of) + Self::Kr => "KR", // Korea (the Republic of) + Self::Kw => "KW", // Kuwait + Self::Kg => "KG", // Kyrgyzstan + Self::La => "LA", // Lao People's Democratic Republic (the) + Self::Lv => "LV", // Latvia + Self::Lb => "LB", // Lebanon + Self::Ls => "LS", // Lesotho + Self::Lr => "LR", // Liberia + Self::Ly => "LY", // Libya + Self::Li => "LI", // Liechtenstein + Self::Lt => "LT", // Lithuania + Self::Lu => "LU", // Luxembourg + Self::Mo => "MO", // Macao + Self::Mg => "MG", // Madagascar + Self::Mw => "MW", // Malawi + Self::My => "MY", // Malaysia + Self::Mv => "MV", // Maldives + Self::Ml => "ML", // Mali + Self::Mt => "MT", // Malta + Self::Mh => "MH", // Marshall Islands (the) + Self::Mq => "MQ", // Martinique + Self::Mr => "MR", // Mauritania + Self::Mu => "MU", // Mauritius + Self::Yt => "YT", // Mayotte + Self::Mx => "MX", // Mexico + Self::Fm => "FM", // Micronesia (Federated States of) + Self::Md => "MD", // Moldova (the Republic of) + Self::Mc => "MC", // Monaco + Self::Mn => "MN", // Mongolia + Self::Me => "ME", // Montenegro + Self::Ms => "MS", // Montserrat + Self::Ma => "MA", // Morocco + Self::Mz => "MZ", // Mozambique + Self::Mm => "MM", // Myanmar + Self::Na => "NA", // Namibia + Self::Nr => "NR", // Nauru + Self::Np => "NP", // Nepal + Self::Nl => "NL", // Netherlands (the) + Self::Nc => "NC", // New Caledonia + Self::Nz => "NZ", // New Zealand + Self::Ni => "NI", // Nicaragua + Self::Ne => "NE", // Niger (the) + Self::Ng => "NG", // Nigeria + Self::Nu => "NU", // Niue + Self::Nf => "NF", // Norfolk Island + Self::Mp => "MP", // Northern Mariana Islands (the) + Self::No => "NO", // Norway + Self::Om => "OM", // Oman + Self::Pk => "PK", // Pakistan + Self::Pw => "PW", // Palau + Self::Ps => "PS", // Palestine, State of + Self::Pa => "PA", // Panama + Self::Pg => "PG", // Papua New Guinea + Self::Py => "PY", // Paraguay + Self::Pe => "PE", // Peru + Self::Ph => "PH", // Philippines (the) + Self::Pn => "PN", // Pitcairn + Self::Pl => "PL", // Poland + Self::Pt => "PT", // Portugal + Self::Pr => "PR", // Puerto Rico + Self::Qa => "QA", // Qatar + Self::Mk => "MK", // Republic of North Macedonia + Self::Ro => "RO", // Romania + Self::Ru => "RU", // Russian Federation (the) + Self::Rw => "RW", // Rwanda + Self::Re => "RE", // Réunion + Self::Bl => "BL", // Saint Barthélemy + Self::Sh => "SH", // Saint Helena, Ascension and Tristan da Cunha + Self::Kn => "KN", // Saint Kitts and Nevis + Self::Lc => "LC", // Saint Lucia + Self::Mf => "MF", // Saint Martin (French part) + Self::Pm => "PM", // Saint Pierre and Miquelon + Self::Vc => "VC", // Saint Vincent and the Grenadines + Self::Ws => "WS", // Samoa + Self::Sm => "SM", // San Marino + Self::St => "ST", // Sao Tome and Principe + Self::Sa => "SA", // Saudi Arabia + Self::Sn => "SN", // Senegal + Self::Rs => "RS", // Serbia + Self::Sc => "SC", // Seychelles + Self::Sl => "SL", // Sierra Leone + Self::Sg => "SG", // Singapore + Self::Sx => "SX", // Sint Maarten (Dutch part) + Self::Sk => "SK", // Slovakia + Self::Si => "SI", // Slovenia + Self::Sb => "SB", // Solomon Islands + Self::So => "SO", // Somalia + Self::Za => "ZA", // South Africa + Self::Gs => "GS", // South Georgia and the South Sandwich Islands + Self::Ss => "SS", // South Sudan + Self::Es => "ES", // Spain + Self::Lk => "LK", // Sri Lanka + Self::Sd => "SD", // Sudan (the) + Self::Sr => "SR", // Suriname + Self::Sj => "SJ", // Svalbard and Jan Mayen + Self::Se => "SE", // Sweden + Self::Ch => "CH", // Switzerland + Self::Sy => "SY", // Syrian Arab Republic + Self::Tw => "TW", // Taiwan (Province of China) + Self::Tj => "TJ", // Tajikistan + Self::Tz => "TZ", // Tanzania, United Republic of + Self::Th => "TH", // Thailand + Self::Tl => "TL", // Timor-Leste + Self::Tg => "TG", // Togo + Self::Tk => "TK", // Tokelau + Self::To => "TO", // Tonga + Self::Tt => "TT", // Trinidad and Tobago + Self::Tn => "TN", // Tunisia + Self::Tr => "TR", // Turkey + Self::Tm => "TM", // Turkmenistan + Self::Tc => "TC", // Turks and Caicos Islands (the) + Self::Tv => "TV", // Tuvalu + Self::Ug => "UG", // Uganda + Self::Ua => "UA", // Ukraine + Self::Ae => "AE", // United Arab Emirates (the) + Self::Gb => "GB", // United Kingdom of Great Britain and Northern Ireland (the) + Self::Um => "UM", // United States Minor Outlying Islands (the) + Self::Us => "US", // United States of America (the) + Self::Uy => "UY", // Uruguay + Self::Uz => "UZ", // Uzbekistan + Self::Vu => "VU", // Vanuatu + Self::Ve => "VE", // Venezuela (Bolivarian Republic of) + Self::Vn => "VN", // Viet Nam + Self::Vg => "VG", // Virgin Islands (British) + Self::Vi => "VI", // Virgin Islands (U.S.) + Self::Wf => "WF", // Wallis and Futuna + Self::Eh => "EH", // Western Sahara + Self::Ye => "YE", // Yemen + Self::Zm => "ZM", // Zambia + Self::Zw => "ZW", // Zimbabwe + Self::Ax => "AX", // Åland Islands + }) + } +} + +/// the `function get_language_and_country` returns a String +/// `en_US.UTF-8` : `language_country.text_encoding` +/// the two uppercase letters between the underscore `_` and `.UTF-8` +/// represent the `country` +impl Region { + #[allow(dead_code)] + fn get() -> Self { + let var_env: String = get_language_and_country(); + // output : en_US.UTF-8 + // en : language + // US : country (region) + + // the country is written in uppercase + if var_env.is_empty() { + return Region::Any; + } + + get_region_helper() + } +} + +fn get_region_helper() -> Region { + let var_env: String = get_language_and_country(); + + if var_env.contains("AF") { + return Region::Af; + } else if var_env.contains("AL") { + return Region::Al; + } else if var_env.contains("DZ") { + return Region::Dz; + } else if var_env.contains("AS") { + return Region::As; + } else if var_env.contains("AD") { + return Region::Ad; + } else if var_env.contains("AO") { + return Region::Ao; + } else if var_env.contains("AI") { + return Region::Ai; + } else if var_env.contains("AQ") { + return Region::Aq; + } else if var_env.contains("AG") { + return Region::Ag; + } else if var_env.contains("AR") { + return Region::Ar; + } else if var_env.contains("AM") { + return Region::Am; + } else if var_env.contains("AW") { + return Region::Aw; + } else if var_env.contains("AU") { + return Region::Au; + } else if var_env.contains("AT") { + return Region::At; + } else if var_env.contains("AZ") { + return Region::Az; + } else if var_env.contains("BS") { + return Region::Bs; + } else if var_env.contains("BH") { + return Region::Bh; + } else if var_env.contains("BD") { + return Region::Bd; + } else if var_env.contains("BB") { + return Region::Bb; + } else if var_env.contains("BY") { + return Region::By; + } else if var_env.contains("BE") { + return Region::Be; + } else if var_env.contains("BZ") { + return Region::Bz; + } else if var_env.contains("BJ") { + return Region::Bj; + } else if var_env.contains("BM") { + return Region::Bm; + } else if var_env.contains("BT") { + return Region::Bt; + } else if var_env.contains("BO") { + return Region::Bo; + } else if var_env.contains("BQ") { + return Region::Bq; + } else if var_env.contains("BA") { + return Region::Ba; + } else if var_env.contains("BW") { + return Region::Bw; + } else if var_env.contains("BV") { + return Region::Bv; + } else if var_env.contains("BR") { + return Region::Br; + } else if var_env.contains("IO") { + return Region::Io; + } else if var_env.contains("BN") { + return Region::Bn; + } else if var_env.contains("BG") { + return Region::Bg; + } else if var_env.contains("BF") { + return Region::Bf; + } else if var_env.contains("BI") { + return Region::Bi; + } else if var_env.contains("CV") { + return Region::Cv; + } else if var_env.contains("KH") { + return Region::Kh; + } else if var_env.contains("CM") { + return Region::Cm; + } else if var_env.contains("CA") { + return Region::Ca; + } else if var_env.contains("KY") { + return Region::Ky; + } else if var_env.contains("CF") { + return Region::Cf; + } else if var_env.contains("TD") { + return Region::Td; + } else if var_env.contains("CL") { + return Region::Cl; + } else if var_env.contains("CN") { + return Region::Cn; + } else if var_env.contains("CX") { + return Region::Cx; + } else if var_env.contains("CC") { + return Region::Cc; + } else if var_env.contains("CO") { + return Region::Cd; + } + second_get_region_helper(var_env) +} + +fn second_get_region_helper(var_env: String) -> Region { + if var_env.contains("KM") { + return Region::Km; + } else if var_env.contains("CD") { + return Region::Cd; + } else if var_env.contains("CG") { + return Region::Cg; + } else if var_env.contains("CK") { + return Region::Ck; + } else if var_env.contains("CR") { + return Region::Cr; + } else if var_env.contains("HR") { + return Region::Hr; + } else if var_env.contains("CU") { + return Region::Cu; + } else if var_env.contains("CW") { + return Region::Cw; + } else if var_env.contains("CY") { + return Region::Cy; + } else if var_env.contains("CZ") { + return Region::Cz; + } else if var_env.contains("CI") { + return Region::Ci; + } else if var_env.contains("DK") { + return Region::Dk; + } else if var_env.contains("DJ") { + return Region::Dj; + } else if var_env.contains("DM") { + return Region::Dm; + } else if var_env.contains("DO") { + return Region::Do; + } else if var_env.contains("EC") { + return Region::Ec; + } else if var_env.contains("EG") { + return Region::Eg; + } else if var_env.contains("SV") { + return Region::Sv; + } else if var_env.contains("GQ") { + return Region::Gq; + } else if var_env.contains("ER") { + return Region::Er; + } else if var_env.contains("EE") { + return Region::Ee; + } else if var_env.contains("SZ") { + return Region::Sz; + } else if var_env.contains("ET") { + return Region::Et; + } else if var_env.contains("FK") { + return Region::Fk; + } + + third_get_region_helper(var_env) +} + + fn third_get_region_helper(var_env: String) -> Region { + if var_env.contains("FO") { + return Region::Fo; + } else if var_env.contains("FJ") { + return Region::Fj; + } else if var_env.contains("FI") { + return Region::Fi; + } else if var_env.contains("FR") { + return Region::Fr; + } else if var_env.contains("GF") { + return Region::Gf; + } else if var_env.contains("PF") { + return Region::Pf; + } else if var_env.contains("TF") { + return Region::Tf; + } else if var_env.contains("GA") { + return Region::Ga; + } else if var_env.contains("GM") { + return Region::Gm; + } else if var_env.contains("GE") { + return Region::Ge; + } else if var_env.contains("DE") { + return Region::De; + } else if var_env.contains("GH") { + return Region::Gh; + } else if var_env.contains("GI") { + return Region::Gi; + } else if var_env.contains("GR") { + return Region::Gr; + } else if var_env.contains("GL") { + return Region::Gl; + } else if var_env.contains("GD") { + return Region::Gd; + } else if var_env.contains("GP") { + return Region::Gp; + } else if var_env.contains("GU") { + return Region::Gu; + } else if var_env.contains("GT") { + return Region::Gt; + } else if var_env.contains("GG") { + return Region::Gg; + } else if var_env.contains("GN") { + return Region::Gn; + } else if var_env.contains("GW") { + return Region::Gw; + } else if var_env.contains("GY") { + return Region::Gy; + } else if var_env.contains("HT") { + return Region::Ht; + } + + forth_get_region_helper(var_env) + } + +fn forth_get_region_helper(var_env: String) -> Region { + if var_env.contains("HM") { + return Region::Hm; + } else if var_env.contains("VA") { + return Region::Va; + } else if var_env.contains("HN") { + return Region::Hn; + } else if var_env.contains("HK") { + return Region::Hk; + } else if var_env.contains("HU") { + return Region::Hu; + } else if var_env.contains("IS") { + return Region::Is; + } else if var_env.contains("IN") { + return Region::In; + } else if var_env.contains("ID") { + return Region::Id; + } else if var_env.contains("IR") { + return Region::Ir; + } else if var_env.contains("IQ") { + return Region::Iq; + } else if var_env.contains("IE") { + return Region::Ie; + } else if var_env.contains("IM") { + return Region::Im; + } else if var_env.contains("IL") { + return Region::Il; + } else if var_env.contains("IT") { + return Region::It; + } else if var_env.contains("JM") { + return Region::Jm; + } else if var_env.contains("JP") { + return Region::Jp; + } else if var_env.contains("JE") { + return Region::Je; + } else if var_env.contains("JO") { + return Region::Jo; + } else if var_env.contains("KZ") { + return Region::Kz; + } else if var_env.contains("KE") { + return Region::Ke; + } else if var_env.contains("KI") { + return Region::Ki; + } else if var_env.contains("KP") { + return Region::Kp; + } else if var_env.contains("KR") { + return Region::Kr; + } else if var_env.contains("KW") { + return Region::Kw; + } + + fifth_get_region_helper(var_env) +} + +fn fifth_get_region_helper(var_env: String) -> Region { + if var_env.contains("KG") { + return Region::Kg; + } else if var_env.contains("LA") { + return Region::La; + } else if var_env.contains("LV") { + return Region::Lv; + } else if var_env.contains("LB") { + return Region::Lb; + } else if var_env.contains("LS") { + return Region::Ls; + } else if var_env.contains("LR") { + return Region::Lr; + } else if var_env.contains("LY") { + return Region::Ly; + } else if var_env.contains("LI") { + return Region::Li; + } else if var_env.contains("LT") { + return Region::Lt; + } else if var_env.contains("LU") { + return Region::Lu; + } else if var_env.contains("MO") { + return Region::Mo; + } else if var_env.contains("MG") { + return Region::Mg; + } else if var_env.contains("MW") { + return Region::Mw; + } else if var_env.contains("MY") { + return Region::My; + } else if var_env.contains("MV") { + return Region::Mv; + } else if var_env.contains("ML") { + return Region::Ml; + } else if var_env.contains("MT") { + return Region::Mt; + } else if var_env.contains("MH") { + return Region::Mh; + } else if var_env.contains("MQ") { + return Region::Mq; + } else if var_env.contains("MR") { + return Region::Mr; + } else if var_env.contains("MU") { + return Region::Mu; + } else if var_env.contains("YT") { + return Region::Yt; + } else if var_env.contains("MX") { + return Region::Mx; + } else if var_env.contains("FM") { + return Region::Fm; + } + + sixth_get_region_helper(var_env) +} + +fn sixth_get_region_helper(var_env: String) -> Region { + if var_env.contains("MD") { + return Region::Md; + } else if var_env.contains("MC") { + return Region::Mc; + } else if var_env.contains("MN") { + return Region::Mn; + } else if var_env.contains("ME") { + return Region::Me; + } else if var_env.contains("MS") { + return Region::Ms; + } else if var_env.contains("MA") { + return Region::Ma; + } else if var_env.contains("MZ") { + return Region::Mz; + } else if var_env.contains("MM") { + return Region::Mm; + } else if var_env.contains("NA") { + return Region::Na; + } else if var_env.contains("NR") { + return Region::Nr; + } else if var_env.contains("NP") { + return Region::Np; + } else if var_env.contains("NL") { + return Region::Nl; + } else if var_env.contains("NC") { + return Region::Nc; + } else if var_env.contains("NZ") { + return Region::Nz; + } else if var_env.contains("NI") { + return Region::Ni; + } else if var_env.contains("NE") { + return Region::Ne; + } else if var_env.contains("NG") { + return Region::Ng; + } else if var_env.contains("NU") { + return Region::Nu; + } else if var_env.contains("NF") { + return Region::Nf; + } else if var_env.contains("MP") { + return Region::Mp; + } else if var_env.contains("NO") { + return Region::No; + } else if var_env.contains("OM") { + return Region::Om; + } else if var_env.contains("PK") { + return Region::Pk; + } else if var_env.contains("PW") { + return Region::Pw; + } + + seventh_get_region_helper(var_env) +} + + +fn seventh_get_region_helper(var_env: String) -> Region { + if var_env.contains("PS") { + return Region::Ps; + } else if var_env.contains("PA") { + return Region::Pa; + } else if var_env.contains("PG") { + return Region::Pg; + } else if var_env.contains("PY") { + return Region::Py; + } else if var_env.contains("PE") { + return Region::Pe; + } else if var_env.contains("PH") { + return Region::Ph; + } else if var_env.contains("PN") { + return Region::Pn; + } else if var_env.contains("PL") { + return Region::Pl; + } else if var_env.contains("PT") { + return Region::Pt; + } else if var_env.contains("PR") { + return Region::Pr; + } else if var_env.contains("QA") { + return Region::Qa; + } else if var_env.contains("MK") { + return Region::Mk; + } else if var_env.contains("RO") { + return Region::Ro; + } else if var_env.contains("RU") { + return Region::Ru; + } else if var_env.contains("RW") { + return Region::Rw; + } else if var_env.contains("RE") { + return Region::Re; + } else if var_env.contains("BL") { + return Region::Bl; + } else if var_env.contains("SH") { + return Region::Sh; + } else if var_env.contains("KN") { + return Region::Kn; + } else if var_env.contains("LC") { + return Region::Lc; + } else if var_env.contains("MF") { + return Region::Mf; + } else if var_env.contains("PM") { + return Region::Pm; + } else if var_env.contains("VC") { + return Region::Vc; + } else if var_env.contains("WS") { + return Region::Ws; + } + + eight_get_region_helper(var_env) +} + +fn eight_get_region_helper(var_env: String) -> Region { + if var_env.contains("SM") { + return Region::Sm; + } else if var_env.contains("ST") { + return Region::St; + } else if var_env.contains("SA") { + return Region::Sa; + } else if var_env.contains("SN") { + return Region::Sn; + } else if var_env.contains("RS") { + return Region::Rs; + } else if var_env.contains("SC") { + return Region::Sc; + } else if var_env.contains("SL") { + return Region::Sl; + } else if var_env.contains("SG") { + return Region::Sg; + } else if var_env.contains("SX") { + return Region::Sx; + } else if var_env.contains("SK") { + return Region::Sk; + } else if var_env.contains("SI") { + return Region::Si; + } else if var_env.contains("SB") { + return Region::Sb; + } else if var_env.contains("SO") { + return Region::So; + } else if var_env.contains("ZA") { + return Region::Za; + } else if var_env.contains("GS") { + return Region::Gs; + } else if var_env.contains("SS") { + return Region::Ss; + } else if var_env.contains("ES") { + return Region::Es; + } else if var_env.contains("LK") { + return Region::Lk; + } else if var_env.contains("SD") { + return Region::Sd; + } else if var_env.contains("SR") { + return Region::Sr; + } else if var_env.contains("SJ") { + return Region::Sj; + } else if var_env.contains("SE") { + return Region::Se; + } else if var_env.contains("CH") { + return Region::Ch; + } else if var_env.contains("SY") { + return Region::Sy; + } + + ninth_get_region_helper(var_env) +} + +fn ninth_get_region_helper(var_env: String) -> Region { + if var_env.contains("TW") { + return Region::Tw; + } else if var_env.contains("TJ") { + return Region::Tj; + } else if var_env.contains("TZ") { + return Region::Tz; + } else if var_env.contains("TH") { + return Region::Th; + } else if var_env.contains("TL") { + return Region::Tl; + } else if var_env.contains("TG") { + return Region::Tg; + } else if var_env.contains("TK") { + return Region::Tk; + } else if var_env.contains("TO") { + return Region::To; + } else if var_env.contains("TT") { + return Region::Tt; + } else if var_env.contains("TN") { + return Region::Tn; + } else if var_env.contains("TR") { + return Region::Tr; + } else if var_env.contains("TM") { + return Region::Tm; + } else if var_env.contains("TC") { + return Region::Tc; + } else if var_env.contains("TV") { + return Region::Tv; + } else if var_env.contains("UG") { + return Region::Ug; + } else if var_env.contains("UA") { + return Region::Ua; + } else if var_env.contains("AE") { + return Region::Ae; + } else if var_env.contains("GB") { + return Region::Gb; + } else if var_env.contains("UM") { + return Region::Um; + } else if var_env.contains("US") { + return Region::Us; + } else if var_env.contains("UY") { + return Region::Uy; + } else if var_env.contains("UZ") { + return Region::Uz; + } else if var_env.contains("VU") { + return Region::Vu; + } else if var_env.contains("VE") { + return Region::Ve; + } else if var_env.contains("VN") { + return Region::Vn; + } else if var_env.contains("VG") { + return Region::Vg; + } else if var_env.contains("VI") { + return Region::Vi; + } else if var_env.contains("WF") { + return Region::Wf; + } else if var_env.contains("EH") { + return Region::Eh; + } else if var_env.contains("YE") { + return Region::Ye; + } else if var_env.contains("ZM") { + return Region::Zm; + } else if var_env.contains("ZW") { + return Region::Zw; + } else if var_env.contains("AX") { + return Region::Ax; + } + Region::Any +} + +/// A spoken language +/// +/// Use [`ToString::to_string()`] to convert to string of two letter lowercase +/// language code followed and underscore and uppercase region code (example: +/// `en_US`). +/// +/// Uses +#[non_exhaustive] +#[derive(Clone, Eq, PartialEq, Debug)] +// #[allow(variant_size_differences)] +pub enum Language { + #[doc(hidden)] + __(Box), + + /// `ab`: Abkhazian + #[doc(hidden)] + Ab(Region), + + /// `aa`: Afar + #[doc(hidden)] + Aa(Region), + + /// `AF`: Afrikaans + #[doc(hidden)] + Af(Region), + + /// `SQ`: Albanian + #[doc(hidden)] + Sq(Region), + + /// `AM`: Amharic + #[doc(hidden)] + Am(Region), + + /// `AR`: Arabic + #[doc(hidden)] + Ar(Region), + + /// `HY`: Armenian + #[doc(hidden)] + Hy(Region), + + /// `AS`: Assamese + #[doc(hidden)] + As(Region), + + /// `AY`: Aymara + #[doc(hidden)] + Ay(Region), + + /// `AZ`: Azerbaijani + #[doc(hidden)] + Az(Region), + + /// `BA`: Bashkir + #[doc(hidden)] + Ba(Region), + + /// `EU`: Basque + #[doc(hidden)] + Eu(Region), + + /// `bn`: Bengali, Bangla + #[doc(hidden)] + Bn(Region), + + /// `dz`: Bhutani + #[doc(hidden)] + Dz(Region), + + /// `bh`: Bihari + #[doc(hidden)] + Bh(Region), + + /// `bi`: Bislama + #[doc(hidden)] + Bi(Region), + + /// `br`: Breton + #[doc(hidden)] + Br(Region), + + /// `bg`: Bulgarian + #[doc(hidden)] + Bg(Region), + + /// `my`: Burmese + #[doc(hidden)] + My(Region), + + /// `be`: Byelorussian + #[doc(hidden)] + Be(Region), + + /// `km`: Cambodian + #[doc(hidden)] + Km(Region), + + /// `ca`: Catalan + #[doc(hidden)] + Ca(Region), + + /// `zh`: Chinese + #[doc(hidden)] + Zh(Region), + + /// `co`: Corsican + #[doc(hidden)] + Co(Region), + + /// `hr`: Croatian + #[doc(hidden)] + Hr(Region), + + /// `CS`: Czech + #[doc(hidden)] + Cs(Region), + + /// `DA`: Danish + #[doc(hidden)] + Da(Region), + + /// `nl`: Dutch + #[doc(hidden)] + Nl(Region), + + /// `en`: English, American + #[doc(hidden)] + En(Region), + + /// `EO`: Esperanto + #[doc(hidden)] + Eo(Region), + + /// `Et`: Estonian + #[doc(hidden)] + Et(Region), + + /// `Fo`: Faeroese + #[doc(hidden)] + Fo(Region), + + /// `FJ`: Fiji + #[doc(hidden)] + Fj(Region), + + /// `FI`: Finnish + #[doc(hidden)] + Fi(Region), + + /// `FR`: French + #[doc(hidden)] + Fr(Region), + + /// `fy`: Frisian + #[doc(hidden)] + Fy(Region), + + /// `gd`: Gaelic (Scots Gaelic) + #[doc(hidden)] + Gd(Region), + + /// `GL`: Galician + #[doc(hidden)] + Gl(Region), + + /// `KA`: Georgian + #[doc(hidden)] + Ka(Region), + + /// `DE`: German + #[doc(hidden)] + De(Region), + + /// `EL`: Greek + #[doc(hidden)] + El(Region), + + /// `KL`: Greenlandic + #[doc(hidden)] + Kl(Region), + + /// `GN`: Guarani + #[doc(hidden)] + Gn(Region), + + /// `GU`: Gujarati + #[doc(hidden)] + Gu(Region), + + /// `HA`: Hausa + #[doc(hidden)] + Ha(Region), + + /// `IW`: Hebrew + #[doc(hidden)] + Iw(Region), + + /// `HI`: Hindi + #[doc(hidden)] + Hi(Region), + + /// `HU`: Hungarian + #[doc(hidden)] + Hu(Region), + + /// `IS`: Icelandic + #[doc(hidden)] + Is(Region), + + /// `IN`: Indonesian + #[doc(hidden)] + In(Region), + + /// `IA`: Interlingua + #[doc(hidden)] + Ia(Region), + + /// `IE`: Interlingue + #[doc(hidden)] + Ie(Region), + + /// `IK`: Inupiak + #[doc(hidden)] + Ik(Region), + + /// `GA`: Irish + #[doc(hidden)] + Ga(Region), + + /// `IT`: Italian + #[doc(hidden)] + It(Region), + + /// `JA`: Japanese + #[doc(hidden)] + Ja(Region), + + /// `JW`: Javanese + #[doc(hidden)] + Jw(Region), + + /// `KN`: Kannada + #[doc(hidden)] + Kn(Region), + + /// `KS`: Kashmiri + #[doc(hidden)] + Ks(Region), + + /// `KK`: Kazakh + #[doc(hidden)] + Kk(Region), + + /// `RW`: Kinyarwanda + #[doc(hidden)] + Rw(Region), + + /// `KY`: Kirghiz + #[doc(hidden)] + Ky(Region), + + /// `RN`: Kirundi + #[doc(hidden)] + Rn(Region), + + /// `KO`: Korean + #[doc(hidden)] + Ko(Region), + + /// `ku`: Kurdish + #[doc(hidden)] + Ku(Region), + + /// `lo`: Laothian + #[doc(hidden)] + Lo(Region), + + /// `LA`: Latin + #[doc(hidden)] + La(Region), + + /// `lv`: Latvian, Lettish + #[doc(hidden)] + Lv(Region), + + /// `ln`: Lingala + #[doc(hidden)] + Ln(Region), + + /// `lt`: Lithuanian + #[doc(hidden)] + Lt(Region), + + /// `mk`: Macedonian + #[doc(hidden)] + Mk(Region), + + /// `mg`: Malagasy + #[doc(hidden)] + Mg(Region), + + /// `ms`: Malay + #[doc(hidden)] + Ms(Region), + + /// `ml`: Malayalam + #[doc(hidden)] + Ml(Region), + + /// `mt`: Maltese + #[doc(hidden)] + Mt(Region), + + /// `mi`: Maori + #[doc(hidden)] + Mi(Region), + + /// `mr`: Marathi + #[doc(hidden)] + Mr(Region), + + /// `mo`: Moldavian + #[doc(hidden)] + Mo(Region), + + /// `mn`: Mongolian + #[doc(hidden)] + Mn(Region), + + /// `na`: Nauru + #[doc(hidden)] + Na(Region), + + /// `ne`: Nepali + #[doc(hidden)] + Ne(Region), + + /// `no`: Norwegian + #[doc(hidden)] + No(Region), + + /// `oc`: Occitan + #[doc(hidden)] + Oc(Region), + + /// `or`: Oriya + #[doc(hidden)] + Or(Region), + + /// `om`: Oromo, Afan + #[doc(hidden)] + Om(Region), + + /// `ps`: Pashto, Pushto + #[doc(hidden)] + Ps(Region), + + /// `fa`: Persian + #[doc(hidden)] + Fa(Region), + + /// `pl`: Polish + #[doc(hidden)] + Pl(Region), + + /// `pt`: Portuguese + #[doc(hidden)] + Pt(Region), + + /// `pa`: Punjabi + #[doc(hidden)] + Pa(Region), + + /// `qu`: Quechua + #[doc(hidden)] + Qu(Region), + + /// `rm`: Rhaeto-Romance + #[doc(hidden)] + Rm(Region), + + /// `ro`: Romanian + #[doc(hidden)] + Ro(Region), + + /// `ru`: Russian + #[doc(hidden)] + Ru(Region), + + /// `sm`: Samoan + #[doc(hidden)] + Sm(Region), + + /// `SG`: Sangro + #[doc(hidden)] + Sg(Region), + + /// `sa`: Sanskrit + #[doc(hidden)] + Sa(Region), + + /// `sr`: Serbian + #[doc(hidden)] + Sr(Region), + + /// `sh`: Serbo-Croatian + #[doc(hidden)] + Sh(Region), + + /// `st`: Sesotho + #[doc(hidden)] + St(Region), + + /// `tn`: Setswana + #[doc(hidden)] + Tn(Region), + + /// `sn`: Shona + #[doc(hidden)] + Sn(Region), + + /// `sd`: Sindhi + #[doc(hidden)] + Sd(Region), + + /// `si`: Singhalese + #[doc(hidden)] + Si(Region), + + /// `ss`: Siswati + #[doc(hidden)] + Ss(Region), + + /// `sk`: Slovak + #[doc(hidden)] + Sk(Region), + + /// `sl`: Slovenian + #[doc(hidden)] + Sl(Region), + + /// `so`: Somali + #[doc(hidden)] + So(Region), + + /// `es`: Spanish + #[doc(hidden)] + Es(Region), + + /// `su`: Sudanese + #[doc(hidden)] + Su(Region), + + /// `sw`: Swahili + #[doc(hidden)] + Sw(Region), + + /// `sv`: Swedish + #[doc(hidden)] + Sv(Region), + + /// `tl`: Tagalog + #[doc(hidden)] + Tl(Region), + + /// `tg`: Tajik + #[doc(hidden)] + Tg(Region), + + /// `ta`: Tamil + #[doc(hidden)] + Ta(Region), + + /// `tt`: Tatar + #[doc(hidden)] + Tt(Region), + + /// `te`: Tegulu + #[doc(hidden)] + Te(Region), + + /// `th`: Thai + #[doc(hidden)] + Th(Region), + + /// `bo`: Tibetan + #[doc(hidden)] + Bo(Region), + + /// `ti`: Tigrinya #[doc(hidden)] - Us, -} + Ti(Region), -impl Display for Region { - fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { - f.write_str(match self { - Self::Any => "**", - Self::Us => "US", - }) - } -} + /// `to`: Tonga + #[doc(hidden)] + To(Region), -/// A spoken language -/// -/// Use [`ToString::to_string()`] to convert to string of two letter lowercase -/// language code followed and underscore and uppercase region code (example: -/// `en_US`). -/// -/// Uses -#[non_exhaustive] -#[derive(Clone, Eq, PartialEq, Debug)] -// #[allow(variant_size_differences)] -pub enum Language { + /// `ts`: Tsonga #[doc(hidden)] - __(Box), - /// `en`: English + Ts(Region), + + /// `tr`: Turkish #[doc(hidden)] - En(Region), - /// `es`: Spanish + Tr(Region), + + /// `tk`: Turkmen #[doc(hidden)] - Es(Region), + Tk(Region), + + /// `tw`: Twi + #[doc(hidden)] + Tw(Region), + + /// `uk`: Ukrainian + #[doc(hidden)] + Uk(Region), + + /// `ur`: Urdu + #[doc(hidden)] + Ur(Region), + + /// `uz`: Uzbek + #[doc(hidden)] + Uz(Region), + + /// `Vi`: Vietnamese + #[doc(hidden)] + Vi(Region), + + /// `vo`: Volapuk + #[doc(hidden)] + Vo(Region), + + /// `cy`: Welsh + #[doc(hidden)] + Cy(Region), + + /// `wo`: Wolof + #[doc(hidden)] + Wo(Region), + + /// `Xh`: Xhosa + #[doc(hidden)] + Xh(Region), + + /// `ji`: Yiddish + #[doc(hidden)] + Ji(Region), + + /// `yo`: Yoruba + #[doc(hidden)] + Yo(Region), + + /// `zu`: Zulu + #[doc(hidden)] + Zu(Region), + } + impl Language { /// Retrieve the region code for this language dialect. pub fn region(&self) -> Region { match self { Self::__(_) => Region::Any, - Self::En(region) | Self::Es(region) => *region, + Self::Ab(region) => *region, // Abkhazian AB + Self::Aa(region) => *region, // Afar AA + Self::Af(region) => *region, // Afrikaans AF + Self::Sq(region) => *region, // Albanian SQ + Self::Am(region) => *region, // Amharic AM + Self::Ar(region) => *region, // Arabic AR + Self::Hy(region) => *region, // Armenian HY + Self::As(region) => *region, // Assamese AS + Self::Ay(region) => *region, // Aymara AY + Self::Az(region) => *region, // Azerbaijani AZ + Self::Ba(region) => *region, // Bashkir BA + Self::Eu(region) => *region, // Basque EU + Self::Bn(region) => *region, // Bengali, Bangla BN + Self::Dz(region) => *region, // Bhutani DZ + Self::Bh(region) => *region, // Bihari BH + Self::Bi(region) => *region, // Bislama BI + Self::Br(region) => *region, // Breton BR + Self::Bg(region) => *region, // Bulgarian BG + Self::My(region) => *region, // Burmese MY + Self::Be(region) => *region, // Byelorussian BE + Self::Km(region) => *region, // Cambodian KM + Self::Ca(region) => *region, // Catalan CA + Self::Zh(region) => *region, // Chinese ZH + Self::Co(region) => *region, // Corsican CO + Self::Hr(region) => *region, // Croatian HR + Self::Cs(region) => *region, // Czech CS + Self::Da(region) => *region, // Danish DA + Self::Nl(region) => *region, // Dutch NL + Self::En(region) => *region, // English, American EN + Self::Eo(region) => *region, // Esperanto EO + Self::Et(region) => *region, // Estonian ET + Self::Fo(region) => *region, // Faeroese FO + Self::Fj(region) => *region, // Fiji FJ + Self::Fi(region) => *region, // Finnish FI + Self::Fr(region) => *region, // French FR + Self::Fy(region) => *region, // Frisian FY + Self::Gd(region) => *region, // Gaelic (Scots Gaelic) GD + Self::Gl(region) => *region, // Galician GL + Self::Ka(region) => *region, // Georgian KA + Self::De(region) => *region, // German DE + Self::El(region) => *region, // Greek EL + Self::Kl(region) => *region, // Greenlandic KL + Self::Gn(region) => *region, // Guarani GN + Self::Gu(region) => *region, // Gujarati GU + Self::Ha(region) => *region, // Hausa HA + Self::Iw(region) => *region, // Hebrew IW + Self::Hi(region) => *region, // Hindi HI + Self::Hu(region) => *region, // Hungarian HU + Self::Is(region) => *region, // Icelandic IS + Self::In(region) => *region, // Indonesian IN + Self::Ia(region) => *region, // Interlingua IA + Self::Ie(region) => *region, // Interlingue IE + Self::Ik(region) => *region, // Inupiak IK + Self::Ga(region) => *region, // Irish GA + Self::It(region) => *region, // Italian IT + Self::Ja(region) => *region, // Japanese JA + Self::Jw(region) => *region, // Javanese JW + Self::Kn(region) => *region, // Kannada KN + Self::Ks(region) => *region, // Kashmiri KS + Self::Kk(region) => *region, // Kazakh KK + Self::Rw(region) => *region, // Kinyarwanda RW + Self::Ky(region) => *region, // Kirghiz KY + Self::Rn(region) => *region, // Kirundi RN + Self::Ko(region) => *region, // Korean KO + Self::Ku(region) => *region, // Kurdish KU + Self::Lo(region) => *region, // Laothian LO + Self::La(region) => *region, // Latin LA + Self::Lv(region) => *region, // Latvian, Lettish LV + Self::Ln(region) => *region, // Lingala LN + Self::Lt(region) => *region, // Lithuanian LT + Self::Mk(region) => *region, // Macedonian MK + Self::Mg(region) => *region, // Malagasy MG + Self::Ms(region) => *region, // Malay MS + Self::Ml(region) => *region, // Malayalam ML + Self::Mt(region) => *region, // Maltese MT + Self::Mi(region) => *region, // Maori MI + Self::Mr(region) => *region, // Marathi MR + Self::Mo(region) => *region, // Moldavian MO + Self::Mn(region) => *region, // Mongolian MN + Self::Na(region) => *region, // Nauru NA + Self::Ne(region) => *region, // Nepali NE + Self::No(region) => *region, // Norwegian NO + Self::Oc(region) => *region, // Occitan OC + Self::Or(region) => *region, // Oriya OR + Self::Om(region) => *region, // Oromo, Afan OM + Self::Ps(region) => *region, // Pashto, Pushto PS + Self::Fa(region) => *region, // Persian FA + Self::Pl(region) => *region, // Polish PL + Self::Pt(region) => *region, // Portuguese PT + Self::Pa(region) => *region, // Punjabi PA + Self::Qu(region) => *region, // Quechua QU + Self::Rm(region) => *region, // Rhaeto-Romance RM + Self::Ro(region) => *region, // Romanian RO + Self::Ru(region) => *region, // Russian RU + Self::Sm(region) => *region, // Samoan SM + Self::Sg(region) => *region, // Sangro SG + Self::Sa(region) => *region, // Sanskrit SA + Self::Sr(region) => *region, // Serbian SR + Self::Sh(region) => *region, // Serbo-Croatian SH + Self::St(region) => *region, // Sesotho ST + Self::Tn(region) => *region, // Setswana TN + Self::Sn(region) => *region, // Shona SN + Self::Sd(region) => *region, // Sindhi SD + Self::Si(region) => *region, // Singhalese SI + Self::Ss(region) => *region, // Siswati SS + Self::Sk(region) => *region, // Slovak SK + Self::Sl(region) => *region, // Slovenian SL + Self::So(region) => *region, // Somali SO + Self::Es(region) => *region, // Spanish ES + Self::Su(region) => *region, // Sudanese SU + Self::Sw(region) => *region, // Swahili SW + Self::Sv(region) => *region, // Swedish SV + Self::Tl(region) => *region, // Tagalog TL + Self::Tg(region) => *region, // Tajik TG + Self::Ta(region) => *region, // Tamil TA + Self::Tt(region) => *region, // Tatar TT + Self::Te(region) => *region, // Tegulu TE + Self::Th(region) => *region, // Thai TH + Self::Bo(region) => *region, // Tibetan BO + Self::Ti(region) => *region, // Tigrinya TI + Self::To(region) => *region, // Tonga TO + Self::Ts(region) => *region, // Tsonga TS + Self::Tr(region) => *region, // Turkish TR + Self::Tk(region) => *region, // Turkmen TK + Self::Tw(region) => *region, // Twi TW + Self::Uk(region) => *region, // Ukrainian UK + Self::Ur(region) => *region, // Urdu UR + Self::Uz(region) => *region, // Uzbek UZ + Self::Vi(region) => *region, // Vietnamese VI + Self::Vo(region) => *region, // Volapuk VO + Self::Cy(region) => *region, // Welsh CY + Self::Wo(region) => *region, // Wolof WO + Self::Xh(region) => *region, // Xhosa XH + Self::Ji(region) => *region, // Yiddish JI + Self::Yo(region) => *region, // Yoruba YO + Self::Zu(region) => *region, // Zulu ZU } } } impl Display for Language { + fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { match self { Self::__(code) => f.write_str(code.as_str()), - Self::En(region) => { - if *region != Region::Any { - f.write_str("en_")?; - ::fmt(region, f) - } else { - f.write_str("en") - } - } - Self::Es(region) => { - if *region != Region::Any { - f.write_str("es_")?; - ::fmt(region, f) - } else { - f.write_str("es") - } - } + + // Abkhazian AB + Self::Ab(region) => language_display_helper(*region, f, "ab".to_string()), + + // Afar AA + Self::Aa(region) => language_display_helper(*region, f, "aa".to_string()), + + // Afrikaans AF + Self::Af(region) => language_display_helper(*region, f, "af".to_string()), + + // Albanian SQ + Self::Sq(region) => language_display_helper(*region, f, "sq".to_string()), + + // Amharic AM + Self::Am(region) => language_display_helper(*region, f, "am".to_string()), + + // Arabic AR + Self::Ar(region) => language_display_helper(*region, f, "ar".to_string()), + + // Armenian HY + Self::Hy(region) => language_display_helper(*region, f, "hy".to_string()), + + // Assamese AS + Self::As(region) => language_display_helper(*region, f, "as".to_string()), + + // Aymara AY + Self::Ay(region) => language_display_helper(*region, f, "ay".to_string()), + + // Azerbaijani AZ + Self::Az(region) => language_display_helper(*region, f, "az".to_string()), + + // Bashkir BA + Self::Ba(region) => language_display_helper(*region, f, "ba".to_string()), + + // Basque EU + Self::Eu(region) => language_display_helper(*region, f, "eu".to_string()), + + // Bengali, Bangla BN + Self::Bn(region) => language_display_helper(*region, f, "bn".to_string()), + + // Bhutani DZ + Self::Dz(region) => language_display_helper(*region, f, "dz".to_string()), + + // Bihari BH + Self::Bh(region) => language_display_helper(*region, f, "bh".to_string()), + + // Bislama BI + Self::Bi(region) => language_display_helper(*region, f, "bi".to_string()), + + // Breton BR + Self::Br(region) => language_display_helper(*region, f, "br".to_string()), + + // Bulgarian BG + Self::Bg(region) => language_display_helper(*region, f, "bg".to_string()), + + // Burmese MY + Self::My(region) => language_display_helper(*region, f, "my".to_string()), + + // Byelorussian BE + Self::Be(region) => language_display_helper(*region, f, "be".to_string()), + + // Cambodian KM + Self::Km(region) => language_display_helper(*region, f, "km".to_string()), + + // Catalan CA + Self::Ca(region) => language_display_helper(*region, f, "ca".to_string()), + + // Chinese ZH + Self::Zh(region) => language_display_helper(*region, f, "zh".to_string()), + + // Corsican CO + Self::Co(region) => language_display_helper(*region, f, "co".to_string()), + + // Croatian HR + Self::Hr(region) => language_display_helper(*region, f, "hr".to_string()), + + // Czech CS + Self::Cs(region) => language_display_helper(*region, f, "cs".to_string()), + + // Danish DA + Self::Da(region) => language_display_helper(*region, f, "da".to_string()), + + // Dutch NL + Self::Nl(region) => language_display_helper(*region, f, "nl".to_string()), + + // English, American EN + Self::En(region) => language_display_helper(*region, f, "en".to_string()), + + // Esperanto EO + Self::Eo(region) => language_display_helper(*region, f, "eo".to_string()), + + // Estonian ET + Self::Et(region) => language_display_helper(*region, f, "et".to_string()), + + // Faeroese FO + Self::Fo(region) => language_display_helper(*region, f, "fo".to_string()), + + // Fiji FJ + Self::Fj(region) => language_display_helper(*region, f, "fj".to_string()), + + // Finnish FI + Self::Fi(region) => language_display_helper(*region, f, "fi".to_string()), + + // French FR + Self::Fr(region) => language_display_helper(*region, f, "fr".to_string()), + + // Frisian FY + Self::Fy(region) => language_display_helper(*region, f, "fy".to_string()), + + // Gaelic (Scots Gaelic) GD + Self::Gd(region) => language_display_helper(*region, f, "gd".to_string()), + + // Galician GL + Self::Gl(region) => language_display_helper(*region, f, "gl".to_string()), + + // Georgian KA + Self::Ka(region) => language_display_helper(*region, f, "ka".to_string()), + + // German DE + Self::De(region) => language_display_helper(*region, f, "de".to_string()), + + // Greek EL + Self::El(region) => language_display_helper(*region, f, "el".to_string()), + + // Greenlandic KL + Self::Kl(region) => language_display_helper(*region, f, "kl".to_string()), + + // Guarani GN + Self::Gn(region) => language_display_helper(*region, f, "gn".to_string()), + + // Gujarati GU + Self::Gu(region) => language_display_helper(*region, f, "gu".to_string()), + + // Hausa HA + Self::Ha(region) => language_display_helper(*region, f, "ha".to_string()), + + // Hebrew IW + Self::Iw(region) => language_display_helper(*region, f, "iw".to_string()), + + // Hindi HI + Self::Hi(region) => language_display_helper(*region, f, "hi".to_string()), + + // Hungarian HU + Self::Hu(region) => language_display_helper(*region, f, "hu".to_string()), + + // Icelandic IS + Self::Is(region) => language_display_helper(*region, f, "is".to_string()), + + // Indonesian IN + Self::In(region) => language_display_helper(*region, f, "in".to_string()), + + // Interlingua IA + Self::Ia(region) => language_display_helper(*region, f, "ia".to_string()), + + // Interlingue IE + Self::Ie(region) => language_display_helper(*region, f, "ie".to_string()), + + // Inupiak IK + Self::Ik(region) => language_display_helper(*region, f, "ik".to_string()), + + // Irish GA + Self::Ga(region) => language_display_helper(*region, f, "ga".to_string()), + + // Italian IT + Self::It(region) => language_display_helper(*region, f, "it".to_string()), + + // Japanese JA + Self::Ja(region) => language_display_helper(*region, f, "ja".to_string()), + + // Javanese JW + Self::Jw(region) => language_display_helper(*region, f, "jw".to_string()), + + // Kannada KN + Self::Kn(region) => language_display_helper(*region, f, "kn".to_string()), + + // Kashmiri KS + Self::Ks(region) => language_display_helper(*region, f, "ks".to_string()), + + // Kazakh KK + Self::Kk(region) => language_display_helper(*region, f, "kk".to_string()), + + // Kinyarwanda RW + Self::Rw(region) => language_display_helper(*region, f, "rw".to_string()), + + // Kirghiz KY + Self::Ky(region) => language_display_helper(*region, f, "ky".to_string()), + + // Kirundi RN + Self::Rn(region) => language_display_helper(*region, f, "rn".to_string()), + + // Korean KO + Self::Ko(region) => language_display_helper(*region, f, "ko".to_string()), + + // Kurdish KU + Self::Ku(region) => language_display_helper(*region, f, "ku".to_string()), + + // Laothian LO + Self::Lo(region) => language_display_helper(*region, f, "lo".to_string()), + + // Latin LA + Self::La(region) => language_display_helper(*region, f, "la".to_string()), + + // Latvian, Lettish LV + Self::Lv(region) => language_display_helper(*region, f, "lv".to_string()), + + // Lingala LN + Self::Ln(region) => language_display_helper(*region, f, "ln".to_string()), + + // Lithuanian LT + Self::Lt(region) => language_display_helper(*region, f, "lt".to_string()), + + // Macedonian MK + Self::Mk(region) => language_display_helper(*region, f, "mk".to_string()), + + // Malagasy MG + Self::Mg(region) => language_display_helper(*region, f, "mg".to_string()), + + // Malay MS + Self::Ms(region) => language_display_helper(*region, f, "ms".to_string()), + // Malayalam ML + Self::Ml(region) => language_display_helper(*region, f, "ml".to_string()), + + // Maltese MT + Self::Mt(region) => language_display_helper(*region, f, "mt".to_string()), + + // Maori MI + Self::Mi(region) => language_display_helper(*region, f, "mi".to_string()), + + // Marathi MR + Self::Mr(region) => language_display_helper(*region, f, "mr".to_string()), + + // Moldavian MO + Self::Mo(region) => language_display_helper(*region, f, "mo".to_string()), + + // Mongolian MN + Self::Mn(region) => language_display_helper(*region, f, "mn".to_string()), + + // Nauru NA + Self::Na(region) => language_display_helper(*region, f, "na".to_string()), + + // Nepali NE + Self::Ne(region) => language_display_helper(*region, f, "ne".to_string()), + + // Norwegian NO + Self::No(region) => language_display_helper(*region, f, "no".to_string()), + + // Occitan OC + Self::Oc(region) => language_display_helper(*region, f, "oc".to_string()), + + // Oriya OR + Self::Or(region) => language_display_helper(*region, f, "or".to_string()), + + // Oromo, Afan OM + Self::Om(region) => language_display_helper(*region, f, "om".to_string()), + + // Pashto, Pushto PS + Self::Ps(region) => language_display_helper(*region, f, "ps".to_string()), + + // Persian FA + Self::Fa(region) => language_display_helper(*region, f, "fa".to_string()), + + // Polish PL + Self::Pl(region) => language_display_helper(*region, f, "pl".to_string()), + + // Portuguese PT + Self::Pt(region) => language_display_helper(*region, f, "pt".to_string()), + + // Punjabi PA + Self::Pa(region) => language_display_helper(*region, f, "pa".to_string()), + + // Quechua QU + Self::Qu(region) => language_display_helper(*region, f, "qu".to_string()), + + // Rhaeto-Romance RM + Self::Rm(region) => language_display_helper(*region, f, "rm".to_string()), + + // Romanian RO + Self::Ro(region) => language_display_helper(*region, f, "ro".to_string()), + + // Russian RU + Self::Ru(region) => language_display_helper(*region, f, "ru".to_string()), + + // Samoan SM + Self::Sm(region) => language_display_helper(*region, f, "sm".to_string()), + + // Sangro SG + Self::Sg(region) => language_display_helper(*region, f, "sg".to_string()), + + // Sanskrit SA + Self::Sa(region) => language_display_helper(*region, f, "sa".to_string()), + + // Serbian SR + Self::Sr(region) => language_display_helper(*region, f, "sr".to_string()), + + // Serbo-Croatian SH + Self::Sh(region) => language_display_helper(*region, f, "sh".to_string()), + + // Sesotho ST + Self::St(region) => language_display_helper(*region, f, "st".to_string()), + + // Setswana TN + Self::Tn(region) => language_display_helper(*region, f, "tn".to_string()), + + // Shona SN + Self::Sn(region) => language_display_helper(*region, f, "sn".to_string()), + + // Sindhi SD + Self::Sd(region) => language_display_helper(*region, f, "sd".to_string()), + + // Singhalese SI + Self::Si(region) => language_display_helper(*region, f, "si".to_string()), + + // Siswati SS + Self::Ss(region) => language_display_helper(*region, f, "ss".to_string()), + + // Slovak SK + Self::Sk(region) => language_display_helper(*region, f, "sk".to_string()), + + // Slovenian SL + Self::Sl(region) => language_display_helper(*region, f, "sl".to_string()), + + // Somali SO + Self::So(region) => language_display_helper(*region, f, "so".to_string()), + + // Spanish ES + Self::Es(region) => language_display_helper(*region, f, "es".to_string()), + + // Sudanese SU + Self::Su(region) => language_display_helper(*region, f, "su".to_string()), + + // Swahili SW + Self::Sw(region) => language_display_helper(*region, f, "sw".to_string()), + + // Swedish SV + Self::Sv(region) => language_display_helper(*region, f, "sv".to_string()), + + // Tagalog TL + Self::Tl(region) => language_display_helper(*region, f, "tl".to_string()), + + // Tajik TG + Self::Tg(region) => language_display_helper(*region, f, "tg".to_string()), + + // Tamil TA + Self::Ta(region) => language_display_helper(*region, f, "ta".to_string()), + + // Tatar TT + Self::Tt(region) => language_display_helper(*region, f, "tt".to_string()), + + // Tegulu TE + Self::Te(region) => language_display_helper(*region, f, "te".to_string()), + + // Thai TH + Self::Th(region) => language_display_helper(*region, f, "th".to_string()), + + // Tibetan BO + Self::Bo(region) => language_display_helper(*region, f, "bo".to_string()), + + // Tigrinya TI + Self::Ti(region) => language_display_helper(*region, f, "ti".to_string()), + + // Tonga TO + Self::To(region) => language_display_helper(*region, f, "to".to_string()), + + // Tsonga TS + Self::Ts(region) => language_display_helper(*region, f, "ts".to_string()), + + // Turkish TR + Self::Tr(region) => language_display_helper(*region, f, "tr".to_string()), + + // Turkmen TK + Self::Tk(region) => language_display_helper(*region, f, "tk".to_string()), + + // Twi TW + Self::Tw(region) => language_display_helper(*region, f, "tw".to_string()), + + // Ukrainian UK + Self::Uk(region) => language_display_helper(*region, f, "uk".to_string()), + + // Urdu UR + Self::Ur(region) => language_display_helper(*region, f, "ur".to_string()), + + // Uzbek UZ + Self::Uz(region) => language_display_helper(*region, f, "uz".to_string()), + + // Vietnamese VI + Self::Vi(region) => language_display_helper(*region, f, "vi".to_string()), + + // Volapuk VO + Self::Vo(region) => language_display_helper(*region, f, "vo".to_string()), + + // Welsh CY + Self::Cy(region) => language_display_helper(*region, f, "cy".to_string()), + + // Wolof WO + Self::Wo(region) => language_display_helper(*region, f, "wo".to_string()), + + // Xhosa XH + Self::Xh(region) => language_display_helper(*region, f, "xh".to_string()), + + // Yiddish JI + Self::Ji(region) => language_display_helper(*region, f, "ji".to_string()), + + // Yoruba YO + Self::Yo(region) => language_display_helper(*region, f, "yo".to_string()), + + // Zulu ZU + Self::Zu(region) => language_display_helper(*region, f, "zu".to_string()), } } } + +/// the String represents the two letter encoding of the language +fn language_display_helper(region: Region, f: &mut Formatter<'_>, encoding: String) -> fmt::Result { + if region != Region::Any { + let mut display: String = encoding; + display.push('_'); + f.write_str(&display)?; + ::fmt(®ion, f) + } else { + let display: String = encoding; + f.write_str(&display) + } +} + + + + +/// the `function get_language_and_country` returns a String +/// `en_US.UTF-8` : `language_country.textencoding` +/// the two lowercase letters before the underscore `_` +/// represents the `language` +impl Language { + #[allow(dead_code)] + fn get() -> Self { + + // the language is written with two lowercase characters + get_language_helper() + } +} + +fn get_language_helper() -> Language { + let var_env: String = get_language_and_country(); + let region: Region = Region::get(); + + if var_env.contains("ab") { + return Language::Ab(region); + } else if var_env.contains("aa") { + return Language::Aa(region); + } else if var_env.contains("af") { + return Language::Af(region); + } else if var_env.contains("sq") { + return Language::Sq(region); + } else if var_env.contains("am") { + return Language::Am(region); + } else if var_env.contains("ar") { + return Language::Ar(region); + } else if var_env.contains("hy") { + return Language::Hy(region); + } else if var_env.contains("as") { + return Language::As(region); + } else if var_env.contains("ay") { + return Language::Ay(region); + } else if var_env.contains("az") { + return Language::Az(region); + } else if var_env.contains("ba") { + return Language::Ba(region); + } else if var_env.contains("eu") { + return Language::Eu(region); + } else if var_env.contains("bn") { + return Language::Bn(region); + } else if var_env.contains("dz") { + return Language::Dz(region); + } else if var_env.contains("bh") { + return Language::Bh(region); + } else if var_env.contains("bi") { + return Language::Bi(region); + } else if var_env.contains("br") { + return Language::Br(region); + } else if var_env.contains("bg") { + return Language::Bg(region); + } else if var_env.contains("my") { + return Language::My(region); + } else if var_env.contains("be") { + return Language::Be(region); + } else if var_env.contains("km") { + return Language::Km(region); + } else if var_env.contains("ca") { + return Language::Ca(region); + } else if var_env.contains("zh") { + return Language::Zh(region); + } else if var_env.contains("co") { + return Language::Co(region); + } + + second_get_language_helper() +} + +fn second_get_language_helper() -> Language { + let var_env: String = get_language_and_country(); + let region: Region = Region::get(); + + if var_env.contains("hr") { + return Language::Hr(region); + } else if var_env.contains("cs") { + return Language::Cs(region); + } else if var_env.contains("da") { + return Language::Da(region); + } else if var_env.contains("nl") { + return Language::Nl(region); + } else if var_env.contains("en") { + return Language::En(region); + } else if var_env.contains("eo") { + return Language::Eo(region); + } else if var_env.contains("et") { + return Language::Et(region); + } else if var_env.contains("fo") { + return Language::Fo(region); + } else if var_env.contains("fj") { + return Language::Fj(region); + } else if var_env.contains("fi") { + return Language::Fi(region); + } else if var_env.contains("fr") { + return Language::Fr(region); + } else if var_env.contains("fy") { + return Language::Fy(region); + } else if var_env.contains("gd") { + return Language::Gd(region); + } else if var_env.contains("gl") { + return Language::Gl(region); + } else if var_env.contains("ka") { + return Language::Ka(region); + } else if var_env.contains("de") { + return Language::De(region); + } else if var_env.contains("el") { + return Language::El(region); + } else if var_env.contains("kl") { + return Language::Kl(region); + } else if var_env.contains("gn") { + return Language::Gn(region); + } else if var_env.contains("gu") { + return Language::Gu(region); + } else if var_env.contains("ha") { + return Language::Ha(region); + } else if var_env.contains("iw") { + return Language::Iw(region); + } else if var_env.contains("hi") { + return Language::Hi(region); + } else if var_env.contains("hu") { + return Language::Hu(region); + } + + third_get_language_helper() +} + + +fn third_get_language_helper() -> Language { + let var_env: String = get_language_and_country(); + let region: Region = Region::get(); + + if var_env.contains("is") { + return Language::Is(region); + } else if var_env.contains("in") { + return Language::In(region); + } else if var_env.contains("ia") { + return Language::Ia(region); + } else if var_env.contains("ie") { + return Language::Ie(region); + } else if var_env.contains("ik") { + return Language::Ik(region); + } else if var_env.contains("ga") { + return Language::Ga(region); + } else if var_env.contains("it") { + return Language::It(region); + } else if var_env.contains("ja") { + return Language::Ja(region); + } else if var_env.contains("jw") { + return Language::Jw(region); + } else if var_env.contains("kn") { + return Language::Kn(region); + } else if var_env.contains("ks") { + return Language::Ks(region); + } else if var_env.contains("kk") { + return Language::Kk(region); + } else if var_env.contains("rw") { + return Language::Rw(region); + } else if var_env.contains("ky") { + return Language::Ky(region); + } else if var_env.contains("rn") { + return Language::Rn(region); + } else if var_env.contains("ko") { + return Language::Ko(region); + } else if var_env.contains("ku") { + return Language::Ku(region); + } else if var_env.contains("lo") { + return Language::Lo(region); + } else if var_env.contains("la") { + return Language::La(region); + } else if var_env.contains("lv") { + return Language::Lv(region); + } else if var_env.contains("ln") { + return Language::Ln(region); + } else if var_env.contains("lt") { + return Language::Lt(region); + } else if var_env.contains("mk") { + return Language::Mk(region); + } else if var_env.contains("mg") { + return Language::Mg(region); + } + + forth_get_language_helper() +} + + +fn forth_get_language_helper() -> Language { + let var_env: String = get_language_and_country(); + let region: Region = Region::get(); + + if var_env.contains("ms") { + return Language::Ms(region); + } else if var_env.contains("ml") { + return Language::Ml(region); + } else if var_env.contains("mt") { + return Language::Mt(region); + } else if var_env.contains("mi") { + return Language::Mi(region); + } else if var_env.contains("mr") { + return Language::Mr(region); + } else if var_env.contains("mo") { + return Language::Mo(region); + } else if var_env.contains("mn") { + return Language::Mn(region); + } else if var_env.contains("na") { + return Language::Na(region); + } else if var_env.contains("ne") { + return Language::Ne(region); + } else if var_env.contains("no") { + return Language::No(region); + } else if var_env.contains("oc") { + return Language::Oc(region); + } else if var_env.contains("or") { + return Language::Or(region); + } else if var_env.contains("om") { + return Language::Om(region); + } else if var_env.contains("ps") { + return Language::Ps(region); + } else if var_env.contains("fa") { + return Language::Fa(region); + } else if var_env.contains("pl") { + return Language::Pl(region); + } else if var_env.contains("pt") { + return Language::Pt(region); + } else if var_env.contains("pa") { + return Language::Pa(region); + } else if var_env.contains("qu") { + return Language::Qu(region); + } else if var_env.contains("rm") { + return Language::Rm(region); + } else if var_env.contains("ro") { + return Language::Ro(region); + } else if var_env.contains("ru") { + return Language::Ru(region); + } else if var_env.contains("sm") { + return Language::Sm(region); + } else if var_env.contains("sg") { + return Language::Sg(region); + } + + fifth_get_language_helper() +} + + +fn fifth_get_language_helper() -> Language { + let var_env: String = get_language_and_country(); + let region: Region = Region::get(); + + if var_env.contains("sa") { + return Language::Sa(region); + } else if var_env.contains("sr") { + return Language::Sr(region); + } else if var_env.contains("sh") { + return Language::Sh(region); + } else if var_env.contains("st") { + return Language::St(region); + } else if var_env.contains("tn") { + return Language::Tn(region); + } else if var_env.contains("sn") { + return Language::Sn(region); + } else if var_env.contains("sd") { + return Language::Sd(region); + } else if var_env.contains("si") { + return Language::Si(region); + } else if var_env.contains("ss") { + return Language::Ss(region); + } else if var_env.contains("sk") { + return Language::Sk(region); + } else if var_env.contains("sl") { + return Language::Sl(region); + } else if var_env.contains("so") { + return Language::So(region); + } else if var_env.contains("es") { + return Language::Es(region); + } else if var_env.contains("su") { + return Language::Su(region); + } else if var_env.contains("sw") { + return Language::Sw(region); + } else if var_env.contains("sv") { + return Language::Sv(region); + } else if var_env.contains("tl") { + return Language::Tl(region); + } else if var_env.contains("tg") { + return Language::Tg(region); + } else if var_env.contains("ta") { + return Language::Ta(region); + } else if var_env.contains("tt") { + return Language::Tt(region); + } else if var_env.contains("te") { + return Language::Te(region); + } else if var_env.contains("th") { + return Language::Th(region); + } else if var_env.contains("bo") { + return Language::Bo(region); + } else if var_env.contains("ti") { + return Language::Ti(region); + } + + sixth_get_language_helper() +} + + +fn sixth_get_language_helper() -> Language { + let var_env: String = get_language_and_country(); + let region: Region = Region::get(); + + if var_env.contains("to") { + return Language::To(region); + } else if var_env.contains("ts") { + return Language::Ts(region); + } else if var_env.contains("tr") { + return Language::Tr(region); + } else if var_env.contains("tk") { + return Language::Tk(region); + } else if var_env.contains("tw") { + return Language::Tw(region); + } else if var_env.contains("uk") { + return Language::Uk(region); + } else if var_env.contains("ur") { + return Language::Ur(region); + } else if var_env.contains("uz") { + return Language::Uz(region); + } else if var_env.contains("vi") { + return Language::Vi(region); + } else if var_env.contains("vo") { + return Language::Vo(region); + } else if var_env.contains("cy") { + return Language::Cy(region); + } else if var_env.contains("wo") { + return Language::Wo(region); + } else if var_env.contains("xh") { + return Language::Xh(region); + } else if var_env.contains("ji") { + return Language::Ji(region); + } else if var_env.contains("yo") { + return Language::Yo(region); + } else if var_env.contains("zu") { + return Language::Zu(region); + } + + // unknown language + Language::En(Region::Any) +} + // FIXME: V2: Move `Unknown` variants to the top of the enum. /// The desktop environment of a system #[derive(Debug, PartialEq, Eq, Clone)] #[non_exhaustive] pub enum DesktopEnv { + /// Unknown desktop environment + Unknown(String), + /// Popular GTK-based desktop environment on Linux Gnome, /// One of the desktop environments for a specific version of Windows @@ -240,8 +3773,6 @@ pub enum DesktopEnv { Ermine, /// Default desktop environment for Redox Orbital, - /// Unknown desktop environment - Unknown(String), } impl Display for DesktopEnv { diff --git a/tari.txt b/tari.txt new file mode 100644 index 0000000..62d6c96 --- /dev/null +++ b/tari.txt @@ -0,0 +1,249 @@ +004 => "AF", +008 => "AL", +012 => "DZ", +016 => "AS", +020 => "AD", +024 => "AO", +660 => "AI", +010 => "AQ", +028 => "AG", +032 => "AR", +051 => "AM", +533 => "AW", +036 => "AU", +040 => "AT", +031 => "AZ", +044 => "BS", +048 => "BH", +050 => "BD", +052 => "BB", +112 => "BY", +056 => "BE", +084 => "BZ", +204 => "BJ", +060 => "BM", +064 => "BT", +068 => "BO", +535 => "BQ", +070 => "BA", +072 => "BW", +074 => "BV", +076 => "BR", +086 => "IO", +096 => "BN", +100 => "BG", +854 => "BF", +108 => "BI", +132 => "CV", +116 => "KH", +120 => "CM", +124 => "CA", +136 => "KY", +140 => "CF", +148 => "TD", +152 => "CL", +156 => "CN", +162 => "CX", +166 => "CC", +170 => "CO", +174 => "KM", +180 => "CD", +178 => "CG", +184 => "CK", +188 => "CR", +191 => "HR", +192 => "CU", +531 => "CW", +196 => "CY", +203 => "CZ", +384 => "CI", +208 => "DK", +262 => "DJ", +212 => "DM", +214 => "DO", +218 => "EC", +818 => "EG", +222 => "SV", +226 => "GQ", +232 => "ER", +233 => "EE", +748 => "SZ", +231 => "ET", +238 => "FK", +234 => "FO", +242 => "FJ", +246 => "FI", +250 => "FR", +254 => "GF", +258 => "PF", +260 => "TF", +266 => "GA", +270 => "GM", +268 => "GE", +276 => "DE", +288 => "GH", +292 => "GI", +300 => "GR", +304 => "GL", +308 => "GD", +312 => "GP", +316 => "GU", +320 => "GT", +831 => "GG", +324 => "GN", +624 => "GW", +328 => "GY", +332 => "HT", +334 => "HM", +336 => "VA", +340 => "HN", +344 => "HK", +348 => "HU", +352 => "IS", +356 => "IN", +360 => "ID", +364 => "IR", +368 => "IQ", +372 => "IE", +833 => "IM", +376 => "IL", +380 => "IT", +388 => "JM", +392 => "JP", +832 => "JE", +400 => "JO", +398 => "KZ", +404 => "KE", +296 => "KI", +408 => "KP", +410 => "KR", +414 => "KW", +417 => "KG", +418 => "LA", +428 => "LV", +422 => "LB", +426 => "LS", +430 => "LR", +434 => "LY", +438 => "LI", +440 => "LT", +442 => "LU", +446 => "MO", +450 => "MG", +454 => "MW", +458 => "MY", +462 => "MV", +466 => "ML", +470 => "MT", +584 => "MH", +474 => "MQ", +478 => "MR", +480 => "MU", +175 => "YT", +484 => "MX", +583 => "FM", +498 => "MD", +492 => "MC", +496 => "MN", +499 => "ME", +500 => "MS", +504 => "MA", +508 => "MZ", +104 => "MM", +516 => "NA", +520 => "NR", +524 => "NP", +528 => "NL", +540 => "NC", +554 => "NZ", +558 => "NI", +562 => "NE", +566 => "NG", +570 => "NU", +574 => "NF", +580 => "MP", +578 => "NO", +512 => "OM", +586 => "PK", +585 => "PW", +275 => "PS", +591 => "PA", +598 => "PG", +600 => "PY", +604 => "PE", +608 => "PH", +612 => "PN", +616 => "PL", +620 => "PT", +630 => "PR", +634 => "QA", +807 => "MK", +642 => "RO", +643 => "RU", +646 => "RW", +638 => "RE", +652 => "BL", +654 => "SH", +659 => "KN", +662 => "LC", +663 => "MF", +666 => "PM", +670 => "VC", +882 => "WS", +674 => "SM", +678 => "ST", +682 => "SA", +686 => "SN", +688 => "RS", +690 => "SC", +694 => "SL", +702 => "SG", +534 => "SX", +703 => "SK", +705 => "SI", +090 => "SB", +706 => "SO", +710 => "ZA", +239 => "GS", +728 => "SS", +724 => "ES", +144 => "LK", +729 => "SD", +740 => "SR", +744 => "SJ", +752 => "SE", +756 => "CH", +760 => "SY", +158 => "TW", +762 => "TJ", +834 => "TZ", +764 => "TH", +626 => "TL", +768 => "TG", +772 => "TK", +776 => "TO", +780 => "TT", +788 => "TN", +792 => "TR", +795 => "TM", +796 => "TC", +798 => "TV", +800 => "UG", +804 => "UA", +784 => "AE", +826 => "GB", +581 => "UM", +840 => "US", +858 => "UY", +860 => "UZ", +548 => "VU", +862 => "VE", +704 => "VN", +092 => "VG", +850 => "VI", +876 => "WF", +732 => "EH", +887 => "YE", +894 => "ZM", +716 => "ZW", +248 => "AX",