@formatjs/intl-displaynames 7.1.1 → 7.2.0

package/abstract/CanonicalCodeForDisplayNames.d.ts

@@ -1 +1 @@
-export declare function CanonicalCodeForDisplayNames(type: 'language' | 'region' | 'script' | 'calendar' | 'dateTimeField' | 'currency', code: string): string;
+export declare function CanonicalCodeForDisplayNames(type: "language" | "region" | "script" | "calendar" | "dateTimeField" | "currency", code: string): string;

package/abstract/CanonicalCodeForDisplayNames.js

@@ -1,48 +1,48 @@
-import { CanonicalizeLocaleList, invariant, IsWellFormedCurrencyCode, } from '@formatjs/ecma402-abstract';
-import { IsValidDateTimeFieldCode } from './IsValidDateTimeFieldCode';
-var UNICODE_REGION_SUBTAG_REGEX = /^([a-z]{2}|[0-9]{3})$/i;
-var ALPHA_4 = /^[a-z]{4}$/i;
-var UNICODE_TYPE_REGEX = /^[a-z0-9]{3,8}([-_][a-z0-9]{3,8})*$/i;
+import { CanonicalizeLocaleList, invariant, IsWellFormedCurrencyCode } from "@formatjs/ecma402-abstract";
+import { IsValidDateTimeFieldCode } from "./IsValidDateTimeFieldCode.js";
+const UNICODE_REGION_SUBTAG_REGEX = /^([a-z]{2}|[0-9]{3})$/i;
+const ALPHA_4 = /^[a-z]{4}$/i;
+const UNICODE_TYPE_REGEX = /^[a-z0-9]{3,8}([-_][a-z0-9]{3,8})*$/i;
 function isUnicodeRegionSubtag(region) {
-    return UNICODE_REGION_SUBTAG_REGEX.test(region);
+	return UNICODE_REGION_SUBTAG_REGEX.test(region);
 }
 function isUnicodeScriptSubtag(script) {
-    return ALPHA_4.test(script);
+	return ALPHA_4.test(script);
 }
 function isUnicodeLocaleIdentifierType(code) {
-    return UNICODE_TYPE_REGEX.test(code);
+	return UNICODE_TYPE_REGEX.test(code);
 }
 export function CanonicalCodeForDisplayNames(type, code) {
-    if (type === 'language') {
-        return CanonicalizeLocaleList([code])[0];
-    }
-    if (type === 'region') {
-        if (!isUnicodeRegionSubtag(code)) {
-            throw RangeError('invalid region');
-        }
-        return code.toUpperCase();
-    }
-    if (type === 'script') {
-        if (!isUnicodeScriptSubtag(code)) {
-            throw RangeError('invalid script');
-        }
-        return "".concat(code[0].toUpperCase()).concat(code.slice(1).toLowerCase());
-    }
-    if (type === 'calendar') {
-        if (!isUnicodeLocaleIdentifierType(code)) {
-            throw RangeError('invalid calendar');
-        }
-        return code.toLowerCase();
-    }
-    if (type === 'dateTimeField') {
-        if (!IsValidDateTimeFieldCode(code)) {
-            throw RangeError('invalid dateTimeField');
-        }
-        return code;
-    }
-    invariant(type === 'currency', 'invalid type');
-    if (!IsWellFormedCurrencyCode(code)) {
-        throw RangeError('invalid currency');
-    }
-    return code.toUpperCase();
+	if (type === "language") {
+		return CanonicalizeLocaleList([code])[0];
+	}
+	if (type === "region") {
+		if (!isUnicodeRegionSubtag(code)) {
+			throw RangeError("invalid region");
+		}
+		return code.toUpperCase();
+	}
+	if (type === "script") {
+		if (!isUnicodeScriptSubtag(code)) {
+			throw RangeError("invalid script");
+		}
+		return `${code[0].toUpperCase()}${code.slice(1).toLowerCase()}`;
+	}
+	if (type === "calendar") {
+		if (!isUnicodeLocaleIdentifierType(code)) {
+			throw RangeError("invalid calendar");
+		}
+		return code.toLowerCase();
+	}
+	if (type === "dateTimeField") {
+		if (!IsValidDateTimeFieldCode(code)) {
+			throw RangeError("invalid dateTimeField");
+		}
+		return code;
+	}
+	invariant(type === "currency", "invalid type");
+	if (!IsWellFormedCurrencyCode(code)) {
+		throw RangeError("invalid currency");
+	}
+	return code.toUpperCase();
 }

