@formatjs/intl-displaynames 7.3.1 → 7.3.3

package/index.d.ts

@@ -1,27 +1,102 @@
-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";
+//#region packages/ecma402-abstract/types/core.d.ts
+type Locale = string;
+interface LocaleData<T> {
+  data: T;
+  locale: Locale;
 }
-export interface DisplayNamesResolvedOptions {
-	locale: string;
-	style: NonNullable<DisplayNamesOptions["style"]>;
-	type: NonNullable<DisplayNamesOptions["type"]>;
-	fallback: NonNullable<DisplayNamesOptions["fallback"]>;
-	languageDisplay: NonNullable<DisplayNamesOptions["languageDisplay"]>;
+//#endregion
+//#region packages/ecma402-abstract/types/displaynames.d.ts
+type LanguageTag = string;
+type RegionCode = string;
+type ScriptCode = string;
+type CurrencyCode = string;
+type CalendarCode = string;
+type DateTimeFieldCode = string;
+interface DisplayNamesData {
+  /**
+  * Note that for style fields, `short` and `narrow` might not exist.
+  * At runtime, the fallback order will be narrow -> short -> long.
+  */
+  types: {
+    /**
+    * Maps language subtag like `zh-CN` to their display names.
+    */
+    language: {
+      dialect: {
+        narrow: Record<LanguageTag, string>;
+        short: Record<LanguageTag, string>;
+        long: Record<LanguageTag, string>;
+      };
+      standard: {
+        narrow: Record<LanguageTag, string>;
+        short: Record<LanguageTag, string>;
+        long: Record<LanguageTag, string>;
+      };
+    };
+    region: {
+      narrow: Record<RegionCode, string>;
+      short: Record<RegionCode, string>;
+      long: Record<RegionCode, string>;
+    };
+    script: {
+      narrow: Record<ScriptCode, string>;
+      short: Record<ScriptCode, string>;
+      long: Record<ScriptCode, string>;
+    };
+    currency: {
+      narrow: Record<CurrencyCode, string>;
+      short: Record<CurrencyCode, string>;
+      long: Record<CurrencyCode, string>;
+    };
+    calendar: {
+      narrow: Record<CalendarCode, string>;
+      short: Record<CalendarCode, string>;
+      long: Record<CalendarCode, string>;
+    };
+    dateTimeField: {
+      narrow: Record<DateTimeFieldCode, string>;
+      short: Record<DateTimeFieldCode, string>;
+      long: Record<DateTimeFieldCode, string>;
+    };
+  };
+  /**
+  * Not in spec, but we need this to display both language and region in display name.
+  * e.g. zh-Hans-SG + "{0}（{1}）" -> 简体中文（新加坡）
+  * Here {0} is replaced by language display name and {1} is replaced by region display name.
+  */
+  patterns: {
+    locale: string;
+  };
 }
-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;
+type DisplayNamesLocaleData = LocaleData<DisplayNamesData>;
+//#endregion
+//#region packages/intl-displaynames/index.d.ts
+interface DisplayNamesOptions {
+  localeMatcher?: "lookup" | "best fit";
+  style?: "narrow" | "short" | "long";
+  type: "language" | "region" | "script" | "currency" | "calendar" | "dateTimeField";
+  fallback?: "code" | "none";
+  languageDisplay?: "dialect" | "standard";
 }
+interface DisplayNamesResolvedOptions {
+  locale: string;
+  style: NonNullable<DisplayNamesOptions["style"]>;
+  type: NonNullable<DisplayNamesOptions["type"]>;
+  fallback: NonNullable<DisplayNamesOptions["fallback"]>;
+  languageDisplay: NonNullable<DisplayNamesOptions["languageDisplay"]>;
+}
+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;
+}
+//#endregion
+export { DisplayNames, DisplayNamesOptions, DisplayNamesResolvedOptions };
+//# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1,18 +1,256 @@
-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 {
+import { LookupSupportedLocales, ResolveLocale } from "@formatjs/intl-localematcher";
+//#region packages/ecma262-abstract/ToString.js
+/**
+* https://tc39.es/ecma262/#sec-tostring
+*/
+function ToString(o) {
+	if (typeof o === "symbol") throw TypeError("Cannot convert a Symbol value to a string");
+	return String(o);
+}
+//#endregion
+//#region packages/ecma402-abstract/CanonicalizeLocaleList.js
+/**
+* http://ecma-international.org/ecma-402/7.0/index.html#sec-canonicalizelocalelist
+* @param locales
+*/
+function CanonicalizeLocaleList(locales) {
+	return Intl.getCanonicalLocales(locales);
+}
+//#endregion
+//#region packages/ecma402-abstract/GetOption.js
+/**
+* https://tc39.es/ecma402/#sec-getoption
+* @param opts
+* @param prop
+* @param type
+* @param values
+* @param fallback
+*/
+function GetOption(opts, prop, type, values, fallback) {
+	if (typeof opts !== "object") throw new TypeError("Options must be an object");
+	let value = opts[prop];
+	if (value !== void 0) {
+		if (type !== "boolean" && type !== "string") throw new TypeError("invalid type");
+		if (type === "boolean") value = Boolean(value);
+		if (type === "string") value = ToString(value);
+		if (values !== void 0 && !values.filter((val) => val == value).length) throw new RangeError(`${value} is not within ${values.join(", ")}`);
+		return value;
+	}
+	return fallback;
+}
+//#endregion
+//#region packages/ecma402-abstract/GetOptionsObject.js
+/**
+* https://tc39.es/ecma402/#sec-getoptionsobject
+* @param options
+* @returns
+*/
+function GetOptionsObject(options) {
+	if (typeof options === "undefined") return Object.create(null);
+	if (typeof options === "object") return options;
+	throw new TypeError("Options must be an object");
+}
+//#endregion
+//#region packages/ecma402-abstract/IsWellFormedCurrencyCode.js
+/**
+* This follows https://tc39.es/ecma402/#sec-case-sensitivity-and-case-mapping
+* @param str string to convert
+*/
+function toUpperCase(str) {
+	return str.replace(/([a-z])/g, (_, c) => c.toUpperCase());
+}
+const NOT_A_Z_REGEX = /[^A-Z]/;
+/**
+* https://tc39.es/ecma402/#sec-iswellformedcurrencycode
+*/
+function IsWellFormedCurrencyCode(currency) {
+	currency = toUpperCase(currency);
+	if (currency.length !== 3) return false;
+	if (NOT_A_Z_REGEX.test(currency)) return false;
+	return true;
+}
+//#endregion
+//#region packages/ecma262-abstract/ToObject.js
+/**
+* https://tc39.es/ecma262/#sec-toobject
+*/
+function ToObject(arg) {
+	if (arg == null) throw new TypeError("undefined/null cannot be converted to object");
+	return Object(arg);
+}
+//#endregion
+//#region packages/ecma402-abstract/SupportedLocales.js
+/**
+* https://tc39.es/ecma402/#sec-supportedlocales
+* @param availableLocales
+* @param requestedLocales
+* @param options
+*/
+function SupportedLocales(availableLocales, requestedLocales, options) {
+	let matcher = "best fit";
+	if (options !== void 0) {
+		options = ToObject(options);
+		matcher = GetOption(options, "localeMatcher", "string", ["lookup", "best fit"], "best fit");
+	}
+	if (matcher === "best fit") return LookupSupportedLocales(Array.from(availableLocales), requestedLocales);
+	return LookupSupportedLocales(Array.from(availableLocales), requestedLocales);
+}
+//#endregion
+//#region node_modules/.aspect_rules_js/@formatjs+fast-memoize@0.0.0/node_modules/@formatjs/fast-memoize/index.js
+function memoize(fn, options) {
+	const cache = options && options.cache ? options.cache : cacheDefault;
+	const serializer = options && options.serializer ? options.serializer : serializerDefault;
+	return (options && options.strategy ? options.strategy : strategyDefault)(fn, {
+		cache,
+		serializer
+	});
+}
+function isPrimitive(value) {
+	return value == null || typeof value === "number" || typeof value === "boolean";
+}
+function monadic(fn, cache, serializer, arg) {
+	const cacheKey = isPrimitive(arg) ? arg : serializer(arg);
+	let computedValue = cache.get(cacheKey);
+	if (typeof computedValue === "undefined") {
+		computedValue = fn.call(this, arg);
+		cache.set(cacheKey, computedValue);
+	}
+	return computedValue;
+}
+function variadic(fn, cache, serializer) {
+	const args = Array.prototype.slice.call(arguments, 3);
+	const cacheKey = serializer(args);
+	let computedValue = cache.get(cacheKey);
+	if (typeof computedValue === "undefined") {
+		computedValue = fn.apply(this, args);
+		cache.set(cacheKey, computedValue);
+	}
+	return computedValue;
+}
+function assemble(fn, context, strategy, cache, serialize) {
+	return strategy.bind(context, fn, cache, serialize);
+}
+function strategyDefault(fn, options) {
+	const strategy = fn.length === 1 ? monadic : variadic;
+	return assemble(fn, this, strategy, options.cache.create(), options.serializer);
+}
+function strategyVariadic(fn, options) {
+	return assemble(fn, this, variadic, options.cache.create(), options.serializer);
+}
+function strategyMonadic(fn, options) {
+	return assemble(fn, this, monadic, options.cache.create(), options.serializer);
+}
+const serializerDefault = function() {
+	return JSON.stringify(arguments);
+};
+var ObjectWithoutPrototypeCache = class {
+	constructor() {
+		this.cache = Object.create(null);
+	}
+	get(key) {
+		return this.cache[key];
+	}
+	set(key, value) {
+		this.cache[key] = value;
+	}
+};
+const cacheDefault = { create: function create() {
+	return new ObjectWithoutPrototypeCache();
+} };
+const strategies = {
+	variadic: strategyVariadic,
+	monadic: strategyMonadic
+};
+//#endregion
+//#region packages/ecma402-abstract/utils.js
+function setInternalSlot(map, pl, field, value) {
+	if (!map.get(pl)) map.set(pl, Object.create(null));
+	const slots = map.get(pl);
+	slots[field] = value;
+}
+function getInternalSlot(map, pl, field) {
+	return getMultiInternalSlots(map, pl, field)[field];
+}
+function getMultiInternalSlots(map, pl, ...fields) {
+	const slots = map.get(pl);
+	if (!slots) throw new TypeError(`${pl} InternalSlot has not been initialized`);
+	return fields.reduce((all, f) => {
+		all[f] = slots[f];
+		return all;
+	}, Object.create(null));
+}
+function invariant(condition, message, Err = Error) {
+	if (!condition) throw new Err(message);
+}
+memoize((...args) => new Intl.NumberFormat(...args), { strategy: strategies.variadic });
+memoize((...args) => new Intl.PluralRules(...args), { strategy: strategies.variadic });
+memoize((...args) => new Intl.Locale(...args), { strategy: strategies.variadic });
+memoize((...args) => new Intl.ListFormat(...args), { strategy: strategies.variadic });
+//#endregion
+//#region packages/ecma402-abstract/DisplayNames/IsValidDateTimeFieldCode.js
+const CODES_FOR_DATE_TIME_FIELD = [
+	"era",
+	"year",
+	"quarter",
+	"month",
+	"weekOfYear",
+	"weekday",
+	"day",
+	"dayPeriod",
+	"hour",
+	"minute",
+	"second",
+	"timeZoneName"
+];
+function IsValidDateTimeFieldCode(field) {
+	return CODES_FOR_DATE_TIME_FIELD.indexOf(field) >= 0;
+}
+//#endregion
+//#region packages/ecma402-abstract/DisplayNames/CanonicalCodeForDisplayNames.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);
+}
+function isUnicodeScriptSubtag(script) {
+	return ALPHA_4.test(script);
+}
+function isUnicodeLocaleIdentifierType(code) {
+	return UNICODE_TYPE_REGEX.test(code);
+}
+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 `${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();
+}
+//#endregion
+//#region packages/intl-displaynames/index.ts
+var DisplayNames = class DisplayNames {
 	constructor(locales, options) {
-		if (new.target === undefined) {
-			throw TypeError(`Constructor Intl.DisplayNames requires 'new'`);
-		}
+		if (new.target === void 0) 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;
+		opt.localeMatcher = GetOption(options, "localeMatcher", "string", ["lookup", "best fit"], "best fit");
 		const r = ResolveLocale(Array.from(DisplayNames.availableLocales), requestedLocales, opt, [], DisplayNames.localeData, DisplayNames.getDefaultLocale);
 		const style = GetOption(options, "style", "string", [
 			"narrow",
@@ -27,10 +265,8 @@ export class DisplayNames {
 			"currency",
 			"calendar",
 			"dateTimeField"
-		], undefined);
-		if (type === undefined) {
-			throw TypeError(`Intl.DisplayNames constructor requires "type" option`);
-		}
+		], void 0);
+		if (type === void 0) 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);
@@ -39,7 +275,7 @@ export class DisplayNames {
 		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.`);
