@formatjs/intl 4.0.7 → 4.0.9

package/src/error.d.ts

@@ -1,35 +1,35 @@
-import { MessageDescriptor } from './types.js';
+import { type MessageDescriptor } from "./types.js";
 export declare enum IntlErrorCode {
-    FORMAT_ERROR = "FORMAT_ERROR",
-    UNSUPPORTED_FORMATTER = "UNSUPPORTED_FORMATTER",
-    INVALID_CONFIG = "INVALID_CONFIG",
-    MISSING_DATA = "MISSING_DATA",
-    MISSING_TRANSLATION = "MISSING_TRANSLATION"
+	FORMAT_ERROR = "FORMAT_ERROR",
+	UNSUPPORTED_FORMATTER = "UNSUPPORTED_FORMATTER",
+	INVALID_CONFIG = "INVALID_CONFIG",
+	MISSING_DATA = "MISSING_DATA",
+	MISSING_TRANSLATION = "MISSING_TRANSLATION"
 }
 export declare class IntlError<T extends IntlErrorCode = IntlErrorCode.FORMAT_ERROR> extends Error {
-    readonly code: T;
-    constructor(code: T, message: string, exception?: Error | unknown);
+	readonly code: T;
+	constructor(code: T, message: string, exception?: Error | unknown);
 }
 export declare class UnsupportedFormatterError extends IntlError<IntlErrorCode.UNSUPPORTED_FORMATTER> {
-    constructor(message: string, exception?: Error | unknown);
+	constructor(message: string, exception?: Error | unknown);
 }
 export declare class InvalidConfigError extends IntlError<IntlErrorCode.INVALID_CONFIG> {
-    constructor(message: string, exception?: Error | unknown);
+	constructor(message: string, exception?: Error | unknown);
 }
 export declare class MissingDataError extends IntlError<IntlErrorCode.MISSING_DATA> {
-    constructor(message: string, exception?: Error | unknown);
+	constructor(message: string, exception?: Error | unknown);
 }
 export declare class IntlFormatError extends IntlError<IntlErrorCode.FORMAT_ERROR> {
-    readonly descriptor?: MessageDescriptor;
-    readonly locale: string;
-    constructor(message: string, locale: string, exception?: Error | unknown);
+	readonly descriptor?: MessageDescriptor;
+	readonly locale: string;
+	constructor(message: string, locale: string, exception?: Error | unknown);
 }
 export declare class MessageFormatError extends IntlFormatError {
-    readonly descriptor?: MessageDescriptor;
-    readonly locale: string;
-    constructor(message: string, locale: string, descriptor?: MessageDescriptor, exception?: Error | unknown);
+	readonly descriptor?: MessageDescriptor;
+	readonly locale: string;
+	constructor(message: string, locale: string, descriptor?: MessageDescriptor, exception?: Error | unknown);
 }
 export declare class MissingTranslationError extends IntlError<IntlErrorCode.MISSING_TRANSLATION> {
-    readonly descriptor?: MessageDescriptor;
-    constructor(descriptor: MessageDescriptor, locale: string);
+	readonly descriptor?: MessageDescriptor;
+	constructor(descriptor: MessageDescriptor, locale: string);
 }

package/src/error.js

