generaltranslation 8.2.11 → 8.2.13

package/dist/locales/getLocaleProperties.js

@@ -0,0 +1,220 @@
+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);
+};
+import { libraryDefaultLocale } from '../settings/settings';
+import { defaultEmoji } from './getLocaleEmoji';
+import { _isValidLocale, _standardizeLocale } from './isValidLocale';
+import _getLocaleEmoji from './getLocaleEmoji';
+import { intlCache } from '../cache/IntlCache';
+import { shouldUseCanonicalLocale } from './customLocaleMapping';
+/**
+ * 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 function createCustomLocaleProperties(lArray, customMapping) {
+    if (customMapping) {
+        var merged = {};
+        for (var _i = 0, lArray_1 = lArray; _i < lArray_1.length; _i++) {
+            var l = lArray_1[_i];
+            var value = customMapping[l];
+            if (value) {
+                if (typeof value === 'string') {
+                    merged.name || (merged.name = value);
+                }
+                else if (value) {
+                    merged = __assign(__assign({}, value), merged);
+                }
+            }
+        }
+        return merged;
+    }
+    return undefined;
+}
+/**
+ * @internal
+ */
+export default function _getLocaleProperties(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); // "de-AT"
+        var localeObject = intlCache.get('Locale', locale);
+        var languageCode = localeObject.language; // "de"
+        var customLocaleProperties = createCustomLocaleProperties([aliasedLocale, locale, standardizedLocale, languageCode], customMapping);
+        var baseRegion = localeObject.region; // "AT"
+        var maximizedLocale = localeObject.maximize();
+        var maximizedCode = maximizedLocale.toString(); // "de-Latn-AT"
+        var regionCode = localeObject.region ||
+            (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.regionCode) ||
+            maximizedLocale.region ||
+            ''; // "AT"
+        var scriptCode = localeObject.script ||
+            (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.scriptCode) ||
+            maximizedLocale.script ||
+            ''; // "Latn"
+        var minimizedLocale = localeObject.minimize();
+        var minimizedCode = minimizedLocale.toString(); // "de-AT"
+        // Language names (default and native)
+        var defaultLanguageOrder = [defaultLocale, locale, libraryDefaultLocale];
+        var nativeLanguageOrder = [locale, defaultLocale, libraryDefaultLocale];
+        var languageNames = intlCache.get('DisplayNames', defaultLanguageOrder, {
+            type: 'language',
+        });
+        var nativeLanguageNames = intlCache.get('DisplayNames', nativeLanguageOrder, { type: 'language' });
+        var customName = customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.name;
+        var customNativeName = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.nativeName) || (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.name);
+        var name = customName || languageNames.of(locale) || locale; // "Austrian German"
+        var nativeName = customNativeName || nativeLanguageNames.of(locale) || locale; // "Österreichisches Deutsch"
+        var maximizedName = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.maximizedName) ||
+            customName ||
+            languageNames.of(maximizedCode) ||
+            locale; // "Austrian German (Latin)"
+        var nativeMaximizedName = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.nativeMaximizedName) ||
+            customNativeName ||
+            nativeLanguageNames.of(maximizedCode) ||
+            locale; // "Österreichisches Deutsch (Lateinisch)"
+        var minimizedName = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.minimizedName) ||
+            customName ||
+            languageNames.of(minimizedCode) ||
+            locale; // "Austrian German", but for "de-DE" would just be "German"
+        var nativeMinimizedName = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.nativeMinimizedName) ||
+            customNativeName ||
+            nativeLanguageNames.of(minimizedCode) ||
+            locale; // "Österreichisches Deutsch", but for "de-DE" would just be "Deutsch"
+        var languageName = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.languageName) ||
+            customName ||
+            languageNames.of(languageCode) ||
+            locale; // "German"
+        var nativeLanguageName = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.nativeLanguageName) ||
+            customNativeName ||
+            nativeLanguageNames.of(languageCode) ||
+            locale; // "Deutsch"
+        var nameWithRegionCode = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.nameWithRegionCode) || baseRegion
+            ? "".concat(languageName, " (").concat(baseRegion, ")")
+            : name; // German (AT)
+        var nativeNameWithRegionCode = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.nativeNameWithRegionCode) ||
+            (baseRegion ? "".concat(nativeLanguageName, " (").concat(baseRegion, ")") : nativeName) ||
+            nameWithRegionCode; // "Deutsch (AT)"
+        // Region names (default and native)
+        var regionNames = intlCache.get('DisplayNames', defaultLanguageOrder, {
+            type: 'region',
+        });
+        var nativeRegionNames = intlCache.get('DisplayNames', nativeLanguageOrder, { type: 'region' });
+        var regionName = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.regionName) ||
+            (regionCode ? regionNames.of(regionCode) : '') ||
+            ''; // "Austria"
+        var nativeRegionName = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.nativeRegionName) ||
+            (regionCode ? nativeRegionNames.of(regionCode) : '') ||
+            ''; // "Österreich"
+        // Script names (default and native)
+        var scriptNames = intlCache.get('DisplayNames', defaultLanguageOrder, {
+            type: 'script',
+        });
+        var nativeScriptNames = intlCache.get('DisplayNames', nativeLanguageOrder, { type: 'script' });
+        var scriptName = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.scriptName) ||
+            (scriptCode ? scriptNames.of(scriptCode) : '') ||
+            ''; // "Latin"
+        var nativeScriptName = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.nativeScriptName) ||
+            (scriptCode ? nativeScriptNames.of(scriptCode) : '') ||
+            ''; // "Lateinisch"
+        // Emoji
+        var emoji = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.emoji) ||
+            _getLocaleEmoji(standardizedLocale, customMapping);
+        return {
+            code: standardizedLocale,
+            name: name,
+            nativeName: nativeName,
+            maximizedCode: maximizedCode,
+            maximizedName: maximizedName,
+            nativeMaximizedName: nativeMaximizedName,
+            minimizedCode: minimizedCode,
+            minimizedName: minimizedName,
+            nativeMinimizedName: nativeMinimizedName,
+            languageCode: languageCode,
+            languageName: languageName,
+            nativeLanguageName: nativeLanguageName,
+            nameWithRegionCode: nameWithRegionCode,
+            nativeNameWithRegionCode: nativeNameWithRegionCode,
+            regionCode: regionCode,
+            regionName: regionName,
+            nativeRegionName: nativeRegionName,
+            scriptCode: scriptCode,
+            scriptName: scriptName,
+            nativeScriptName: nativeScriptName,
+            emoji: emoji,
+        };
+    }
+    catch (_a) {
+        var code = _isValidLocale(locale) ? _standardizeLocale(locale) : locale;
+        var codeParts = code === null || code === void 0 ? void 0 : code.split('-');
+        var languageCode = (codeParts === null || codeParts === void 0 ? void 0 : codeParts[0]) || code || '';
+        var regionCode = codeParts.length > 2 ? codeParts === null || codeParts === void 0 ? void 0 : codeParts[2] : (codeParts === null || codeParts === void 0 ? void 0 : codeParts[1]) || '';
+        var scriptCode = (codeParts === null || codeParts === void 0 ? void 0 : codeParts[3]) || '';
+        var customLocaleProperties = createCustomLocaleProperties([code, languageCode], customMapping);
+        code = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.code) || code;
+        var name = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.name) || code;
+        var nativeName = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.nativeName) || name;
+        var maximizedCode = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.maximizedCode) || code;
+        var maximizedName = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.maximizedName) || name;
+        var nativeMaximizedName = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.nativeMaximizedName) || nativeName;
+        var minimizedCode = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.minimizedCode) || code;
+        var minimizedName = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.minimizedName) || name;
+        var nativeMinimizedName = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.nativeMinimizedName) || nativeName;
+        languageCode = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.languageCode) || languageCode;
+        var languageName = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.languageName) || name;
+        var nativeLanguageName = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.nativeLanguageName) || nativeName;
+        regionCode = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.regionCode) || regionCode;
+        var regionName = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.regionName) || '';
+        var nativeRegionName = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.nativeRegionName) || '';
+        scriptCode = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.scriptCode) || scriptCode;
+        var scriptName = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.scriptName) || '';
+        var nativeScriptName = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.nativeScriptName) || '';
+        var nameWithRegionCode = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.nameWithRegionCode) ||
+            (regionName ? "".concat(languageName, " (").concat(regionName, ")") : name);
+        var nativeNameWithRegionCode = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.nativeNameWithRegionCode) ||
+            (nativeRegionName
+                ? "".concat(nativeLanguageName, " (").concat(nativeRegionName, ")")
+                : nativeName);
+        var emoji = (customLocaleProperties === null || customLocaleProperties === void 0 ? void 0 : customLocaleProperties.emoji) || defaultEmoji;
+        return {
+            code: code,
+            name: name,
+            nativeName: nativeName,
+            maximizedCode: maximizedCode,
+            maximizedName: maximizedName,
+            nativeMaximizedName: nativeMaximizedName,
+            minimizedCode: minimizedCode,
+            minimizedName: minimizedName,
+            nativeMinimizedName: nativeMinimizedName,
+            languageCode: languageCode,
+            languageName: languageName,
+            nativeLanguageName: nativeLanguageName,
+            nameWithRegionCode: nameWithRegionCode,
+            nativeNameWithRegionCode: nativeNameWithRegionCode,
+            regionCode: regionCode,
+            regionName: regionName,
+            nativeRegionName: nativeRegionName,
+            scriptCode: scriptCode,
+            scriptName: scriptName,
+            nativeScriptName: nativeScriptName,
+            emoji: emoji,
+        };
+    }
+}