+		invariant(dataLocaleData !== void 0, `locale data for ${r.locale} does not exist.`);
 		const { types } = dataLocaleData;
 		invariant(typeof types === "object" && types != null, "invalid types data");
 		const typeFields = types[type];
@@ -47,11 +283,9 @@ export class DisplayNames {
 		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);
@@ -65,83 +299,62 @@ export class DisplayNames {
 			DisplayNames.localeData[locale] = DisplayNames.localeData[minimizedLocale] = d;
 			DisplayNames.availableLocales.add(minimizedLocale);
 			DisplayNames.availableLocales.add(locale);
-			if (!DisplayNames.__defaultLocale) {
-				DisplayNames.__defaultLocale = minimizedLocale;
-			}
+			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");
-		}
+		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
+		if (type === "language") name = getNameForTypeLanguage(getSlot(this, "languageDisplay"), localeData, style, canonicalCode, fallback);
+		else {
 			const typesData = localeData.types[type];
 			name = typesData[style][canonicalCode] || typesData.long[canonicalCode];
 		}
-		if (name !== undefined) {
-			return name;
-		}
-		if (fallback === "code") {
-			return codeAsString;
-		}
+		if (name !== void 0) 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 {
+		this.localeData = {};
+	}
+	static {
+		this.availableLocales = /* @__PURE__ */ new Set();
+	}
+	static {
+		this.__defaultLocale = "";
+	}
 	static getDefaultLocale() {
 		return DisplayNames.__defaultLocale;
 	}
