generaltranslation 8.2.11 → 8.2.13

package/dist/locales/determineLocale.js

@@ -0,0 +1,72 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { _isValidLocale, _standardizeLocale } from './isValidLocale';
+import _isSameLanguage from './isSameLanguage';
+import _getLocaleProperties from './getLocaleProperties';
+/**
+ * Given a list of locales and a list of approved locales, sorted in preference order
+ * Determines which locale is the best match among the approved locales, prioritizing exact matches and falling back to dialects of the same language
+ * @internal
+ */
+export default function _determineLocale(locales, approvedLocales, customMapping) {
+    if (typeof locales === 'string')
+        locales = [locales];
+    locales = locales
+        .filter(function (locale) { return _isValidLocale(locale, customMapping); })
+        .map(_standardizeLocale);
+    approvedLocales = approvedLocales
+        .filter(function (locale) { return _isValidLocale(locale, customMapping); })
+        .map(_standardizeLocale);
+    var _loop_1 = function (locale) {
+        var candidates = approvedLocales.filter(function (approvedLocale) {
+            return _isSameLanguage(locale, approvedLocale);
+        });
+        var getMatchingCode = function (_a) {
+            var locale = _a.locale, languageCode = _a.languageCode, minimizedCode = _a.minimizedCode, regionCode = _a.regionCode, scriptCode = _a.scriptCode;
+            var locales = [
+                locale, // If the full locale is supported under this language category
+                "".concat(languageCode, "-").concat(regionCode), // Attempt to match parts
+                "".concat(languageCode, "-").concat(scriptCode),
+                minimizedCode, // If a minimized variant of this locale is supported
+            ];
+            for (var _i = 0, locales_2 = locales; _i < locales_2.length; _i++) {
+                var l = locales_2[_i];
+                if (candidates.includes(l))
+                    return l;
+            }
+            return null;
+        };
+        var _a = _getLocaleProperties(locale), languageCode = _a.languageCode, codes = __rest(_a, ["languageCode"]);
+        var matchingCode = getMatchingCode(__assign({ locale: locale, languageCode: languageCode }, codes)) ||
+            getMatchingCode(__assign({ locale: languageCode }, _getLocaleProperties(languageCode)));
+        if (matchingCode)
+            return { value: matchingCode };
+    };
+    for (var _i = 0, locales_1 = locales; _i < locales_1.length; _i++) {
+        var locale = locales_1[_i];
+        var state_1 = _loop_1(locale);
+        if (typeof state_1 === "object")
+            return state_1.value;
+    }
+    return undefined;
+}

package/dist/locales/getLocaleDirection.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/locales/getLocaleDirection.js