package/dist/locales/getPluralForm.d.ts

@@ -0,0 +1,9 @@
+import { PluralType } from '../settings/plurals';
+/**
+ * Given a number and a list of allowed plural forms, return the plural form that best fits the number.
+ *
+ * @param {number} n - The number to determine the plural form for.
+ * @param {PluralType[]} forms - The allowed plural forms.
+ * @returns {PluralType} The determined plural form, or an empty string if none fit.
+ */
+export default function _getPluralForm(n: number, forms?: readonly PluralType[], locales?: string[]): PluralType | '';

package/dist/locales/getPluralForm.js

@@ -0,0 +1,63 @@
+import { intlCache } from '../cache/IntlCache';
+import { pluralForms } from '../settings/plurals';
+import { libraryDefaultLocale } from '../settings/settings';
+/**
+ * Given a number and a list of allowed plural forms, return the plural form that best fits the number.
+ *
+ * @param {number} n - The number to determine the plural form for.
+ * @param {PluralType[]} forms - The allowed plural forms.
+ * @returns {PluralType} The determined plural form, or an empty string if none fit.
+ */
+export default function _getPluralForm(n, forms, locales) {
+    if (forms === void 0) { forms = pluralForms; }
+    if (locales === void 0) { locales = [libraryDefaultLocale]; }
+    var pluralRules = intlCache.get('PluralRules', locales);
+    var provisionalBranchName = pluralRules.select(n);
+    // aliases
+    var absN = Math.abs(n);
+    // 0
+    if (absN === 0 && forms.includes('zero'))
+        return 'zero'; // override
+    // 1
+    if (absN === 1) {
+        if (forms.includes('singular'))
+            return 'singular'; // override
+        if (forms.includes('one'))
+            return 'one'; // override
+    }
+    if (provisionalBranchName === 'one' && forms.includes('singular'))
+        return 'singular';
+    // 2
+    if (absN === 2) {
+        if (forms.includes('dual'))
+            return 'dual'; // override
+        if (forms.includes('two'))
+            return 'two'; // override
+    }
+    if (provisionalBranchName === 'two' && forms.includes('dual'))
+        return 'dual';
+    // fallbacks
+    if (forms.includes(provisionalBranchName))
+        return provisionalBranchName;
+    // two
+    if (provisionalBranchName === 'two' && forms.includes('dual'))
+        return 'dual';
+    if (provisionalBranchName === 'two' && forms.includes('plural'))
+        return 'plural';
+    if (provisionalBranchName === 'two' && forms.includes('other'))
+        return 'other';
+    // few
+    if (provisionalBranchName === 'few' && forms.includes('plural'))
+        return 'plural';
+    if (provisionalBranchName === 'few' && forms.includes('other'))
+        return 'other';
+    // many
+    if (provisionalBranchName === 'many' && forms.includes('plural'))
+        return 'plural';
+    if (provisionalBranchName === 'many' && forms.includes('other'))
+        return 'other';
+    // other
+    if (provisionalBranchName === 'other' && forms.includes('plural'))
+        return 'plural';
+    return '';
+}