@@ -1,91 +1,68 @@
-import { __extends } from "tslib";
-export var IntlErrorCode;
-(function (IntlErrorCode) {
-    IntlErrorCode["FORMAT_ERROR"] = "FORMAT_ERROR";
-    IntlErrorCode["UNSUPPORTED_FORMATTER"] = "UNSUPPORTED_FORMATTER";
-    IntlErrorCode["INVALID_CONFIG"] = "INVALID_CONFIG";
-    IntlErrorCode["MISSING_DATA"] = "MISSING_DATA";
-    IntlErrorCode["MISSING_TRANSLATION"] = "MISSING_TRANSLATION";
-})(IntlErrorCode || (IntlErrorCode = {}));
-var IntlError = /** @class */ (function (_super) {
-    __extends(IntlError, _super);
-    function IntlError(code, message, exception) {
-        var _this = this;
-        var err = exception
-            ? exception instanceof Error
-                ? exception
-                : new Error(String(exception))
-            : undefined;
-        _this = _super.call(this, "[@formatjs/intl Error ".concat(code, "] ").concat(message, "\n").concat(err ? "\n".concat(err.message, "\n").concat(err.stack) : '')) || this;
-        _this.code = code;
-        // @ts-ignore just so we don't need to declare dep on @types/node
-        if (typeof Error.captureStackTrace === 'function') {
-            // @ts-ignore just so we don't need to declare dep on @types/node
-            Error.captureStackTrace(_this, IntlError);
-        }
-        return _this;
-    }
-    return IntlError;
-}(Error));
-export { IntlError };
-var UnsupportedFormatterError = /** @class */ (function (_super) {
-    __extends(UnsupportedFormatterError, _super);
-    function UnsupportedFormatterError(message, exception) {
-        return _super.call(this, IntlErrorCode.UNSUPPORTED_FORMATTER, message, exception) || this;
-    }
-    return UnsupportedFormatterError;
-}(IntlError));
-export { UnsupportedFormatterError };
-var InvalidConfigError = /** @class */ (function (_super) {
-    __extends(InvalidConfigError, _super);
-    function InvalidConfigError(message, exception) {
-        return _super.call(this, IntlErrorCode.INVALID_CONFIG, message, exception) || this;
-    }
-    return InvalidConfigError;
-}(IntlError));
-export { InvalidConfigError };
-var MissingDataError = /** @class */ (function (_super) {
-    __extends(MissingDataError, _super);
-    function MissingDataError(message, exception) {
-        return _super.call(this, IntlErrorCode.MISSING_DATA, message, exception) || this;
-    }
-    return MissingDataError;
-}(IntlError));
-export { MissingDataError };
-var IntlFormatError = /** @class */ (function (_super) {
-    __extends(IntlFormatError, _super);
-    function IntlFormatError(message, locale, exception) {
-        var _this = _super.call(this, IntlErrorCode.FORMAT_ERROR, "".concat(message, "\nLocale: ").concat(locale, "\n"), exception) || this;
-        _this.locale = locale;
-        return _this;
-    }
-    return IntlFormatError;
-}(IntlError));
-export { IntlFormatError };
-var MessageFormatError = /** @class */ (function (_super) {
-    __extends(MessageFormatError, _super);
-    function MessageFormatError(message, locale, descriptor, exception) {
-        var _this = _super.call(this, "".concat(message, "\nMessageID: ").concat(descriptor === null || descriptor === void 0 ? void 0 : descriptor.id, "\nDefault Message: ").concat(descriptor === null || descriptor === void 0 ? void 0 : descriptor.defaultMessage, "\nDescription: ").concat(descriptor === null || descriptor === void 0 ? void 0 : descriptor.description, "\n"), locale, exception) || this;
-        _this.descriptor = descriptor;
-        _this.locale = locale;
-        return _this;
-    }
-    return MessageFormatError;
-}(IntlFormatError));
-export { MessageFormatError };
-var MissingTranslationError = /** @class */ (function (_super) {
-    __extends(MissingTranslationError, _super);
-    function MissingTranslationError(descriptor, locale) {
-        var _this = _super.call(this, IntlErrorCode.MISSING_TRANSLATION, "Missing message: \"".concat(descriptor.id, "\" for locale \"").concat(locale, "\", using ").concat(descriptor.defaultMessage
-            ? "default message (".concat(typeof descriptor.defaultMessage === 'string'
-                ? descriptor.defaultMessage
-                : descriptor.defaultMessage
-                    .map(function (e) { var _a; return (_a = e.value) !== null && _a !== void 0 ? _a : JSON.stringify(e); })
-                    .join(), ")")
-            : 'id', " as fallback.")) || this;
-        _this.descriptor = descriptor;
-        return _this;
-    }
-    return MissingTranslationError;
-}(IntlError));
-export { MissingTranslationError };
+import "./types.js";
+export let IntlErrorCode = /* @__PURE__ */ function(IntlErrorCode) {
+	IntlErrorCode["FORMAT_ERROR"] = "FORMAT_ERROR";
+	IntlErrorCode["UNSUPPORTED_FORMATTER"] = "UNSUPPORTED_FORMATTER";
+	IntlErrorCode["INVALID_CONFIG"] = "INVALID_CONFIG";
+	IntlErrorCode["MISSING_DATA"] = "MISSING_DATA";
+	IntlErrorCode["MISSING_TRANSLATION"] = "MISSING_TRANSLATION";
+	return IntlErrorCode;
+}({});
+export class IntlError extends Error {
+	code;
+	constructor(code, message, exception) {
+		const err = exception ? exception instanceof Error ? exception : new Error(String(exception)) : undefined;
+		super(`[@formatjs/intl Error ${code}] ${message}
+${err ? `\n${err.message}\n${err.stack}` : ""}`);
+		this.code = code;
+		// @ts-ignore just so we don't need to declare dep on @types/node
+		if (typeof Error.captureStackTrace === "function") {
+			// @ts-ignore just so we don't need to declare dep on @types/node
+			Error.captureStackTrace(this, IntlError);
+		}
+	}
+}
+export class UnsupportedFormatterError extends IntlError {
+	constructor(message, exception) {
+		super(IntlErrorCode.UNSUPPORTED_FORMATTER, message, exception);
+	}
+}
+export class InvalidConfigError extends IntlError {
+	constructor(message, exception) {
+		super(IntlErrorCode.INVALID_CONFIG, message, exception);
+	}
+}
+export class MissingDataError extends IntlError {
+	constructor(message, exception) {
+		super(IntlErrorCode.MISSING_DATA, message, exception);
+	}
+}
+export class IntlFormatError extends IntlError {
+	descriptor;
+	locale;
+	constructor(message, locale, exception) {
+		super(IntlErrorCode.FORMAT_ERROR, `${message}
+Locale: ${locale}
+`, exception);
+		this.locale = locale;
+	}
+}
+export class MessageFormatError extends IntlFormatError {
+	descriptor;
+	locale;
+	constructor(message, locale, descriptor, exception) {
+		super(`${message}
+MessageID: ${descriptor?.id}
+Default Message: ${descriptor?.defaultMessage}
+Description: ${descriptor?.description}
+`, locale, exception);
+		this.descriptor = descriptor;
+		this.locale = locale;
+	}
+}
+export class MissingTranslationError extends IntlError {
+	descriptor;
+	constructor(descriptor, locale) {
+		super(IntlErrorCode.MISSING_TRANSLATION, `Missing message: "${descriptor.id}" for locale "${locale}", using ${descriptor.defaultMessage ? `default message (${typeof descriptor.defaultMessage === "string" ? descriptor.defaultMessage : descriptor.defaultMessage.map((e) => e.value ?? JSON.stringify(e)).join()})` : "id"} as fallback.`);
+		this.descriptor = descriptor;
+	}
+}