package/abstract/IsValidDateTimeFieldCode.js

@@ -1,17 +1,17 @@
-var CODES_FOR_DATE_TIME_FIELD = [
-    'era',
-    'year',
-    'quarter',
-    'month',
-    'weekOfYear',
-    'weekday',
-    'day',
-    'dayPeriod',
-    'hour',
-    'minute',
-    'second',
-    'timeZoneName',
+const CODES_FOR_DATE_TIME_FIELD = [
+	"era",
+	"year",
+	"quarter",
+	"month",
+	"weekOfYear",
+	"weekday",
+	"day",
+	"dayPeriod",
+	"hour",
+	"minute",
+	"second",
+	"timeZoneName"
 ];
 export function IsValidDateTimeFieldCode(field) {
-    return CODES_FOR_DATE_TIME_FIELD.indexOf(field) >= 0;
+	return CODES_FOR_DATE_TIME_FIELD.indexOf(field) >= 0;
 }

package/index.d.ts

@@ -1,27 +1,27 @@
-import { DisplayNamesData, DisplayNamesLocaleData } from '@formatjs/ecma402-abstract';
+import { type DisplayNamesData, type DisplayNamesLocaleData } from "@formatjs/ecma402-abstract";
 export interface DisplayNamesOptions {
-    localeMatcher?: 'lookup' | 'best fit';
-    style?: 'narrow' | 'short' | 'long';
-    type: 'language' | 'region' | 'script' | 'currency' | 'calendar' | 'dateTimeField';
-    fallback?: 'code' | 'none';
-    languageDisplay?: 'dialect' | 'standard';
+	localeMatcher?: "lookup" | "best fit";
+	style?: "narrow" | "short" | "long";
+	type: "language" | "region" | "script" | "currency" | "calendar" | "dateTimeField";
+	fallback?: "code" | "none";
+	languageDisplay?: "dialect" | "standard";
 }
 export interface DisplayNamesResolvedOptions {
-    locale: string;
-    style: NonNullable<DisplayNamesOptions['style']>;
-    type: NonNullable<DisplayNamesOptions['type']>;
-    fallback: NonNullable<DisplayNamesOptions['fallback']>;
-    languageDisplay: NonNullable<DisplayNamesOptions['languageDisplay']>;
+	locale: string;
+	style: NonNullable<DisplayNamesOptions["style"]>;
+	type: NonNullable<DisplayNamesOptions["type"]>;
+	fallback: NonNullable<DisplayNamesOptions["fallback"]>;
+	languageDisplay: NonNullable<DisplayNamesOptions["languageDisplay"]>;
 }
 export declare class DisplayNames {
-    constructor(locales: string | string[] | undefined, options: DisplayNamesOptions);
-    static supportedLocalesOf(locales?: string | string[], options?: Pick<DisplayNamesOptions, 'localeMatcher'>): string[];
-    static __addLocaleData(...data: DisplayNamesLocaleData[]): void;
-    of(code: string | number | Record<string, unknown>): string | undefined;
-    resolvedOptions(): DisplayNamesResolvedOptions;
-    static localeData: Record<string, DisplayNamesData | undefined>;
-    private static availableLocales;
-    private static __defaultLocale;
-    private static getDefaultLocale;
-    static readonly polyfilled = true;
+	constructor(locales: string | string[] | undefined, options: DisplayNamesOptions);
+	static supportedLocalesOf(locales?: string | string[], options?: Pick<DisplayNamesOptions, "localeMatcher">): string[];
+	static __addLocaleData(...data: DisplayNamesLocaleData[]): void;
+	of(code: string | number | Record<string, unknown>): string | undefined;
+	resolvedOptions(): DisplayNamesResolvedOptions;
+	static localeData: Record<string, DisplayNamesData | undefined>;
+	private static availableLocales;
+	private static __defaultLocale;
+	private static getDefaultLocale;
+	static readonly polyfilled: true;
 }

package/index.js

@@ -1,210 +1,196 @@
-import { __assign } from "tslib";
-import { CanonicalizeLocaleList, GetOption, GetOptionsObject, IsWellFormedCurrencyCode, SupportedLocales, ToString, getInternalSlot, getMultiInternalSlots, invariant, setInternalSlot, } from '@formatjs/ecma402-abstract';
-import { CanonicalCodeForDisplayNames } from './abstract/CanonicalCodeForDisplayNames.js';
-import { IsValidDateTimeFieldCode } from './abstract/IsValidDateTimeFieldCode.js';
-import { ResolveLocale } from '@formatjs/intl-localematcher';
-var DisplayNames = /** @class */ (function () {
-    function DisplayNames(locales, options) {
-        var _newTarget = this.constructor;
-        if (_newTarget === undefined) {
-            throw TypeError("Constructor Intl.DisplayNames requires 'new'");
-        }
-        var requestedLocales = CanonicalizeLocaleList(locales);
-        options = GetOptionsObject(options);
-        var opt = Object.create(null);
-        var localeData = DisplayNames.localeData;
-        var matcher = GetOption(options, 'localeMatcher', 'string', ['lookup', 'best fit'], 'best fit');
-        opt.localeMatcher = matcher;
-        var r = ResolveLocale(Array.from(DisplayNames.availableLocales), requestedLocales, opt, [], // there is no relevantExtensionKeys
-        DisplayNames.localeData, DisplayNames.getDefaultLocale);
-        var style = GetOption(options, 'style', 'string', ['narrow', 'short', 'long'], 'long');
-        setSlot(this, 'style', style);
-        var type = GetOption(options, 'type', 'string', ['language', 'region', 'script', 'currency', 'calendar', 'dateTimeField'], undefined);
-        if (type === undefined) {
-            throw TypeError("Intl.DisplayNames constructor requires \"type\" option");
-        }
-        setSlot(this, 'type', type);
-        var fallback = GetOption(options, 'fallback', 'string', ['code', 'none'], 'code');
-        setSlot(this, 'fallback', fallback);
-        setSlot(this, 'locale', r.locale);
-        var dataLocale = r.dataLocale;
-        var dataLocaleData = localeData[dataLocale];
-        invariant(!!dataLocaleData, "Missing locale data for ".concat(dataLocale));
-        setSlot(this, 'localeData', dataLocaleData);
-        invariant(dataLocaleData !== undefined, "locale data for ".concat(r.locale, " does not exist."));
-        var types = dataLocaleData.types;
-        invariant(typeof types === 'object' && types != null, 'invalid types data');
-        var typeFields = types[type];
-        invariant(typeof typeFields === 'object' && typeFields != null, 'invalid typeFields data');
-        var languageDisplay = GetOption(options, 'languageDisplay', 'string', ['dialect', 'standard'], 'dialect');
-        if (type === 'language') {
-            setSlot(this, 'languageDisplay', languageDisplay);
-            // Using types[type] instead of typeFields because TypeScript cannot infer the correct type
-            var typeFields_1 = types[type][languageDisplay];
-            invariant(typeof typeFields_1 === 'object' && typeFields_1 != null, 'invalid language typeFields data');
-        }
-        // Using types[type] instead of typeFields because TypeScript cannot infer the correct type
-        var styleFields = type === 'language'
-            ? types[type][languageDisplay][style]
-            : types[type][style];
-        invariant(typeof styleFields === 'object' && styleFields != null, 'invalid styleFields data');
-        setSlot(this, 'fields', styleFields);
-    }
-    DisplayNames.supportedLocalesOf = function (locales, options) {
-        return SupportedLocales(DisplayNames.availableLocales, CanonicalizeLocaleList(locales), options);
-    };
-    DisplayNames.__addLocaleData = function () {
-        var data = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            data[_i] = arguments[_i];
-        }
-        for (var _a = 0, data_1 = data; _a < data_1.length; _a++) {
-            var _b = data_1[_a], d = _b.data, locale = _b.locale;
-            var minimizedLocale = new Intl.Locale(locale)
-                .minimize()
-                .toString();
-            DisplayNames.localeData[locale] = DisplayNames.localeData[minimizedLocale] = d;
-            DisplayNames.availableLocales.add(minimizedLocale);
-            DisplayNames.availableLocales.add(locale);
-            if (!DisplayNames.__defaultLocale) {
-                DisplayNames.__defaultLocale = minimizedLocale;
-            }
-        }
-    };
-    DisplayNames.prototype.of = function (code) {
-        checkReceiver(this, 'of');
-        var type = getSlot(this, 'type');
-        var codeAsString = ToString(code);
-        if (!isValidCodeForDisplayNames(type, codeAsString)) {
-            throw RangeError('invalid code for Intl.DisplayNames.prototype.of');
-        }
-        var _a = getMultiInternalSlots(__INTERNAL_SLOT_MAP__, this, 'localeData', 'style', 'fallback'), localeData = _a.localeData, style = _a.style, fallback = _a.fallback;
-        // Canonicalize the case.
-        var canonicalCode = CanonicalCodeForDisplayNames(type, codeAsString);
-        var name;
-        if (type === 'language') {
-            var languageDisplay = getSlot(this, 'languageDisplay');
-            name = getNameForTypeLanguage(languageDisplay, localeData, style, canonicalCode, fallback);
-        }
-        else {
-            // All the other types
-            var typesData = localeData.types[type];
-            name = typesData[style][canonicalCode] || typesData.long[canonicalCode];
-        }
-        if (name !== undefined) {
-            return name;
-        }
-        if (fallback === 'code') {
-            return codeAsString;
-        }
-    };
-    DisplayNames.prototype.resolvedOptions = function () {
-        checkReceiver(this, 'resolvedOptions');
-        return __assign({}, getMultiInternalSlots(__INTERNAL_SLOT_MAP__, this, 'locale', 'style', 'type', 'fallback', 'languageDisplay'));
-    };
-    DisplayNames.getDefaultLocale = function () {
-        return DisplayNames.__defaultLocale;
-    };
-    DisplayNames.localeData = {};
-    DisplayNames.availableLocales = new Set();
-    DisplayNames.__defaultLocale = '';
-    DisplayNames.polyfilled = true;
-    return DisplayNames;
-}());
-export { DisplayNames };
+import { CanonicalizeLocaleList, GetOption, GetOptionsObject, IsWellFormedCurrencyCode, SupportedLocales, ToString, getInternalSlot, getMultiInternalSlots, invariant, setInternalSlot } from "@formatjs/ecma402-abstract";
+import { CanonicalCodeForDisplayNames } from "./abstract/CanonicalCodeForDisplayNames.js";
+import { IsValidDateTimeFieldCode } from "./abstract/IsValidDateTimeFieldCode.js";
+import { ResolveLocale } from "@formatjs/intl-localematcher";
+export class DisplayNames {
+	constructor(locales, options) {
+		if (new.target === undefined) {
+			throw TypeError(`Constructor Intl.DisplayNames requires 'new'`);
+		}
+		const requestedLocales = CanonicalizeLocaleList(locales);
+		options = GetOptionsObject(options);
+		const opt = Object.create(null);
+		const { localeData } = DisplayNames;
+		const matcher = GetOption(options, "localeMatcher", "string", ["lookup", "best fit"], "best fit");
+		opt.localeMatcher = matcher;
+		const r = ResolveLocale(Array.from(DisplayNames.availableLocales), requestedLocales, opt, [], DisplayNames.localeData, DisplayNames.getDefaultLocale);
+		const style = GetOption(options, "style", "string", [
+			"narrow",
+			"short",
+			"long"
+		], "long");
+		setSlot(this, "style", style);
+		const type = GetOption(options, "type", "string", [
+			"language",
+			"region",
+			"script",
+			"currency",
+			"calendar",
+			"dateTimeField"
+		], undefined);
+		if (type === undefined) {
+			throw TypeError(`Intl.DisplayNames constructor requires "type" option`);
+		}
+		setSlot(this, "type", type);
+		const fallback = GetOption(options, "fallback", "string", ["code", "none"], "code");
+		setSlot(this, "fallback", fallback);
+		setSlot(this, "locale", r.locale);
+		const { dataLocale } = r;
+		const dataLocaleData = localeData[dataLocale];
+		invariant(!!dataLocaleData, `Missing locale data for ${dataLocale}`);
+		setSlot(this, "localeData", dataLocaleData);
+		invariant(dataLocaleData !== undefined, `locale data for ${r.locale} does not exist.`);
+		const { types } = dataLocaleData;
+		invariant(typeof types === "object" && types != null, "invalid types data");
+		const typeFields = types[type];
+		invariant(typeof typeFields === "object" && typeFields != null, "invalid typeFields data");
+		const languageDisplay = GetOption(options, "languageDisplay", "string", ["dialect", "standard"], "dialect");
+		if (type === "language") {
+			setSlot(this, "languageDisplay", languageDisplay);
+			// Using types[type] instead of typeFields because TypeScript cannot infer the correct type
+			const typeFields = types[type][languageDisplay];
+			invariant(typeof typeFields === "object" && typeFields != null, "invalid language typeFields data");
+		}
+		// Using types[type] instead of typeFields because TypeScript cannot infer the correct type
+		const styleFields = type === "language" ? types[type][languageDisplay][style] : types[type][style];
+		invariant(typeof styleFields === "object" && styleFields != null, "invalid styleFields data");
+		setSlot(this, "fields", styleFields);
+	}
+	static supportedLocalesOf(locales, options) {
+		return SupportedLocales(DisplayNames.availableLocales, CanonicalizeLocaleList(locales), options);
+	}
+	static __addLocaleData(...data) {
+		for (const { data: d, locale } of data) {
+			const minimizedLocale = new Intl.Locale(locale).minimize().toString();
+			DisplayNames.localeData[locale] = DisplayNames.localeData[minimizedLocale] = d;
+			DisplayNames.availableLocales.add(minimizedLocale);
+			DisplayNames.availableLocales.add(locale);
+			if (!DisplayNames.__defaultLocale) {
+				DisplayNames.__defaultLocale = minimizedLocale;
+			}
+		}
+	}
+	of(code) {
+		checkReceiver(this, "of");
+		const type = getSlot(this, "type");
+		const codeAsString = ToString(code);
+		if (!isValidCodeForDisplayNames(type, codeAsString)) {
+			throw RangeError("invalid code for Intl.DisplayNames.prototype.of");
+		}
+		const { localeData, style, fallback } = getMultiInternalSlots(__INTERNAL_SLOT_MAP__, this, "localeData", "style", "fallback");
+		// Canonicalize the case.
+		let canonicalCode = CanonicalCodeForDisplayNames(type, codeAsString);
+		let name;
+		if (type === "language") {
+			const languageDisplay = getSlot(this, "languageDisplay");
+			name = getNameForTypeLanguage(languageDisplay, localeData, style, canonicalCode, fallback);
+		} else {
+			// All the other types
+			const typesData = localeData.types[type];
+			name = typesData[style][canonicalCode] || typesData.long[canonicalCode];
+		}
+		if (name !== undefined) {
+			return name;
+		}
+		if (fallback === "code") {
+			return codeAsString;
+		}
+	}
+	resolvedOptions() {
+		checkReceiver(this, "resolvedOptions");
+		return { ...getMultiInternalSlots(__INTERNAL_SLOT_MAP__, this, "locale", "style", "type", "fallback", "languageDisplay") };
+	}
+	static localeData = {};
+	static availableLocales = new Set();
+	static __defaultLocale = "";
+	static getDefaultLocale() {
+		return DisplayNames.__defaultLocale;
+	}
+	static polyfilled = true;
+}
 // https://tc39.es/proposal-intl-displaynames/#sec-isvalidcodefordisplaynames
 function isValidCodeForDisplayNames(type, code) {
-    switch (type) {
-        case 'language':
-            // subset of unicode_language_id
-            // languageCode ["-" scriptCode] ["-" regionCode] *("-" variant)
-            // where:
-            // - languageCode is either a two letters ISO 639-1 language code or a three letters ISO 639-2 language code.
-            // - scriptCode is should be an ISO-15924 four letters script code
-            // - regionCode is either an ISO-3166 two letters region code, or a three digits UN M49 Geographic Regions.
-            return /^[a-z]{2,3}(-[a-z]{4})?(-([a-z]{2}|\d{3}))?(-([a-z\d]{5,8}|\d[a-z\d]{3}))*$/i.test(code);
-        case 'region':
-            // unicode_region_subtag
-            return /^([a-z]{2}|\d{3})$/i.test(code);
-        case 'script':
-            // unicode_script_subtag
-            return /^[a-z]{4}$/i.test(code);
-        case 'currency':
-            return IsWellFormedCurrencyCode(code);
-        case 'calendar':
-            // unicode locale identifier type
-            return /^[a-z0-9]{3,8}([-_][a-z0-9]{3,8})*$/i.test(code);
-        case 'dateTimeField':
-            return IsValidDateTimeFieldCode(code);
-    }
+	switch (type) {
+		case "language":
+ // subset of unicode_language_id
+		// languageCode ["-" scriptCode] ["-" regionCode] *("-" variant)
+		// where:
+		// - languageCode is either a two letters ISO 639-1 language code or a three letters ISO 639-2 language code.
+		// - scriptCode is should be an ISO-15924 four letters script code
+		// - regionCode is either an ISO-3166 two letters region code, or a three digits UN M49 Geographic Regions.
+		return /^[a-z]{2,3}(-[a-z]{4})?(-([a-z]{2}|\d{3}))?(-([a-z\d]{5,8}|\d[a-z\d]{3}))*$/i.test(code);
+		case "region":
+ // unicode_region_subtag
+		return /^([a-z]{2}|\d{3})$/i.test(code);
+		case "script":
+ // unicode_script_subtag
+		return /^[a-z]{4}$/i.test(code);
+		case "currency": return IsWellFormedCurrencyCode(code);
+		case "calendar":
+ // unicode locale identifier type
+		return /^[a-z0-9]{3,8}([-_][a-z0-9]{3,8})*$/i.test(code);
+		case "dateTimeField": return IsValidDateTimeFieldCode(code);
+	}
 }
 try {
-    // IE11 does not have Symbol
-    if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
-        Object.defineProperty(DisplayNames.prototype, Symbol.toStringTag, {
-            value: 'Intl.DisplayNames',
-            configurable: true,
-            enumerable: false,
-            writable: false,
-        });
-    }
-    Object.defineProperty(DisplayNames, 'length', {
-        value: 2,
-        writable: false,
-        enumerable: false,
-        configurable: true,
-    });
-}
-catch (_a) {
-    // Make test 262 compliant
-}
-var __INTERNAL_SLOT_MAP__ = new WeakMap();
+	// IE11 does not have Symbol
+	if (typeof Symbol !== "undefined" && Symbol.toStringTag) {
+		Object.defineProperty(DisplayNames.prototype, Symbol.toStringTag, {
+			value: "Intl.DisplayNames",
+			configurable: true,
+			enumerable: false,
+			writable: false
+		});
+	}
+	Object.defineProperty(DisplayNames, "length", {
+		value: 2,
+		writable: false,
+		enumerable: false,
+		configurable: true
+	});
+} catch {}
+const __INTERNAL_SLOT_MAP__ = new WeakMap();
 function getSlot(instance, key) {
-    return getInternalSlot(__INTERNAL_SLOT_MAP__, instance, key);
+	return getInternalSlot(__INTERNAL_SLOT_MAP__, instance, key);
 }
 function setSlot(instance, key, value) {
-    setInternalSlot(__INTERNAL_SLOT_MAP__, instance, key, value);
+	setInternalSlot(__INTERNAL_SLOT_MAP__, instance, key, value);
 }
 function checkReceiver(receiver, methodName) {
-    if (!(receiver instanceof DisplayNames)) {
-        throw TypeError("Method Intl.DisplayNames.prototype.".concat(methodName, " called on incompatible receiver"));
-    }
+	if (!(receiver instanceof DisplayNames)) {
+		throw TypeError(`Method Intl.DisplayNames.prototype.${methodName} called on incompatible receiver`);
+	}
 }
 function getNameForTypeLanguage(languageDisplay, localeData, style, canonicalCode, fallback) {
-    // First, try to get the name using the canonicalCode
-    var typesData = localeData.types.language[languageDisplay];
-    var name = typesData[style][canonicalCode] || typesData.long[canonicalCode];
-    if (name === undefined) {
-        // If no name has been found using the canonicalCode,
-        // check if the latter contains a region sub tag
-        var regionMatch = /-([a-z]{2}|\d{3})\b/i.exec(canonicalCode);
-        if (regionMatch) {
-            // Extract the language and region sub tags
-            var languageSubTag = canonicalCode.substring(0, regionMatch.index) +
-                canonicalCode.substring(regionMatch.index + regionMatch[0].length);
-            var regionSubTag = regionMatch[1];
-            // Let's try again using languageSubTag this time
-            var name_1 = typesData[style][languageSubTag] || typesData.long[languageSubTag];
-            // If a name has been found and a region sub tag exists,
-            // compose them together or use the code fallback
-            if (name_1 !== undefined && regionSubTag) {
-                // Retrieve region display names
-                var regionsData = localeData.types.region;
-                var regionDisplayName = regionsData[style][regionSubTag] || regionsData.long[regionSubTag];
-                if (regionDisplayName || fallback === 'code') {
-                    // Interpolate into locale-specific pattern.
-                    var pattern = localeData.patterns.locale;
-                    return pattern
-                        .replace('{0}', name_1)
-                        .replace('{1}', regionDisplayName || regionSubTag);
-                }
-            }
-            else {
-                return name_1;
-            }
-        }
-    }
-    else {
-        return name;
-    }
+	// First, try to get the name using the canonicalCode
+	const typesData = localeData.types.language[languageDisplay];
+	const name = typesData[style][canonicalCode] || typesData.long[canonicalCode];
+	if (name === undefined) {
+		// If no name has been found using the canonicalCode,
+		// check if the latter contains a region sub tag
+		const regionMatch = /-([a-z]{2}|\d{3})\b/i.exec(canonicalCode);
+		if (regionMatch) {
+			// Extract the language and region sub tags
+			const languageSubTag = canonicalCode.substring(0, regionMatch.index) + canonicalCode.substring(regionMatch.index + regionMatch[0].length);
+			const regionSubTag = regionMatch[1];
+			// Let's try again using languageSubTag this time
+			const name = typesData[style][languageSubTag] || typesData.long[languageSubTag];
+			// If a name has been found and a region sub tag exists,
+			// compose them together or use the code fallback
+			if (name !== undefined && regionSubTag) {
+				// Retrieve region display names
+				const regionsData = localeData.types.region;
+				const regionDisplayName = regionsData[style][regionSubTag] || regionsData.long[regionSubTag];
+				if (regionDisplayName || fallback === "code") {
+					// Interpolate into locale-specific pattern.
+					const pattern = localeData.patterns.locale;
+					return pattern.replace("{0}", name).replace("{1}", regionDisplayName || regionSubTag);
+				}
+			} else {
+				return name;
+			}
+		}
+	} else {
+		return name;
+	}
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formatjs/intl-displaynames",
   "description": "Polyfill for: https://tc39.es/proposal-intl-displaynames",
-  "version": "7.1.1",
+  "version": "7.2.0",
   "license": "MIT",
   "author": "Linjie Ding <pyrocat101@users.noreply.github.com>",
   "type": "module",
@@ -14,13 +14,13 @@
     "./locale-data/*": "./locale-data/*"
   },
   "dependencies": {
-    "tslib": "^2.8.0",
-    "@formatjs/ecma402-abstract": "3.0.7",
-    "@formatjs/intl-localematcher": "0.7.4"
+    "tslib": "^2.8.1",
+    "@formatjs/ecma402-abstract": "3.1.0",
+    "@formatjs/intl-localematcher": "0.8.0"
   },
   "devDependencies": {
-    "@formatjs/intl-getcanonicallocales": "3.1.1",
-    "@formatjs/intl-locale": "5.1.1"
+    "@formatjs/intl-getcanonicallocales": "3.2.0",
+    "@formatjs/intl-locale": "5.2.0"
   },
   "bugs": "https://github.com/formatjs/formatjs/issues",
   "homepage": "https://github.com/formatjs/formatjs",

package/polyfill-force.js

@@ -1,7 +1,7 @@
-import { DisplayNames } from './index.js';
-Object.defineProperty(Intl, 'DisplayNames', {
-    value: DisplayNames,
-    enumerable: false,
-    writable: true,
-    configurable: true,
+import { DisplayNames } from "./index.js";
+Object.defineProperty(Intl, "DisplayNames", {
+	value: DisplayNames,
+	enumerable: false,
+	writable: true,
+	configurable: true
 });