@@ -0,0 +1,89 @@
+import { intlCache } from '../cache/IntlCache';
+import _getLocaleProperties from './getLocaleProperties';
+/**
+ * Get the text direction for a given locale code using the Intl.Locale API.
+ *
+ * @param {string} code - The locale code to check.
+ * @returns {string} 'rtl' if the language is right-to-left; otherwise 'ltr'.
+ * @internal
+ */
+export function _getLocaleDirection(code) {
+    // Extract via textInfo property
+    try {
+        var locale = intlCache.get('Locale', code);
+        var textInfoDirection = extractDirectionWithTextInfo(locale);
+        if (textInfoDirection) {
+            return textInfoDirection;
+        }
+    }
+    catch (_a) {
+        // silent
+    }
+    // Fallback to simple heuristics
+    var _b = _getLocaleProperties(code), scriptCode = _b.scriptCode, languageCode = _b.languageCode;
+    // Handle RTL script or language
+    if (scriptCode)
+        return isRtlScript(scriptCode) ? 'rtl' : 'ltr';
+    if (languageCode)
+        return isRtlLanguage(languageCode) ? 'rtl' : 'ltr';
+    return 'ltr';
+}
+// ===== HELPER CONSTANTS ===== //
+var RTL_SCRIPTS = new Set([
+    'arab',
+    'adlm',
+    'hebr',
+    'nkoo',
+    'rohg',
+    'samr',
+    'syrc',
+    'thaa',
+    'yezi',
+]);
+var RTL_LANGUAGES = new Set([
+    'ar',
+    'arc',
+    'ckb',
+    'dv',
+    'fa',
+    'he',
+    'iw',
+    'ku',
+    'lrc',
+    'nqo',
+    'ps',
+    'pnb',
+    'sd',
+    'syr',
+    'ug',
+    'ur',
+    'yi',
+]);
+// ===== HELPER FUNCTIONS ===== //
+/**
+ * Handles extracting direction via textInfo property
+ * @param locale - Intl.Locale object.
+ * @returns {'ltr' | 'rtl'} - The direction of the locale
+ *
+ * Intl.Locale.prototype.getTextInfo() / textInfo property incorporated in ES2024 Specification.
+ * This is not supported by all browsers yet.
+ * See: {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/getTextInfo#browser_compatibility}
+ */
+function extractDirectionWithTextInfo(locale) {
+    var _a, _b, _c;
+    if ('textInfo' in locale &&
+        typeof locale.textInfo === 'object' &&
+        locale.textInfo !== null &&
+        'direction' in locale.textInfo &&
+        (((_a = locale.textInfo) === null || _a === void 0 ? void 0 : _a.direction) === 'rtl' ||
+            ((_b = locale.textInfo) === null || _b === void 0 ? void 0 : _b.direction) === 'ltr')) {
+        return (_c = locale.textInfo) === null || _c === void 0 ? void 0 : _c.direction;
+    }
+    return undefined;
+}
+function isRtlScript(script) {
+    return script ? RTL_SCRIPTS.has(script.toLowerCase()) : false;
+}
+function isRtlLanguage(language) {
+    return language ? RTL_LANGUAGES.has(language.toLowerCase()) : false;
+}

package/dist/locales/getLocaleEmoji.d.ts

@@ -0,0 +1,2 @@
+export declare const defaultEmoji = "\uD83C\uDF0D";
+export declare function getRegionEmoji(region: string): string;

package/dist/locales/getLocaleEmoji.js