package/src/list.d.ts

@@ -1,9 +1,9 @@
-import { Formatters, IntlFormatters, OnErrorFn, Part } from './types.js';
+import { type Formatters, type IntlFormatters, type OnErrorFn, type Part } from "./types.js";
 export declare function formatList(opts: {
-    locale: string;
-    onError: OnErrorFn;
-}, getListFormat: Formatters['getListFormat'], values: Iterable<string>, options: Parameters<IntlFormatters['formatList']>[1]): string;
+	locale: string;
+	onError: OnErrorFn;
+}, getListFormat: Formatters["getListFormat"], values: Iterable<string>, options: Parameters<IntlFormatters["formatList"]>[1]): string;
 export declare function formatListToParts<T>(opts: {
-    locale: string;
-    onError: OnErrorFn;
-}, getListFormat: Formatters['getListFormat'], values: Iterable<string | T>, options: Parameters<IntlFormatters['formatList']>[1]): Part[];
+	locale: string;
+	onError: OnErrorFn;
+}, getListFormat: Formatters["getListFormat"], values: Iterable<string | T>, options: Parameters<IntlFormatters["formatList"]>[1]): Part[];

package/src/list.js

@@ -1,61 +1,51 @@
-import { __assign } from "tslib";
-import { ErrorCode, FormatError } from 'intl-messageformat';
-import { IntlFormatError } from './error.js';
-import { filterProps } from './utils.js';
-var LIST_FORMAT_OPTIONS = [
-    'type',
-    'style',
-];
-var now = Date.now();
+import { ErrorCode, FormatError } from "intl-messageformat";
+import { IntlFormatError } from "./error.js";
+import "./types.js";
+import { filterProps } from "./utils.js";
+const LIST_FORMAT_OPTIONS = ["type", "style"];
+const now = Date.now();
 function generateToken(i) {
-    return "".concat(now, "_").concat(i, "_").concat(now);
+	return `${now}_${i}_${now}`;
 }
