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 === void 0) throw TypeError(`Constructor Intl.DisplayNames requires 'new'`);
		const requestedLocales = CanonicalizeLocaleList(locales);
		options = GetOptionsObject(options);
		const opt = Object.create(null);
		const { localeData } = DisplayNames;
		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",
			"short",
			"long"
		], "long");
		setSlot(this, "style", style);
		const type = GetOption(options, "type", "string", [
			"language",
			"region",
			"script",
			"currency",
			"calendar",
			"dateTimeField"
		], 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);
		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 !== 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];
		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);
			const typeFields = types[type][languageDisplay];
			invariant(typeof typeFields === "object" && typeFields != null, "invalid language typeFields data");
		}
		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");
		let canonicalCode = CanonicalCodeForDisplayNames(type, codeAsString);
		let name;
		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 !== 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 {
		this.localeData = {};
	}
	static {
		this.availableLocales = /* @__PURE__ */ new Set();
	}
	static {
		this.__defaultLocale = "";
	}
	static getDefaultLocale() {
		return DisplayNames.__defaultLocale;
	}
	static {
		this.polyfilled = true;
	}
};
function isValidCodeForDisplayNames(type, code) {
	switch (type) {
		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": return /^[a-z0-9]{3,8}([-_][a-z0-9]{3,8})*$/i.test(code);
		case "dateTimeField": return IsValidDateTimeFieldCode(code);
	}
}
try {
	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__ = /* @__PURE__ */ new WeakMap();
function getSlot(instance, key) {
	return getInternalSlot(__INTERNAL_SLOT_MAP__, instance, key);
}
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`);
}
function getNameForTypeLanguage(languageDisplay, localeData, style, canonicalCode, fallback) {
	const typesData = localeData.types.language[languageDisplay];
	const name = typesData[style][canonicalCode] || typesData.long[canonicalCode];
	if (name === void 0) {
		const regionMatch = /-([a-z]{2}|\d{3})\b/i.exec(canonicalCode);
		if (regionMatch) {
			const languageSubTag = canonicalCode.substring(0, regionMatch.index) + canonicalCode.substring(regionMatch.index + regionMatch[0].length);
			const regionSubTag = regionMatch[1];
			const name = typesData[style][languageSubTag] || typesData.long[languageSubTag];
			if (name !== void 0 && regionSubTag) {
				const regionsData = localeData.types.region;
				const regionDisplayName = regionsData[style][regionSubTag] || regionsData.long[regionSubTag];
				if (regionDisplayName || fallback === "code") return localeData.patterns.locale.replace("{0}", name).replace("{1}", regionDisplayName || regionSubTag);
			} else return name;
		}
	} else return name;
}
//#endregion
export { DisplayNames };

//# sourceMappingURL=index.js.map