@@ -0,0 +1,319 @@
+import { intlCache } from '../cache/IntlCache';
+import { getCustomProperty, shouldUseCanonicalLocale, } from './customLocaleMapping';
+import { _standardizeLocale } from './isValidLocale';
+/**
+ * @internal
+ */
+export default function _getLocaleEmoji(locale, customMapping) {
+    var aliasedLocale = locale;
+    if (customMapping && shouldUseCanonicalLocale(locale, customMapping)) {
+        locale = customMapping[locale].code;
+    }
+    try {
+        var standardizedLocale = _standardizeLocale(locale);
+        var localeObject = intlCache.get('Locale', standardizedLocale);
+        var language = localeObject.language, region = localeObject.region;
+        if (customMapping) {
+            for (var _i = 0, _a = [aliasedLocale, locale, standardizedLocale, language]; _i < _a.length; _i++) {
+                var l = _a[_i];
+                var customEmoji = getCustomProperty(customMapping, l, 'emoji');
+                if (customEmoji)
+                    return customEmoji;
+            }
+        }
+        var regionEmoji = region && getSupportedRegionEmoji(region);
+        if (regionEmoji)
+            return regionEmoji;
+        var extrapolated = localeObject.maximize();
+        return (exceptions[extrapolated.language] ||
+            getRegionEmoji(extrapolated.region || ''));
+    }
+    catch (_b) {
+        return defaultEmoji;
+    }
+}
+// Default language emoji for when none else can be found
+var europeAfricaGlobe = '🌍';
+var asiaAustraliaGlobe = '🌏';
+export var defaultEmoji = europeAfricaGlobe;
+// Exceptions to better reflect linguistic and cultural identities
+var exceptions = {
+    ca: europeAfricaGlobe,
+    eu: europeAfricaGlobe,
+    ku: europeAfricaGlobe,
+    bo: asiaAustraliaGlobe,
+    ug: asiaAustraliaGlobe,
+    gd: '🏴󠁧󠁢󠁳󠁣󠁴󠁿',
+    cy: '🏴󠁧󠁢󠁷󠁬󠁳󠁿',
+    gv: '🇮🇲',
+    grc: '🏺',
+};
+var specialRegionEmojis = {
+    EU: '🇪🇺',
+    '419': '🌎',
+};
+// Regions with Unicode regional-indicator flag sequences.
+var flagRegions = new Set([
+    'AF', // Afghanistan
+    'AX', // Åland Islands
+    'AL', // Albania
+    'DZ', // Algeria
+    'AS', // American Samoa
+    'AD', // Andorra
+    'AO', // Angola
+    'AI', // Anguilla
+    'AQ', // Antarctica
+    'AG', // Antigua and Barbuda
+    'AR', // Argentina
+    'AM', // Armenia
+    'AW', // Aruba
+    'AU', // Australia
+    'AT', // Austria
+    'AZ', // Azerbaijan
+    'BS', // Bahamas
+    'BH', // Bahrain
+    'BD', // Bangladesh
+    'BB', // Barbados
+    'BY', // Belarus
+    'BE', // Belgium
+    'BZ', // Belize
+    'BJ', // Benin
+    'BM', // Bermuda
+    'BT', // Bhutan
+    'BO', // Bolivia
+    'BQ', // Bonaire, Sint Eustatius and Saba
+    'BA', // Bosnia and Herzegovina
+    'BW', // Botswana
+    'BV', // Bouvet Island
+    'BR', // Brazil
+    'IO', // British Indian Ocean Territory
+    'BN', // Brunei Darussalam
+    'BG', // Bulgaria
+    'BF', // Burkina Faso
+    'BI', // Burundi
+    'CV', // Cabo Verde
+    'KH', // Cambodia
+    'CM', // Cameroon
+    'CA', // Canada
+    'KY', // Cayman Islands
+    'CF', // Central African Republic
+    'TD', // Chad
+    'CL', // Chile
+    'CN', // China
+    'CX', // Christmas Island
+    'CC', // Cocos (Keeling) Islands
+    'CO', // Colombia
+    'KM', // Comoros
+    'CD', // Congo (Democratic Republic)
+    'CG', // Congo (Republic)
+    'CK', // Cook Islands
+    'CR', // Costa Rica
+    'CI', // Côte d'Ivoire
+    'HR', // Croatia
+    'CU', // Cuba
+    'CW', // Curaçao
+    'CY', // Cyprus
+    'CZ', // Czechia
+    'DK', // Denmark
+    'DJ', // Djibouti
+    'DM', // Dominica
+    'DO', // Dominican Republic
+    'EC', // Ecuador
+    'EG', // Egypt
+    'SV', // El Salvador
+    'GQ', // Equatorial Guinea
+    'ER', // Eritrea
+    'EE', // Estonia
+    'SZ', // Eswatini
+    'ET', // Ethiopia
+    'FK', // Falkland Islands
+    'FO', // Faroe Islands
+    'FJ', // Fiji
+    'FI', // Finland
+    'FR', // France
+    'GF', // French Guiana
+    'PF', // French Polynesia
+    'TF', // French Southern Territories
+    'GA', // Gabon
+    'GM', // Gambia
+    'GE', // Georgia
+    'DE', // Germany
+    'GH', // Ghana
+    'GI', // Gibraltar
+    'GR', // Greece
+    'GL', // Greenland
+    'GD', // Grenada
+    'GP', // Guadeloupe
+    'GU', // Guam
+    'GT', // Guatemala
+    'GG', // Guernsey
+    'GN', // Guinea
+    'GW', // Guinea-Bissau
+    'GY', // Guyana
+    'HT', // Haiti
+    'HM', // Heard Island and McDonald Islands
+    'VA', // Holy See
+    'HN', // Honduras
+    'HK', // Hong Kong
+    'HU', // Hungary
+    'IS', // Iceland
+    'IN', // India
+    'ID', // Indonesia
+    'IR', // Iran
+    'IQ', // Iraq
+    'IE', // Ireland
+    'IM', // Isle of Man
+    'IL', // Israel
+    'IT', // Italy
+    'JM', // Jamaica
+    'JP', // Japan
+    'JE', // Jersey
+    'JO', // Jordan
+    'KZ', // Kazakhstan
+    'KE', // Kenya
+    'KI', // Kiribati
+    'KP', // Korea (North)
+    'KR', // Korea (South)
+    'KW', // Kuwait
+    'KG', // Kyrgyzstan
+    'LA', // Laos
+    'LV', // Latvia
+    'LB', // Lebanon
+    'LS', // Lesotho
+    'LR', // Liberia
+    'LY', // Libya
+    'LI', // Liechtenstein
+    'LT', // Lithuania
+    'LU', // Luxembourg
+    'MO', // Macao
+    'MG', // Madagascar
+    'MW', // Malawi
+    'MY', // Malaysia
+    'MV', // Maldives
+    'ML', // Mali
+    'MT', // Malta
+    'MH', // Marshall Islands
+    'MQ', // Martinique
+    'MR', // Mauritania
+    'MU', // Mauritius
+    'YT', // Mayotte
+    'MX', // Mexico
+    'FM', // Micronesia
+    'MD', // Moldova
+    'MC', // Monaco
+    'MN', // Mongolia
+    'ME', // Montenegro
+    'MS', // Montserrat
+    'MA', // Morocco
+    'MZ', // Mozambique
+    'MM', // Myanmar
+    'NA', // Namibia
+    'NR', // Nauru
+    'NP', // Nepal
+    'NL', // Netherlands
+    'NC', // New Caledonia
+    'NZ', // New Zealand
+    'NI', // Nicaragua
+    'NE', // Niger
+    'NG', // Nigeria
+    'NU', // Niue
+    'NF', // Norfolk Island
+    'MK', // North Macedonia
+    'MP', // Northern Mariana Islands
+    'NO', // Norway
+    'OM', // Oman
+    'PK', // Pakistan
+    'PW', // Palau
+    'PS', // Palestine, State of
+    'PA', // Panama
+    'PG', // Papua New Guinea
+    'PY', // Paraguay
+    'PE', // Peru
+    'PH', // Philippines
+    'PN', // Pitcairn
+    'PL', // Poland
+    'PT', // Portugal
+    'PR', // Puerto Rico
+    'QA', // Qatar
+    'RE', // Réunion
+    'RO', // Romania
+    'RU', // Russian Federation
+    'RW', // Rwanda
+    'BL', // Saint Barthélemy
+    'SH', // Saint Helena, Ascension and Tristan da Cunha
+    'KN', // Saint Kitts and Nevis
+    'LC', // Saint Lucia
+    'MF', // Saint Martin (French part)
+    'PM', // Saint Pierre and Miquelon
+    'VC', // Saint Vincent and the Grenadines
+    'WS', // Samoa
+    'SM', // San Marino
+    'ST', // São Tomé and Príncipe
+    'SA', // Saudi Arabia
+    'SN', // Senegal
+    'RS', // Serbia
+    'SC', // Seychelles
+    'SL', // Sierra Leone
+    'SG', // Singapore
+    'SX', // Sint Maarten (Dutch part)
+    'SK', // Slovakia
+    'SI', // Slovenia
+    'SB', // Solomon Islands
+    'SO', // Somalia
+    'ZA', // South Africa
+    'GS', // South Georgia and the South Sandwich Islands
+    'SS', // South Sudan
+    'ES', // Spain
+    'LK', // Sri Lanka
+    'SD', // Sudan
+    'SR', // Suriname
+    'SJ', // Svalbard and Jan Mayen
+    'SE', // Sweden
+    'CH', // Switzerland
+    'SY', // Syrian Arab Republic
+    'TW', // Taiwan
+    'TJ', // Tajikistan
+    'TZ', // Tanzania
+    'TH', // Thailand
+    'TL', // Timor-Leste
+    'TG', // Togo
+    'TK', // Tokelau
+    'TO', // Tonga
+    'TT', // Trinidad and Tobago
+    'TN', // Tunisia
+    'TR', // Türkiye
+    'TM', // Turkmenistan
+    'TC', // Turks and Caicos Islands
+    'TV', // Tuvalu
+    'UG', // Uganda
+    'UA', // Ukraine
+    'AE', // United Arab Emirates
+    'GB', // United Kingdom
+    'US', // United States of America
+    'UM', // United States Minor Outlying Islands
+    'UY', // Uruguay
+    'UZ', // Uzbekistan
+    'VU', // Vanuatu
+    'VE', // Venezuela
+    'VN', // Viet Nam
+    'VG', // Virgin Islands (British)
+    'VI', // Virgin Islands (U.S.)
+    'WF', // Wallis and Futuna
+    'EH', // Western Sahara
+    'YE', // Yemen
+    'ZM', // Zambia
+    'ZW', // Zimbabwe
+]);
+var regionalIndicatorOffset = 0x1f1e6 - 'A'.charCodeAt(0);
+export function getRegionEmoji(region) {
+    return getSupportedRegionEmoji(region) || defaultEmoji;
+}
+function getSupportedRegionEmoji(region) {
+    var normalizedRegion = region.toUpperCase();
+    var specialEmoji = specialRegionEmojis[normalizedRegion];
+    if (specialEmoji)
+        return specialEmoji;
+    if (!flagRegions.has(normalizedRegion))
+        return undefined;
+    return String.fromCodePoint(normalizedRegion.charCodeAt(0) + regionalIndicatorOffset, normalizedRegion.charCodeAt(1) + regionalIndicatorOffset);
+}