package/dist/locales/getRegionProperties.d.ts

@@ -0,0 +1,7 @@
+export type CustomRegionMapping = {
+    [region: string]: {
+        name?: string;
+        emoji?: string;
+        locale?: string;
+    };
+};

package/dist/locales/getRegionProperties.js

@@ -0,0 +1,61 @@
+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);
+};
+import { intlCache } from '../cache/IntlCache';
+import { libraryDefaultLocale } from '../settings/settings';
+import { defaultEmoji, getRegionEmoji } from './getLocaleEmoji';
+/**
+ * Retrieves multiple properties for a given region code, including:
+ * - `code`: the original region code
+ * - `name`: the localized display name
+ * - `emoji`: the associated flag or symbol
+ *
+ * Behavior:
+ * - Accepts ISO 3166-1 alpha-2 or UN M.49 region codes (e.g., `"US"`, `"FR"`, `"419"`).
+ * - If `customMapping` contains a `name` or `emoji` for the region, those override the default values.
+ * - Otherwise, uses `Intl.DisplayNames` to get the localized region name in the given `defaultLocale`,
+ *   falling back to `libraryDefaultLocale`.
+ * - Falls back to the region code as `name` if display name resolution fails.
+ * - Falls back to `defaultEmoji` if no emoji can be computed or found in `customMapping`.
+ *
+ * @param {string} region - The region code to look up (e.g., `"US"`, `"GB"`, `"DE"`).
+ * @param {string} [defaultLocale=libraryDefaultLocale] - The locale to use when localizing the region name.
+ * @param {CustomRegionMapping} [customMapping] - Optional mapping of region codes to custom names and/or emojis.
+ * @returns {{ code: string, name: string, emoji: string }} An object containing:
+ *  - `code`: the input region code
+ *  - `name`: the localized or custom region name
+ *  - `emoji`: the matching emoji flag or symbol
+ * @internal
+ *
+ * @example
+ * _getRegionProperties('US', 'en');
+ * // => { code: 'US', name: 'United States', emoji: '🇺🇸' }
+ *
+ * @example
+ * _getRegionProperties('US', 'fr');
+ * // => { code: 'US', name: 'États-Unis', emoji: '🇺🇸' }
+ *
+ * @example
+ * _getRegionProperties('US', 'en', { US: { name: 'USA', emoji: '🗽' } });
+ * // => { code: 'US', name: 'USA', emoji: '🗽' }
+ */
+export function _getRegionProperties(region, defaultLocale, customMapping) {
+    if (defaultLocale === void 0) { defaultLocale = libraryDefaultLocale; }
+    defaultLocale || (defaultLocale = libraryDefaultLocale);
+    try {
+        var displayNames = intlCache.get('DisplayNames', [defaultLocale, libraryDefaultLocale], // default language order
+        { type: 'region' });
+        return __assign({ code: region, name: displayNames.of(region) || region, emoji: getRegionEmoji(region) }, customMapping === null || customMapping === void 0 ? void 0 : customMapping[region]);
+    }
+    catch (_a) {
+        return __assign({ code: region, name: region, emoji: defaultEmoji }, customMapping === null || customMapping === void 0 ? void 0 : customMapping[region]);
+    }
+}