-	static polyfilled = true;
-}
-// https://tc39.es/proposal-intl-displaynames/#sec-isvalidcodefordisplaynames
+	static {
+		this.polyfilled = true;
+	}
+};
 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 "language": 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": return /^([a-z]{2}|\d{3})$/i.test(code);
+		case "script": 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 "calendar": 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
-		});
-	}
+	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,
@@ -149,7 +362,7 @@ try {
 		configurable: true
 	});
 } catch {}
-const __INTERNAL_SLOT_MAP__ = new WeakMap();
+const __INTERNAL_SLOT_MAP__ = /* @__PURE__ */ new WeakMap();
 function getSlot(instance, key) {
 	return getInternalSlot(__INTERNAL_SLOT_MAP__, instance, key);
 }
@@ -157,40 +370,26 @@ function setSlot(instance, key, value) {
 	setInternalSlot(__INTERNAL_SLOT_MAP__, instance, key, value);
 }
 function checkReceiver(receiver, methodName) {
-	if (!(receiver instanceof DisplayNames)) {
-		throw TypeError(`Method Intl.DisplayNames.prototype.${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
 	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
+	if (name === void 0) {
 		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
+			if (name !== void 0 && regionSubTag) {
 				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;
-			}
+				if (regionDisplayName || fallback === "code") return localeData.patterns.locale.replace("{0}", name).replace("{1}", regionDisplayName || regionSubTag);
+			} else return name;
 		}
-	} else {
-		return name;
-	}
+	} else return name;
 }
+//#endregion
+export { DisplayNames };
+
+//# sourceMappingURL=index.js.map