package/dist/locales/getLocaleName.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/locales/getLocaleName.js

@@ -0,0 +1,45 @@
+import { intlCache } from '../cache/IntlCache';
+import { libraryDefaultLocale } from '../settings/settings';
+import { getCustomProperty, shouldUseCanonicalLocale, } from './customLocaleMapping';
+import { _standardizeLocale } from './isValidLocale';
+/**
+ * Retrieves the display name(s) of locale code(s) using Intl.DisplayNames.
+ *
+ * @param {string} locale - A BCP-47 locale code.
+ * @param {string} [defaultLocale=libraryDefaultLocale] - The locale for display names.
+ * @returns {string} The display name(s) corresponding to the code(s), or empty string(s) if invalid.
+ * @internal
+ */
+export function _getLocaleName(locale, defaultLocale, customMapping) {
+    if (defaultLocale === void 0) { defaultLocale = libraryDefaultLocale; }
+    // Check for canonical locale
+    var aliasedLocale = locale;
+    if (customMapping && shouldUseCanonicalLocale(locale, customMapping)) {
+        // Override locale with canonical locale
+        locale = customMapping[locale].code;
+    }
+    defaultLocale || (defaultLocale = libraryDefaultLocale);
+    try {
+        var standardizedLocale = _standardizeLocale(locale);
+        if (customMapping) {
+            for (var _i = 0, _a = [
+                aliasedLocale,
+                locale,
+                standardizedLocale,
+                intlCache.get('Locale', standardizedLocale).language,
+            ]; _i < _a.length; _i++) {
+                var l = _a[_i];
+                var customName = getCustomProperty(customMapping, l, 'name');
+                if (customName)
+                    return customName;
+            }
+        }
+        var displayNames = intlCache.get('DisplayNames', [defaultLocale, standardizedLocale, libraryDefaultLocale], // default locale order
+        { type: 'language' });
+        return displayNames.of(standardizedLocale) || '';
+    }
+    catch (_b) {
+        // In case Intl.DisplayNames construction fails, return empty string(s)
+        return '';
+    }
+}

package/dist/locales/getLocaleProperties.d.ts

@@ -0,0 +1,32 @@
+import { CustomMapping } from './customLocaleMapping';
+export type LocaleProperties = {
+    code: string;
+    name: string;
+    nativeName: string;
+    languageCode: string;
+    languageName: string;
+    nativeLanguageName: string;
+    nameWithRegionCode: string;
+    nativeNameWithRegionCode: string;
+    regionCode: string;
+    regionName: string;
+    nativeRegionName: string;
+    scriptCode: string;
+    scriptName: string;
+    nativeScriptName: string;
+    maximizedCode: string;
+    maximizedName: string;
+    nativeMaximizedName: string;
+    minimizedCode: string;
+    minimizedName: string;
+    nativeMinimizedName: string;
+    emoji: string;
+};
+/**
+ * Creates a set of custom locale properties from a custom mapping.
+ *
+ * @param lArray - An array of locale codes to search for in the custom mapping.
+ * @param customMapping - Optional custom mapping of locale codes to names.
+ * @returns A partial set of locale properties, or undefined if no custom mapping is provided.
+ */
+export declare function createCustomLocaleProperties(lArray: string[], customMapping?: CustomMapping): Partial<LocaleProperties> | undefined;