package/dist/locales/isSameDialect.d.ts

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

package/dist/locales/isSameDialect.js

@@ -0,0 +1,41 @@
+import { intlCache } from '../cache/IntlCache';
+import { _standardizeLocale } from './isValidLocale';
+function checkTwoLocalesAreSameDialect(codeA, codeB) {
+    var _a = intlCache.get('Locale', codeA), languageA = _a.language, regionA = _a.region, scriptA = _a.script;
+    var _b = intlCache.get('Locale', codeB), languageB = _b.language, regionB = _b.region, scriptB = _b.script;
+    if (languageA !== languageB)
+        return false;
+    if (regionA && regionB && regionA !== regionB)
+        return false;
+    if (scriptA && scriptB && scriptA !== scriptB)
+        return false;
+    return true;
+}
+/**
+ * Test two or more language codes to determine if they are exactly the same
+ * e.g. "en-US" and "en" would be exactly the same.
+ * "en-GB" and "en" would be exactly the same.
+ * "en-GB" and "en-US" would be different.
+ * @internal
+ */
+export default function _isSameDialect() {
+    var locales = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        locales[_i] = arguments[_i];
+    }
+    try {
+        // standardize codes
+        var flattenedCodes = locales.flat().map(_standardizeLocale);
+        for (var i = 0; i < flattenedCodes.length; i++) {
+            for (var j = i + 1; j < flattenedCodes.length; j++) {
+                if (!checkTwoLocalesAreSameDialect(flattenedCodes[i], flattenedCodes[j]))
+                    return false;
+            }
+        }
+        return true;
+    }
+    catch (error) {
+        console.error(error);
+        return false;
+    }
+}

