@formatjs/intl 4.0.7 → 4.0.9

package/src/number.js

@@ -1,58 +1,50 @@
-import { IntlFormatError } from './error.js';
-import { filterProps, getNamedFormat } from './utils.js';
-var NUMBER_FORMAT_OPTIONS = [
-    'style',
-    'currency',
-    'unit',
-    'unitDisplay',
-    'useGrouping',
-    'minimumIntegerDigits',
-    'minimumFractionDigits',
-    'maximumFractionDigits',
-    'minimumSignificantDigits',
-    'maximumSignificantDigits',
-    // ES2020 NumberFormat
-    'compactDisplay',
-    'currencyDisplay',
-    'currencySign',
-    'notation',
-    'signDisplay',
-    'unit',
-    'unitDisplay',
-    'numberingSystem',
-    // ES2023 NumberFormat
-    'trailingZeroDisplay',
-    'roundingPriority',
-    'roundingIncrement',
-    'roundingMode',
+import "@formatjs/ecma402-abstract";
+import { IntlFormatError } from "./error.js";
+import "./types.js";
+import { filterProps, getNamedFormat } from "./utils.js";
+const NUMBER_FORMAT_OPTIONS = [
+	"style",
+	"currency",
+	"unit",
+	"unitDisplay",
+	"useGrouping",
+	"minimumIntegerDigits",
+	"minimumFractionDigits",
+	"maximumFractionDigits",
+	"minimumSignificantDigits",
+	"maximumSignificantDigits",
+	"compactDisplay",
+	"currencyDisplay",
+	"currencySign",
+	"notation",
+	"signDisplay",
+	"unit",
+	"unitDisplay",
+	"numberingSystem",
+	"trailingZeroDisplay",
+	"roundingPriority",
+	"roundingIncrement",
+	"roundingMode"
 ];
-export function getFormatter(_a, getNumberFormat, options) {
-    var locale = _a.locale, formats = _a.formats, onError = _a.onError;
-    if (options === void 0) { options = {}; }
-    var format = options.format;
-    var defaults = ((format &&
-        getNamedFormat(formats, 'number', format, onError)) ||
-        {});
-    var filteredOptions = filterProps(options, NUMBER_FORMAT_OPTIONS, defaults);
-    return getNumberFormat(locale, filteredOptions);
+export function getFormatter({ locale, formats, onError }, getNumberFormat, options = {}) {
+	const { format } = options;
+	const defaults = format && getNamedFormat(formats, "number", format, onError) || {};
+	const filteredOptions = filterProps(options, NUMBER_FORMAT_OPTIONS, defaults);
+	return getNumberFormat(locale, filteredOptions);
 }
-export function formatNumber(config, getNumberFormat, value, options) {
-    if (options === void 0) { options = {}; }
-    try {
-        return getFormatter(config, getNumberFormat, options).format(value);
-    }
-    catch (e) {
-        config.onError(new IntlFormatError('Error formatting number.', config.locale, e));
-    }
-    return String(value);
+export function formatNumber(config, getNumberFormat, value, options = {}) {
+	try {
+		return getFormatter(config, getNumberFormat, options).format(value);
+	} catch (e) {
+		config.onError(new IntlFormatError("Error formatting number.", config.locale, e));
+	}
+	return String(value);
 }
-export function formatNumberToParts(config, getNumberFormat, value, options) {
-    if (options === void 0) { options = {}; }
-    try {
-        return getFormatter(config, getNumberFormat, options).formatToParts(value);
-    }
-    catch (e) {
-        config.onError(new IntlFormatError('Error formatting number.', config.locale, e));
-    }
-    return [];
+export function formatNumberToParts(config, getNumberFormat, value, options = {}) {
+	try {
+		return getFormatter(config, getNumberFormat, options).formatToParts(value);
+	} catch (e) {
+		config.onError(new IntlFormatError("Error formatting number.", config.locale, e));
+	}
+	return [];
 }

package/src/plural.d.ts

@@ -1,5 +1,5 @@
-import { Formatters, IntlFormatters, OnErrorFn } from './types.js';
-export declare function formatPlural({ locale, onError, }: {
-    locale: string;
-    onError: OnErrorFn;
-}, getPluralRules: Formatters['getPluralRules'], value: Parameters<IntlFormatters['formatPlural']>[0], options?: Parameters<IntlFormatters['formatPlural']>[1]): Intl.LDMLPluralRule;
+import { type Formatters, type IntlFormatters, type OnErrorFn } from "./types.js";
+export declare function formatPlural({ locale, onError }: {
+	locale: string;
+	onError: OnErrorFn;
+}, getPluralRules: Formatters["getPluralRules"], value: Parameters<IntlFormatters["formatPlural"]>[0], options?: Parameters<IntlFormatters["formatPlural"]>[1]): Intl.LDMLPluralRule;

package/src/plural.js

@@ -1,19 +1,19 @@
-import { ErrorCode, FormatError } from 'intl-messageformat';
-import { IntlFormatError } from './error.js';
-import { filterProps } from './utils.js';
-var PLURAL_FORMAT_OPTIONS = ['type'];
-export function formatPlural(_a, getPluralRules, value, options) {
-    var locale = _a.locale, onError = _a.onError;
-    if (options === void 0) { options = {}; }
-    if (!Intl.PluralRules) {
-        onError(new FormatError("Intl.PluralRules is not available in this environment.\nTry polyfilling it using \"@formatjs/intl-pluralrules\"\n", ErrorCode.MISSING_INTL_API));
-    }
-    var filteredOptions = filterProps(options, PLURAL_FORMAT_OPTIONS);
-    try {
-        return getPluralRules(locale, filteredOptions).select(value);
-    }
-    catch (e) {
-        onError(new IntlFormatError('Error formatting plural.', locale, e));
-    }
-    return 'other';
+import { ErrorCode, FormatError } from "intl-messageformat";
+import { IntlFormatError } from "./error.js";
+import "./types.js";
+import { filterProps } from "./utils.js";
+const PLURAL_FORMAT_OPTIONS = ["type"];
+export function formatPlural({ locale, onError }, getPluralRules, value, options = {}) {
+	if (!Intl.PluralRules) {
+		onError(new FormatError(`Intl.PluralRules is not available in this environment.
+Try polyfilling it using "@formatjs/intl-pluralrules"
+`, ErrorCode.MISSING_INTL_API));
+	}
+	const filteredOptions = filterProps(options, PLURAL_FORMAT_OPTIONS);
+	try {
+		return getPluralRules(locale, filteredOptions).select(value);
+	} catch (e) {
+		onError(new IntlFormatError("Error formatting plural.", locale, e));
+	}
+	return "other";
 }

package/src/relativeTime.d.ts

@@ -1,6 +1,6 @@
-import { IntlFormatters, Formatters, CustomFormats, OnErrorFn } from './types.js';
+import { type IntlFormatters, type Formatters, type CustomFormats, type OnErrorFn } from "./types.js";
 export declare function formatRelativeTime(config: {
-    locale: string;
-    formats: CustomFormats;
-    onError: OnErrorFn;
-}, getRelativeTimeFormat: Formatters['getRelativeTimeFormat'], value: Parameters<IntlFormatters['formatRelativeTime']>[0], unit?: Parameters<IntlFormatters['formatRelativeTime']>[1], options?: Parameters<IntlFormatters['formatRelativeTime']>[2]): string;
+	locale: string;
+	formats: CustomFormats;
+	onError: OnErrorFn;
+}, getRelativeTimeFormat: Formatters["getRelativeTimeFormat"], value: Parameters<IntlFormatters["formatRelativeTime"]>[0], unit?: Parameters<IntlFormatters["formatRelativeTime"]>[1], options?: Parameters<IntlFormatters["formatRelativeTime"]>[2]): string;

package/src/relativeTime.js

@@ -1,29 +1,28 @@
-import { getNamedFormat, filterProps } from './utils.js';
-import { FormatError, ErrorCode } from 'intl-messageformat';
-import { IntlFormatError } from './error.js';
-var RELATIVE_TIME_FORMAT_OPTIONS = ['numeric', 'style'];
-function getFormatter(_a, getRelativeTimeFormat, options) {
-    var locale = _a.locale, formats = _a.formats, onError = _a.onError;
-    if (options === void 0) { options = {}; }
-    var format = options.format;
-    var defaults = (!!format && getNamedFormat(formats, 'relative', format, onError)) || {};
-    var filteredOptions = filterProps(options, RELATIVE_TIME_FORMAT_OPTIONS, defaults);
-    return getRelativeTimeFormat(locale, filteredOptions);
+import "./types.js";
+import { getNamedFormat, filterProps } from "./utils.js";
+import { FormatError, ErrorCode } from "intl-messageformat";
+import { IntlFormatError } from "./error.js";
+const RELATIVE_TIME_FORMAT_OPTIONS = ["numeric", "style"];
+function getFormatter({ locale, formats, onError }, getRelativeTimeFormat, options = {}) {
+	const { format } = options;
+	const defaults = !!format && getNamedFormat(formats, "relative", format, onError) || {};
+	const filteredOptions = filterProps(options, RELATIVE_TIME_FORMAT_OPTIONS, defaults);
+	return getRelativeTimeFormat(locale, filteredOptions);
 }
-export function formatRelativeTime(config, getRelativeTimeFormat, value, unit, options) {
-    if (options === void 0) { options = {}; }
-    if (!unit) {
-        unit = 'second';
-    }
-    var RelativeTimeFormat = Intl.RelativeTimeFormat;
-    if (!RelativeTimeFormat) {
-        config.onError(new FormatError("Intl.RelativeTimeFormat is not available in this environment.\nTry polyfilling it using \"@formatjs/intl-relativetimeformat\"\n", ErrorCode.MISSING_INTL_API));
-    }
-    try {
-        return getFormatter(config, getRelativeTimeFormat, options).format(value, unit);
-    }
-    catch (e) {
-        config.onError(new IntlFormatError('Error formatting relative time.', config.locale, e));
-    }
-    return String(value);
+export function formatRelativeTime(config, getRelativeTimeFormat, value, unit, options = {}) {
+	if (!unit) {
+		unit = "second";
+	}
+	const RelativeTimeFormat = Intl.RelativeTimeFormat;
+	if (!RelativeTimeFormat) {
+		config.onError(new FormatError(`Intl.RelativeTimeFormat is not available in this environment.
+Try polyfilling it using "@formatjs/intl-relativetimeformat"
+`, ErrorCode.MISSING_INTL_API));
+	}
+	try {
+		return getFormatter(config, getRelativeTimeFormat, options).format(value, unit);
+	} catch (e) {
+		config.onError(new IntlFormatError("Error formatting relative time.", config.locale, e));
+	}
+	return String(value);
 }

package/src/types.d.ts

@@ -1,110 +1,114 @@
-import { MessageFormatElement } from '@formatjs/icu-messageformat-parser';
-import { NumberFormatOptions } from '@formatjs/ecma402-abstract';
-import { FormatError, Formats, FormatXMLElementFn, IntlMessageFormat, Options as IntlMessageFormatOptions, PrimitiveType } from 'intl-messageformat';
-import { InvalidConfigError, MessageFormatError, MissingDataError, MissingTranslationError, UnsupportedFormatterError } from './error.js';
-import { DEFAULT_INTL_CONFIG } from './utils.js';
+import { type MessageFormatElement } from "@formatjs/icu-messageformat-parser";
+import { type NumberFormatOptions } from "@formatjs/ecma402-abstract";
+import type { FormatError, IntlMessageFormat } from "intl-messageformat";
+import { type Formats, type FormatXMLElementFn, type Options as IntlMessageFormatOptions, type PrimitiveType } from "intl-messageformat";
+import type { InvalidConfigError, MessageFormatError, MissingDataError, MissingTranslationError, UnsupportedFormatterError } from "./error.js";
+import type { DEFAULT_INTL_CONFIG } from "./utils.js";
 export interface Part<T = string> {
-    type: 'element' | 'literal';
-    value: T;
+	type: "element" | "literal";
+	value: T;
 }
+// Note: FormatjsIntl is defined as a global namespace so the library user can
+// override the default types of Message.ids (e.g. as string literal unions from extracted strings)
+// or IntlConfig.locale (e.g. to a list of supported locales).
 declare global {
-    namespace FormatjsIntl {
-        interface Message {
-        }
-        interface IntlConfig {
-        }
-        interface Formats {
-        }
-    }
+	namespace FormatjsIntl {
+		interface Message {}
+		interface IntlConfig {}
+		interface Formats {}
+	}
 }
 type MessageIds = FormatjsIntl.Message extends {
-    ids: infer T;
+	ids: infer T;
 } ? T extends string ? T : string : string;
 type Locale = FormatjsIntl.IntlConfig extends {
-    locale: infer T;
+	locale: infer T;
 } ? T extends string ? T : string : string;
 export type OnErrorFn = (err: MissingTranslationError | MessageFormatError | MissingDataError | InvalidConfigError | UnsupportedFormatterError | FormatError) => void;
 export type OnWarnFn = (warning: string) => void;
 /**
- * Config for intl object.
- * Generic type T is the type of potential rich text element. For example:
- * With React, T would be React.ReactNode
- */
+* Config for intl object.
+* Generic type T is the type of potential rich text element. For example:
+* With React, T would be React.ReactNode
+*/
 export interface ResolvedIntlConfig<T = string> {
-    locale: Locale;
-    timeZone?: string;
-    fallbackOnEmptyString?: boolean;
-    formats: CustomFormats;
-    messages: Record<MessageIds, string> | Record<MessageIds, MessageFormatElement[]>;
-    defaultLocale: string;
-    defaultFormats: CustomFormats;
-    defaultRichTextElements?: Record<string, FormatXMLElementFn<T>>;
-    onError: OnErrorFn;
-    onWarn?: OnWarnFn;
+	locale: Locale;
+	timeZone?: string;
+	fallbackOnEmptyString?: boolean;
+	formats: CustomFormats;
+	messages: Record<MessageIds, string> | Record<MessageIds, MessageFormatElement[]>;
+	defaultLocale: string;
+	defaultFormats: CustomFormats;
+	defaultRichTextElements?: Record<string, FormatXMLElementFn<T>>;
+	onError: OnErrorFn;
+	onWarn?: OnWarnFn;
 }
 export interface CustomFormats extends Partial<Formats> {
-    relative?: Record<string, Intl.RelativeTimeFormatOptions>;
-    dateTimeRange?: Record<string, Intl.DateTimeFormatOptions>;
+	relative?: Record<string, Intl.RelativeTimeFormatOptions>;
+	dateTimeRange?: Record<string, Intl.DateTimeFormatOptions>;
 }
 export interface CustomFormatConfig<Source = string> {
-    format?: Source extends keyof FormatjsIntl.Formats ? FormatjsIntl.Formats[Source] : string;
+	format?: Source extends keyof FormatjsIntl.Formats ? FormatjsIntl.Formats[Source] : string;
 }
-export type FormatDateTimeRangeOptions = Omit<Intl.DateTimeFormatOptions, 'localeMatcher'> & CustomFormatConfig<'dateTimeRange'>;
-export type FormatDateOptions = Omit<Intl.DateTimeFormatOptions, 'localeMatcher'> & CustomFormatConfig<'date'>;
-export type FormatTimeOptions = Omit<Intl.DateTimeFormatOptions, 'localeMatcher'> & CustomFormatConfig<'time'>;
-export type FormatNumberOptions = Omit<NumberFormatOptions, 'localeMatcher'> & CustomFormatConfig<'number'>;
-export type FormatRelativeTimeOptions = Omit<Intl.RelativeTimeFormatOptions, 'localeMatcher'> & CustomFormatConfig<'time'>;
-export type FormatPluralOptions = Omit<Intl.PluralRulesOptions, 'localeMatcher'> & CustomFormatConfig;
-export type FormatListOptions = Omit<Intl.ListFormatOptions, 'localeMatcher'>;
-export type FormatDisplayNameOptions = Omit<Intl.DisplayNamesOptions, 'localeMatcher'>;
+export type FormatDateTimeRangeOptions = Omit<Intl.DateTimeFormatOptions, "localeMatcher"> & CustomFormatConfig<"dateTimeRange">;
+export type FormatDateOptions = Omit<Intl.DateTimeFormatOptions, "localeMatcher"> & CustomFormatConfig<"date">;
+export type FormatTimeOptions = Omit<Intl.DateTimeFormatOptions, "localeMatcher"> & CustomFormatConfig<"time">;
+export type FormatNumberOptions = Omit<NumberFormatOptions, "localeMatcher"> & CustomFormatConfig<"number">;
+export type FormatRelativeTimeOptions = Omit<Intl.RelativeTimeFormatOptions, "localeMatcher"> & CustomFormatConfig<"time">;
+export type FormatPluralOptions = Omit<Intl.PluralRulesOptions, "localeMatcher"> & CustomFormatConfig;
+export type FormatListOptions = Omit<Intl.ListFormatOptions, "localeMatcher">;
+export type FormatDisplayNameOptions = Omit<Intl.DisplayNamesOptions, "localeMatcher">;
 /**
- * `TBase` is the type constraints of the rich text element in the formatted output.
- * For example, with React, `TBase` should be `React.ReactNode`.
- */
+* `TBase` is the type constraints of the rich text element in the formatted output.
+* For example, with React, `TBase` should be `React.ReactNode`.
+*/
 export interface IntlFormatters<TBase = unknown> {
-    formatDateTimeRange(this: void, from: Parameters<Intl.DateTimeFormat['formatRange']>[0] | string, to: Parameters<Intl.DateTimeFormat['formatRange']>[1] | string, opts?: FormatDateTimeRangeOptions): string;
-    formatDate(this: void, value: Parameters<Intl.DateTimeFormat['format']>[0] | string, opts?: FormatDateOptions): string;
-    formatTime(this: void, value: Parameters<Intl.DateTimeFormat['format']>[0] | string, opts?: FormatTimeOptions): string;
-    formatDateToParts(this: void, value: Parameters<Intl.DateTimeFormat['format']>[0] | string, opts?: FormatDateOptions): Intl.DateTimeFormatPart[];
-    formatTimeToParts(this: void, value: Parameters<Intl.DateTimeFormat['format']>[0] | string, opts?: FormatDateOptions): Intl.DateTimeFormatPart[];
-    formatRelativeTime(this: void, value: Parameters<Intl.RelativeTimeFormat['format']>[0], unit?: Parameters<Intl.RelativeTimeFormat['format']>[1], opts?: FormatRelativeTimeOptions): string;
-    formatNumber(this: void, value: Parameters<Intl.NumberFormat['format']>[0], opts?: FormatNumberOptions): string;
-    formatNumberToParts(this: void, value: Parameters<Intl.NumberFormat['format']>[0], opts?: FormatNumberOptions): Intl.NumberFormatPart[];
-    formatPlural(this: void, value: Parameters<Intl.PluralRules['select']>[0], opts?: FormatPluralOptions): ReturnType<Intl.PluralRules['select']>;
-    formatMessage(this: void, descriptor: MessageDescriptor, values?: Record<string, PrimitiveType | FormatXMLElementFn<string, string>>, opts?: IntlMessageFormatOptions): string;
-    formatMessage<T extends TBase, TValue extends T | FormatXMLElementFn<T>>(this: void, descriptor: MessageDescriptor, values?: Record<string, PrimitiveType | TValue>, opts?: IntlMessageFormatOptions): string | T | Array<string | T>;
-    $t(this: void, descriptor: MessageDescriptor, values?: Record<string, PrimitiveType | FormatXMLElementFn<string, string>>, opts?: IntlMessageFormatOptions): string;
-    $t<T extends TBase>(this: void, descriptor: MessageDescriptor, values?: Record<string, PrimitiveType | T | FormatXMLElementFn<T>>, opts?: IntlMessageFormatOptions): string | T | (T | string)[];
-    formatList(this: void, values: Iterable<string>, opts?: FormatListOptions): string;
-    formatList<T extends TBase>(this: void, values: Iterable<string | T>, opts?: FormatListOptions): T | string | (string | T)[];
-    formatListToParts<T extends TBase>(this: void, values: Iterable<string | T>, opts?: FormatListOptions): Part[];
-    formatDisplayName(this: void, value: Parameters<Intl.DisplayNames['of']>[0], opts: FormatDisplayNameOptions): string | undefined;
+	formatDateTimeRange(this: void, from: Parameters<Intl.DateTimeFormat["formatRange"]>[0] | string, to: Parameters<Intl.DateTimeFormat["formatRange"]>[1] | string, opts?: FormatDateTimeRangeOptions): string;
+	formatDate(this: void, value: Parameters<Intl.DateTimeFormat["format"]>[0] | string, opts?: FormatDateOptions): string;
+	formatTime(this: void, value: Parameters<Intl.DateTimeFormat["format"]>[0] | string, opts?: FormatTimeOptions): string;
+	formatDateToParts(this: void, value: Parameters<Intl.DateTimeFormat["format"]>[0] | string, opts?: FormatDateOptions): Intl.DateTimeFormatPart[];
+	formatTimeToParts(this: void, value: Parameters<Intl.DateTimeFormat["format"]>[0] | string, opts?: FormatDateOptions): Intl.DateTimeFormatPart[];
+	formatRelativeTime(this: void, value: Parameters<Intl.RelativeTimeFormat["format"]>[0], unit?: Parameters<Intl.RelativeTimeFormat["format"]>[1], opts?: FormatRelativeTimeOptions): string;
+	formatNumber(this: void, value: Parameters<Intl.NumberFormat["format"]>[0], opts?: FormatNumberOptions): string;
+	formatNumberToParts(this: void, value: Parameters<Intl.NumberFormat["format"]>[0], opts?: FormatNumberOptions): Intl.NumberFormatPart[];
+	formatPlural(this: void, value: Parameters<Intl.PluralRules["select"]>[0], opts?: FormatPluralOptions): ReturnType<Intl.PluralRules["select"]>;
+	formatMessage(this: void, descriptor: MessageDescriptor, values?: Record<string, PrimitiveType | FormatXMLElementFn<string, string>>, opts?: IntlMessageFormatOptions): string;
+	formatMessage<
+		T extends TBase,
+		TValue extends T | FormatXMLElementFn<T>
+	>(this: void, descriptor: MessageDescriptor, values?: Record<string, PrimitiveType | TValue>, opts?: IntlMessageFormatOptions): string | T | Array<string | T>;
+	$t(this: void, descriptor: MessageDescriptor, values?: Record<string, PrimitiveType | FormatXMLElementFn<string, string>>, opts?: IntlMessageFormatOptions): string;
+	$t<T extends TBase>(this: void, descriptor: MessageDescriptor, values?: Record<string, PrimitiveType | T | FormatXMLElementFn<T>>, opts?: IntlMessageFormatOptions): string | T | (T | string)[];
+	formatList(this: void, values: Iterable<string>, opts?: FormatListOptions): string;
+	formatList<T extends TBase>(this: void, values: Iterable<string | T>, opts?: FormatListOptions): T | string | (string | T)[];
+	formatListToParts<T extends TBase>(this: void, values: Iterable<string | T>, opts?: FormatListOptions): Part[];
+	formatDisplayName(this: void, value: Parameters<Intl.DisplayNames["of"]>[0], opts: FormatDisplayNameOptions): string | undefined;
 }
 export interface Formatters {
-    getDateTimeFormat(this: void, ...args: ConstructorParameters<typeof Intl.DateTimeFormat>): Intl.DateTimeFormat;
-    getNumberFormat(this: void, locales?: string | string[], opts?: NumberFormatOptions): Intl.NumberFormat;
-    getMessageFormat(this: void, ...args: ConstructorParameters<typeof IntlMessageFormat>): IntlMessageFormat;
-    getRelativeTimeFormat(this: void, ...args: ConstructorParameters<typeof Intl.RelativeTimeFormat>): Intl.RelativeTimeFormat;
-    getPluralRules(this: void, ...args: ConstructorParameters<typeof Intl.PluralRules>): Intl.PluralRules;
-    getListFormat(this: void, ...args: ConstructorParameters<typeof Intl.ListFormat>): Intl.ListFormat;
-    getDisplayNames(this: void, ...args: ConstructorParameters<typeof Intl.DisplayNames>): Intl.DisplayNames;
+	getDateTimeFormat(this: void, ...args: ConstructorParameters<typeof Intl.DateTimeFormat>): Intl.DateTimeFormat;
+	getNumberFormat(this: void, locales?: string | string[], opts?: NumberFormatOptions): Intl.NumberFormat;
+	getMessageFormat(this: void, ...args: ConstructorParameters<typeof IntlMessageFormat>): IntlMessageFormat;
+	getRelativeTimeFormat(this: void, ...args: ConstructorParameters<typeof Intl.RelativeTimeFormat>): Intl.RelativeTimeFormat;
+	getPluralRules(this: void, ...args: ConstructorParameters<typeof Intl.PluralRules>): Intl.PluralRules;
+	getListFormat(this: void, ...args: ConstructorParameters<typeof Intl.ListFormat>): Intl.ListFormat;
+	getDisplayNames(this: void, ...args: ConstructorParameters<typeof Intl.DisplayNames>): Intl.DisplayNames;
 }
 export interface IntlShape<T = string> extends ResolvedIntlConfig<T>, IntlFormatters<T> {
-    formatters: Formatters;
+	formatters: Formatters;
 }
 export interface IntlCache {
-    dateTime: Record<string, Intl.DateTimeFormat>;
-    number: Record<string, Intl.NumberFormat>;
-    message: Record<string, IntlMessageFormat>;
-    relativeTime: Record<string, Intl.RelativeTimeFormat>;
-    pluralRules: Record<string, Intl.PluralRules>;
-    list: Record<string, Intl.ListFormat>;
-    displayNames: Record<string, Intl.DisplayNames>;
+	dateTime: Record<string, Intl.DateTimeFormat>;
+	number: Record<string, Intl.NumberFormat>;
+	message: Record<string, IntlMessageFormat>;
+	relativeTime: Record<string, Intl.RelativeTimeFormat>;
+	pluralRules: Record<string, Intl.PluralRules>;
+	list: Record<string, Intl.ListFormat>;
+	displayNames: Record<string, Intl.DisplayNames>;
 }
 export interface MessageDescriptor {
-    id?: MessageIds;
-    description?: string | object;
-    defaultMessage?: string | MessageFormatElement[];
+	id?: MessageIds;
+	description?: string | object;
+	defaultMessage?: string | MessageFormatElement[];
 }
 export type IntlConfig<T = string> = Omit<ResolvedIntlConfig<T>, keyof typeof DEFAULT_INTL_CONFIG> & Partial<typeof DEFAULT_INTL_CONFIG>;
 export {};

package/src/types.js

@@ -1 +1,3 @@
-export {};
+import "@formatjs/icu-messageformat-parser";
+import "@formatjs/ecma402-abstract";
+import "intl-messageformat";

package/src/utils.d.ts

@@ -1,12 +1,15 @@
-import { NumberFormatOptions } from '@formatjs/ecma402-abstract';
-import { CustomFormats, Formatters, IntlCache, OnErrorFn, ResolvedIntlConfig } from './types.js';
+import { type NumberFormatOptions } from "@formatjs/ecma402-abstract";
+import { type CustomFormats, type Formatters, type IntlCache, type OnErrorFn, type ResolvedIntlConfig } from "./types.js";
 export declare function invariant(condition: boolean, message: string, Err?: any): asserts condition;
-export declare function filterProps<T extends Record<string, any>, K extends string>(props: T, allowlist: Array<K>, defaults?: Partial<T>): Pick<T, K>;
-export declare const DEFAULT_INTL_CONFIG: Pick<ResolvedIntlConfig<any>, 'fallbackOnEmptyString' | 'formats' | 'messages' | 'timeZone' | 'defaultLocale' | 'defaultFormats' | 'onError' | 'onWarn'>;
+export declare function filterProps<
+	T extends Record<string, any>,
+	K extends string
+>(props: T, allowlist: Array<K>, defaults?: Partial<T>): Pick<T, K>;
+export declare const DEFAULT_INTL_CONFIG: Pick<ResolvedIntlConfig<any>, "fallbackOnEmptyString" | "formats" | "messages" | "timeZone" | "defaultLocale" | "defaultFormats" | "onError" | "onWarn">;
 export declare function createIntlCache(): IntlCache;
 /**
- * Create intl formatters and populate cache
- * @param cache explicit cache to prevent leaking memory
- */
+* Create intl formatters and populate cache
+* @param cache explicit cache to prevent leaking memory
+*/
 export declare function createFormatters(cache?: IntlCache): Formatters;
 export declare function getNamedFormat<T extends keyof CustomFormats>(formats: CustomFormats, type: T, name: string, onError: OnErrorFn): NumberFormatOptions | Intl.DateTimeFormatOptions | Intl.RelativeTimeFormatOptions | undefined;