-export function formatList(opts, getListFormat, values, options) {
-    if (options === void 0) { options = {}; }
-    var results = formatListToParts(opts, getListFormat, values, options).reduce(function (all, el) {
-        var val = el.value;
-        if (typeof val !== 'string') {
-            all.push(val);
-        }
-        else if (typeof all[all.length - 1] === 'string') {
-            all[all.length - 1] += val;
-        }
-        else {
-            all.push(val);
-        }
-        return all;
-    }, []);
-    return results.length === 1 ? results[0] : results.length === 0 ? '' : results;
+export function formatList(opts, getListFormat, values, options = {}) {
+	const results = formatListToParts(opts, getListFormat, values, options).reduce((all, el) => {
+		const val = el.value;
+		if (typeof val !== "string") {
+			all.push(val);
+		} else if (typeof all[all.length - 1] === "string") {
+			all[all.length - 1] += val;
+		} else {
+			all.push(val);
+		}
+		return all;
+	}, []);
+	return results.length === 1 ? results[0] : results.length === 0 ? "" : results;
 }
-export function formatListToParts(_a, getListFormat, values, options) {
-    var locale = _a.locale, onError = _a.onError;
-    if (options === void 0) { options = {}; }
-    var ListFormat = Intl.ListFormat;
-    if (!ListFormat) {
-        onError(new FormatError("Intl.ListFormat is not available in this environment.\nTry polyfilling it using \"@formatjs/intl-listformat\"\n", ErrorCode.MISSING_INTL_API));
-    }
-    var filteredOptions = filterProps(options, LIST_FORMAT_OPTIONS);
-    try {
-        var richValues_1 = {};
-        var serializedValues = Array.from(values).map(function (v, i) {
-            if (typeof v === 'object' && v !== null) {
-                var id = generateToken(i);
-                richValues_1[id] = v;
-                return id;
-            }
-            return String(v);
-        });
-        return getListFormat(locale, filteredOptions)
-            .formatToParts(serializedValues)
-            .map(function (part) {
-            return (part.type === 'literal'
-                ? part
-                : __assign(__assign({}, part), { value: richValues_1[part.value] || part.value }));
-        });
-    }
-    catch (e) {
-        onError(new IntlFormatError('Error formatting list.', locale, e));
-    }
-    // @ts-ignore
-    return values;
+export function formatListToParts({ locale, onError }, getListFormat, values, options = {}) {
+	const ListFormat = Intl.ListFormat;
+	if (!ListFormat) {
+		onError(new FormatError(`Intl.ListFormat is not available in this environment.
+Try polyfilling it using "@formatjs/intl-listformat"
+`, ErrorCode.MISSING_INTL_API));
+	}
+	const filteredOptions = filterProps(options, LIST_FORMAT_OPTIONS);
+	try {
+		const richValues = {};
+		const serializedValues = Array.from(values).map((v, i) => {
+			if (typeof v === "object" && v !== null) {
+				const id = generateToken(i);
+				richValues[id] = v;
+				return id;
+			}
+			return String(v);
+		});
+		return getListFormat(locale, filteredOptions).formatToParts(serializedValues).map((part) => part.type === "literal" ? part : {
+			...part,
+			value: richValues[part.value] || part.value
+		});
+	} catch (e) {
+		onError(new IntlFormatError("Error formatting list.", locale, e));
+	}
+	// @ts-ignore
+	return values;
 }

package/src/message.d.ts

@@ -1,15 +1,15 @@
-import { CustomFormats, Formatters, MessageDescriptor, OnErrorFn } from './types.js';
-import { MessageFormatElement } from '@formatjs/icu-messageformat-parser';
-import { FormatXMLElementFn, Formatters as IntlMessageFormatFormatters, Options, PrimitiveType } from 'intl-messageformat';
-export type FormatMessageFn<T> = ({ locale, formats, messages, defaultLocale, defaultFormats, fallbackOnEmptyString, onError, timeZone, defaultRichTextElements, }: {
-    locale: string;
-    timeZone?: string;
-    formats: CustomFormats;
-    messages: Record<string, string> | Record<string, MessageFormatElement[]>;
-    defaultLocale: string;
-    defaultFormats: CustomFormats;
-    defaultRichTextElements?: Record<string, FormatXMLElementFn<T>>;
-    fallbackOnEmptyString?: boolean;
-    onError: OnErrorFn;
-}, state: IntlMessageFormatFormatters & Pick<Formatters, 'getMessageFormat'>, messageDescriptor: MessageDescriptor, values?: Record<string, PrimitiveType | T | FormatXMLElementFn<T>>, opts?: Options) => T extends string ? string : Array<T | string> | string | T;
+import { type CustomFormats, type Formatters, type MessageDescriptor, type OnErrorFn } from "./types.js";
+import { type MessageFormatElement } from "@formatjs/icu-messageformat-parser";
+import { type FormatXMLElementFn, type Formatters as IntlMessageFormatFormatters, type Options, type PrimitiveType } from "intl-messageformat";
+export type FormatMessageFn<T> = ({ locale, formats, messages, defaultLocale, defaultFormats, fallbackOnEmptyString, onError, timeZone, defaultRichTextElements }: {
+	locale: string;
+	timeZone?: string;
+	formats: CustomFormats;
+	messages: Record<string, string> | Record<string, MessageFormatElement[]>;
+	defaultLocale: string;
+	defaultFormats: CustomFormats;
+	defaultRichTextElements?: Record<string, FormatXMLElementFn<T>>;
+	fallbackOnEmptyString?: boolean;
+	onError: OnErrorFn;
+}, state: IntlMessageFormatFormatters & Pick<Formatters, "getMessageFormat">, messageDescriptor: MessageDescriptor, values?: Record<string, PrimitiveType | T | FormatXMLElementFn<T>>, opts?: Options) => T extends string ? string : Array<T | string> | string | T;
 export declare const formatMessage: FormatMessageFn<any>;

package/src/message.js

@@ -1,103 +1,110 @@
-import { __assign } from "tslib";
-import { TYPE } from '@formatjs/icu-messageformat-parser';
-import { IntlMessageFormat, } from 'intl-messageformat';
-import { MessageFormatError, MissingTranslationError } from './error.js';
-import { invariant } from './utils.js';
+import "./types.js";
+import { TYPE } from "@formatjs/icu-messageformat-parser";
+import { IntlMessageFormat } from "intl-messageformat";
+import { MessageFormatError, MissingTranslationError } from "./error.js";
+import { invariant } from "./utils.js";
 function setTimeZoneInOptions(opts, timeZone) {
-    return Object.keys(opts).reduce(function (all, k) {
-        all[k] = __assign({ timeZone: timeZone }, opts[k]);
-        return all;
-    }, {});
+	return Object.keys(opts).reduce((all, k) => {
+		all[k] = {
+			timeZone,
+			...opts[k]
+		};
+		return all;
+	}, {});
 }
 function deepMergeOptions(opts1, opts2) {
-    var keys = Object.keys(__assign(__assign({}, opts1), opts2));
-    return keys.reduce(function (all, k) {
-        all[k] = __assign(__assign({}, opts1[k]), opts2[k]);
-        return all;
-    }, {});
+	const keys = Object.keys({
+		...opts1,
+		...opts2
+	});
+	return keys.reduce((all, k) => {
+		all[k] = {
+			...opts1[k],
+			...opts2[k]
+		};
+		return all;
+	}, {});
 }
 function deepMergeFormatsAndSetTimeZone(f1, timeZone) {
-    if (!timeZone) {
-        return f1;
-    }
-    var mfFormats = IntlMessageFormat.formats;
-    return __assign(__assign(__assign({}, mfFormats), f1), { date: deepMergeOptions(setTimeZoneInOptions(mfFormats.date, timeZone), setTimeZoneInOptions(f1.date || {}, timeZone)), time: deepMergeOptions(setTimeZoneInOptions(mfFormats.time, timeZone), setTimeZoneInOptions(f1.time || {}, timeZone)) });
+	if (!timeZone) {
+		return f1;
+	}
+	const mfFormats = IntlMessageFormat.formats;
+	return {
+		...mfFormats,
+		...f1,
+		date: deepMergeOptions(setTimeZoneInOptions(mfFormats.date, timeZone), setTimeZoneInOptions(f1.date || {}, timeZone)),
+		time: deepMergeOptions(setTimeZoneInOptions(mfFormats.time, timeZone), setTimeZoneInOptions(f1.time || {}, timeZone))
+	};
 }
-export var formatMessage = function (_a, state, messageDescriptor, values, opts) {
-    var locale = _a.locale, formats = _a.formats, messages = _a.messages, defaultLocale = _a.defaultLocale, defaultFormats = _a.defaultFormats, fallbackOnEmptyString = _a.fallbackOnEmptyString, onError = _a.onError, timeZone = _a.timeZone, defaultRichTextElements = _a.defaultRichTextElements;
-    if (messageDescriptor === void 0) { messageDescriptor = { id: '' }; }
-    var msgId = messageDescriptor.id, defaultMessage = messageDescriptor.defaultMessage;
-    // `id` is a required field of a Message Descriptor.
-    invariant(!!msgId, "[@formatjs/intl] An `id` must be provided to format a message. You can either:\n1. Configure your build toolchain with [babel-plugin-formatjs](https://formatjs.github.io/docs/tooling/babel-plugin)\nor [@formatjs/ts-transformer](https://formatjs.github.io/docs/tooling/ts-transformer) OR\n2. Configure your `eslint` config to include [eslint-plugin-formatjs](https://formatjs.github.io/docs/tooling/linter#enforce-id)\nto autofix this issue");
-    var id = String(msgId);
-    var message = 
-    // In case messages is Object.create(null)
-    // e.g import('foo.json') from webpack)
-    // See https://github.com/formatjs/formatjs/issues/1914
-    messages &&
-        Object.prototype.hasOwnProperty.call(messages, id) &&
-        messages[id];
-    // IMPORTANT: Hot path if `message` is AST with a single literal node
-    if (Array.isArray(message) &&
-        message.length === 1 &&
-        message[0].type === TYPE.literal) {
-        return message[0].value;
-    }
-    // IMPORTANT: Hot path straight lookup for performance
-    if (!values &&
-        message &&
-        typeof message === 'string' &&
-        !defaultRichTextElements) {
-        return message.replace(/'\{(.*?)\}'/gi, "{$1}");
-    }
-    values = __assign(__assign({}, defaultRichTextElements), values);
-    formats = deepMergeFormatsAndSetTimeZone(formats, timeZone);
-    defaultFormats = deepMergeFormatsAndSetTimeZone(defaultFormats, timeZone);
-    if (!message) {
-        if (fallbackOnEmptyString === false && message === '') {
-            return message;
-        }
-        if (!defaultMessage ||
-            (locale && locale.toLowerCase() !== defaultLocale.toLowerCase())) {
-            // This prevents warnings from littering the console in development
-            // when no `messages` are passed into the <IntlProvider> for the
-            // default locale.
-            onError(new MissingTranslationError(messageDescriptor, locale));
-        }
-        if (defaultMessage) {
-            try {
-                var formatter = state.getMessageFormat(defaultMessage, defaultLocale, defaultFormats, opts);
-                return formatter.format(values);
-            }
-            catch (e) {
-                onError(new MessageFormatError("Error formatting default message for: \"".concat(id, "\", rendering default message verbatim"), locale, messageDescriptor, e));
-                return typeof defaultMessage === 'string' ? defaultMessage : id;
-            }
-        }
-        return id;
-    }
-    // We have the translated message
-    try {
-        var formatter = state.getMessageFormat(message, locale, formats, __assign({ formatters: state }, opts));
-        return formatter.format(values);
-    }
-    catch (e) {
-        onError(new MessageFormatError("Error formatting message: \"".concat(id, "\", using ").concat(defaultMessage ? 'default message' : 'id', " as fallback."), locale, messageDescriptor, e));
-    }
-    if (defaultMessage) {
-        try {
-            var formatter = state.getMessageFormat(defaultMessage, defaultLocale, defaultFormats, opts);
-            return formatter.format(values);
-        }
-        catch (e) {
-            onError(new MessageFormatError("Error formatting the default message for: \"".concat(id, "\", rendering message verbatim"), locale, messageDescriptor, e));
-        }
-    }
-    if (typeof message === 'string') {
-        return message;
-    }
-    if (typeof defaultMessage === 'string') {
-        return defaultMessage;
-    }
-    return id;
+export const formatMessage = ({ locale, formats, messages, defaultLocale, defaultFormats, fallbackOnEmptyString, onError, timeZone, defaultRichTextElements }, state, messageDescriptor = { id: "" }, values, opts) => {
+	const { id: msgId, defaultMessage } = messageDescriptor;
+	// `id` is a required field of a Message Descriptor.
+	invariant(!!msgId, `[@formatjs/intl] An \`id\` must be provided to format a message. You can either:
+1. Configure your build toolchain with [babel-plugin-formatjs](https://formatjs.github.io/docs/tooling/babel-plugin)
+or [@formatjs/ts-transformer](https://formatjs.github.io/docs/tooling/ts-transformer) OR
+2. Configure your \`eslint\` config to include [eslint-plugin-formatjs](https://formatjs.github.io/docs/tooling/linter#enforce-id)
+to autofix this issue`);
+	const id = String(msgId);
+	const message = messages && Object.prototype.hasOwnProperty.call(messages, id) && messages[id];
+	// IMPORTANT: Hot path if `message` is AST with a single literal node
+	if (Array.isArray(message) && message.length === 1 && message[0].type === TYPE.literal) {
+		return message[0].value;
+	}
+	// IMPORTANT: Hot path straight lookup for performance
+	if (!values && message && typeof message === "string" && !defaultRichTextElements) {
+		return message.replace(/'\{(.*?)\}'/gi, `{$1}`);
+	}
+	values = {
+		...defaultRichTextElements,
+		...values
+	};
+	formats = deepMergeFormatsAndSetTimeZone(formats, timeZone);
+	defaultFormats = deepMergeFormatsAndSetTimeZone(defaultFormats, timeZone);
+	if (!message) {
+		if (fallbackOnEmptyString === false && message === "") {
+			return message;
+		}
+		if (!defaultMessage || locale && locale.toLowerCase() !== defaultLocale.toLowerCase()) {
+			// This prevents warnings from littering the console in development
+			// when no `messages` are passed into the <IntlProvider> for the
+			// default locale.
+			onError(new MissingTranslationError(messageDescriptor, locale));
+		}
+		if (defaultMessage) {
+			try {
+				const formatter = state.getMessageFormat(defaultMessage, defaultLocale, defaultFormats, opts);
+				return formatter.format(values);
+			} catch (e) {
+				onError(new MessageFormatError(`Error formatting default message for: "${id}", rendering default message verbatim`, locale, messageDescriptor, e));
+				return typeof defaultMessage === "string" ? defaultMessage : id;
+			}
+		}
+		return id;
+	}
+	// We have the translated message
+	try {
+		const formatter = state.getMessageFormat(message, locale, formats, {
+			formatters: state,
+			...opts
+		});
+		return formatter.format(values);
+	} catch (e) {
+		onError(new MessageFormatError(`Error formatting message: "${id}", using ${defaultMessage ? "default message" : "id"} as fallback.`, locale, messageDescriptor, e));
+	}
+	if (defaultMessage) {
+		try {
+			const formatter = state.getMessageFormat(defaultMessage, defaultLocale, defaultFormats, opts);
+			return formatter.format(values);
+		} catch (e) {
+			onError(new MessageFormatError(`Error formatting the default message for: "${id}", rendering message verbatim`, locale, messageDescriptor, e));
+		}
+	}
+	if (typeof message === "string") {
+		return message;
+	}
+	if (typeof defaultMessage === "string") {
+		return defaultMessage;
+	}
+	return id;
 };

package/src/number.d.ts

@@ -1,16 +1,16 @@
-import { CustomFormats, Formatters, IntlFormatters, OnErrorFn } from './types.js';
-export declare function getFormatter({ locale, formats, onError, }: {
-    locale: string;
-    formats: CustomFormats;
-    onError: OnErrorFn;
-}, getNumberFormat: Formatters['getNumberFormat'], options?: Parameters<IntlFormatters['formatNumber']>[1]): Intl.NumberFormat;
+import { type CustomFormats, type Formatters, type IntlFormatters, type OnErrorFn } from "./types.js";
+export declare function getFormatter({ locale, formats, onError }: {
+	locale: string;
+	formats: CustomFormats;
+	onError: OnErrorFn;
+}, getNumberFormat: Formatters["getNumberFormat"], options?: Parameters<IntlFormatters["formatNumber"]>[1]): Intl.NumberFormat;
 export declare function formatNumber(config: {
-    locale: string;
-    formats: CustomFormats;
-    onError: OnErrorFn;
-}, getNumberFormat: Formatters['getNumberFormat'], value: Parameters<IntlFormatters['formatNumber']>[0], options?: Parameters<IntlFormatters['formatNumber']>[1]): string;
+	locale: string;
+	formats: CustomFormats;
+	onError: OnErrorFn;
+}, getNumberFormat: Formatters["getNumberFormat"], value: Parameters<IntlFormatters["formatNumber"]>[0], options?: Parameters<IntlFormatters["formatNumber"]>[1]): string;
 export declare function formatNumberToParts(config: {
-    locale: string;
-    formats: CustomFormats;
-    onError: OnErrorFn;
-}, getNumberFormat: Formatters['getNumberFormat'], value: Parameters<IntlFormatters['formatNumber']>[0], options?: Parameters<IntlFormatters['formatNumber']>[1]): Intl.NumberFormatPart[];
+	locale: string;
+	formats: CustomFormats;
+	onError: OnErrorFn;
+}, getNumberFormat: Formatters["getNumberFormat"], value: Parameters<IntlFormatters["formatNumber"]>[0], options?: Parameters<IntlFormatters["formatNumber"]>[1]): Intl.NumberFormatPart[];