package/dist/locales/isSameLanguage.d.ts

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

package/dist/locales/isSameLanguage.js

@@ -0,0 +1,20 @@
+import { intlCache } from '../cache/IntlCache';
+/**
+ * @internal
+ */
+export default function _isSameLanguage() {
+    var locales = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        locales[_i] = arguments[_i];
+    }
+    try {
+        var flattenedCodes = locales.flat();
+        // Get the language for each code
+        var languages_1 = flattenedCodes.map(function (locale) { return intlCache.get('Locale', locale).language; });
+        return languages_1.every(function (language) { return language === languages_1[0]; });
+    }
+    catch (error) {
+        console.error(error);
+        return false;
+    }
+}

package/dist/locales/isSupersetLocale.d.ts

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

package/dist/locales/isSupersetLocale.js

@@ -0,0 +1,22 @@
+import { intlCache } from '../cache/IntlCache';
+import { _standardizeLocale } from './isValidLocale';
+/**
+ * @internal
+ */
+export default function _isSupersetLocale(superLocale, subLocale) {
+    try {
+        var _a = intlCache.get('Locale', _standardizeLocale(superLocale)), languageSuper = _a.language, regionSuper = _a.region, scriptSuper = _a.script;
+        var _b = intlCache.get('Locale', _standardizeLocale(subLocale)), languageSub = _b.language, regionSub = _b.region, scriptSub = _b.script;
+        if (languageSuper !== languageSub)
+            return false;
+        if (regionSuper && regionSuper !== regionSub)
+            return false;
+        if (scriptSuper && scriptSuper !== scriptSub)
+            return false;
+        return true;
+    }
+    catch (error) {
+        console.error(error);
+        return false;
+    }
+}

package/dist/locales/isValidLocale.d.ts

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

package/dist/locales/isValidLocale.js

@@ -0,0 +1,75 @@
+import { intlCache } from '../cache/IntlCache';
+import { libraryDefaultLocale } from '../settings/settings';
+var scriptExceptions = ['Cham', 'Jamo', 'Kawi', 'Lisu', 'Toto', 'Thai'];
+//// According to BCP 47, the range qaa–qtz is reserved for private-use language codes
+var isCustomLanguage = function (language) {
+    return language >= 'qaa' && language <= 'qtz';
+};
+/**
+ * Checks if a given BCP 47 language code is valid.
+ * @param {string} code - The BCP 47 language code to validate.
+ * @param {CustomMapping} [customMapping] - The custom mapping to use for validation.
+ * @returns {boolean} True if the BCP 47 code is valid, false otherwise.
+ * @internal
+ */
+export var _isValidLocale = function (locale, customMapping) {
+    // If in custom mapping, return true
+    if ((customMapping === null || customMapping === void 0 ? void 0 : customMapping[locale]) &&
+        typeof customMapping[locale] === 'object' &&
+        'code' in customMapping[locale] &&
+        customMapping[locale].code) {
+        locale = customMapping[locale].code;
+    }
+    try {
+        var _a = intlCache.get('Locale', locale), language = _a.language, region_1 = _a.region, script_1 = _a.script;
+        if (locale.split('-').length !==
+            (function () {
+                var partCount = 1;
+                if (region_1)
+                    partCount += 1;
+                if (script_1)
+                    partCount += 1;
+                return partCount;
+            })())
+            return false;
+        var displayLanguageNames = intlCache.get('DisplayNames', [libraryDefaultLocale], {
+            type: 'language',
+        });
+        if (displayLanguageNames.of(language) === language &&
+            !isCustomLanguage(language))
+            return false;
+        if (region_1) {
+            var displayRegionNames = intlCache.get('DisplayNames', [libraryDefaultLocale], {
+                type: 'region',
+            });
+            if (displayRegionNames.of(region_1) === region_1)
+                return false;
+        }
+        if (script_1) {
+            var displayScriptNames = intlCache.get('DisplayNames', [libraryDefaultLocale], {
+                type: 'script',
+            });
+            if (displayScriptNames.of(script_1) === script_1 &&
+                !scriptExceptions.includes(script_1))
+                return false;
+        }
+        return true;
+    }
+    catch (_b) {
+        return false;
+    }
+};
+/**
+ * Standardizes a BCP 47 locale to ensure correct formatting.
+ * @param {string} locale - The BCP 47 locale to standardize.
+ * @returns {string} The standardized BCP 47 locale, or the input string if it cannot be standardized.
+ * @internal
+ */
+export var _standardizeLocale = function (locale) {
+    try {
+        return Intl.getCanonicalLocales(locale)[0];
+    }
+    catch (_a) {
+        return locale;
+    }
+};

package/dist/locales/requiresTranslation.d.ts

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

package/dist/locales/requiresTranslation.js

@@ -0,0 +1,32 @@
+import _isSameDialect from './isSameDialect';
+import _isSameLanguage from './isSameLanguage';
+import { _isValidLocale } from './isValidLocale';
+/**
+ * Given a target locale and a source locale, determines whether a translation is required
+ * If the target locale and the source locale are the same, returns false, otherwise returns true
+ * If a translation is not possible due to the target locale being outside of the optional approvedLanguages scope, also returns false
+ * @internal
+ */
+export default function _requiresTranslation(sourceLocale, targetLocale, approvedLocales, customMapping) {
+    // If codes are invalid
+    if (!_isValidLocale(sourceLocale, customMapping) ||
+        !_isValidLocale(targetLocale, customMapping) ||
+        (approvedLocales &&
+            approvedLocales.some(function (approvedLocale) { return !_isValidLocale(approvedLocale, customMapping); }))) {
+        return false;
+    }
+    // Check if the languages are identical, if so, a translation is not required
+    if (_isSameDialect(sourceLocale, targetLocale)) {
+        return false;
+    }
+    // Check that the target locale is within the approvedLocales scope, if not, a translation is not required
+    // isSameLanguage rather than checkTwoLocalesAreSameDialect so we can show different dialects as a fallback
+    if (approvedLocales &&
+        !approvedLocales.some(function (approvedLocale) {
+            return _isSameLanguage(targetLocale, approvedLocale);
+        })) {
+        return false;
+    }
+    // Otherwise, a translation is required!
+    return true;
+}

package/dist/locales/resolveAliasLocale.d.ts

@@ -0,0 +1,8 @@
+import { CustomMapping } from './customLocaleMapping';
+/**
+ * Resolves the alias locale for a given locale.
+ * @param locale - The locale to resolve the alias locale for
+ * @param customMapping - The custom mapping to use for resolving the alias locale
+ * @returns The configured alias for a canonical locale, or the input locale when already an alias or no alias mapping exists.
+ */
+export declare function _resolveAliasLocale(locale: string, customMapping?: CustomMapping): string;

package/dist/locales/resolveAliasLocale.js

@@ -0,0 +1,21 @@
+/**
+ * Resolves the alias locale for a given locale.
+ * @param locale - The locale to resolve the alias locale for
+ * @param customMapping - The custom mapping to use for resolving the alias locale
+ * @returns The configured alias for a canonical locale, or the input locale when already an alias or no alias mapping exists.
+ */
+export function _resolveAliasLocale(locale, customMapping) {
+    var reverseCustomMapping;
+    if (customMapping) {
+        reverseCustomMapping = Object.fromEntries(Object.entries(customMapping)
+            .filter(function (_a) {
+            var value = _a[1];
+            return value && typeof value === 'object' && 'code' in value;
+        })
+            .map(function (_a) {
+            var key = _a[0], value = _a[1];
+            return [value.code, key];
+        }));
+    }
+    return (reverseCustomMapping === null || reverseCustomMapping === void 0 ? void 0 : reverseCustomMapping[locale]) || locale;
+}

package/dist/locales/resolveCanonicalLocale.d.ts

@@ -0,0 +1,8 @@
+import { CustomMapping } from './customLocaleMapping';
+/**
+ * Resolves the canonical locale for a given locale.
+ * @param locale - The locale to resolve the canonical locale for
+ * @param customMapping - The custom mapping to use for resolving the canonical locale
+ * @returns The canonical locale, or the input locale when no canonical mapping exists.
+ */
+export declare function _resolveCanonicalLocale(locale: string, customMapping?: CustomMapping): string;

package/dist/locales/resolveCanonicalLocale.js

@@ -0,0 +1,13 @@
+import { shouldUseCanonicalLocale } from './customLocaleMapping';
+/**
+ * Resolves the canonical locale for a given locale.
+ * @param locale - The locale to resolve the canonical locale for
+ * @param customMapping - The custom mapping to use for resolving the canonical locale
+ * @returns The canonical locale, or the input locale when no canonical mapping exists.
+ */
+export function _resolveCanonicalLocale(locale, customMapping) {
+    if (customMapping && shouldUseCanonicalLocale(locale, customMapping)) {
+        return customMapping[locale].code;
+    }
+    return locale;
+}

package/dist/logging/errors.d.ts

@@ -0,0 +1,10 @@
+export declare const translationTimeoutError: (timeout: number) => string;
+export declare const translationRequestFailedError: (error: string) => string;
+export declare const apiError: (status: number, statusText: string, error: string) => string;
+export declare const invalidAuthError = "GT Error: Invalid authentication.";
+export declare const noTargetLocaleProvidedError: (functionName: string) => string;
+export declare const noSourceLocaleProvidedError: (functionName: string) => string;
+export declare const noProjectIdProvidedError: (functionName: string) => string;
+export declare const noApiKeyProvidedError: (functionName: string) => string;
+export declare const invalidLocaleError: (locale: string) => string;
+export declare const invalidLocalesError: (locales: string[]) => string;