react-intl 8.0.10 → 8.0.11

package/src/components/createFormattedComponent.d.ts

@@ -1,27 +1,27 @@
-import { FormatDateOptions, FormatDisplayNameOptions, FormatListOptions, FormatNumberOptions } from '@formatjs/intl';
-import * as React from 'react';
-import { IntlShape } from '../types.js';
+import { type FormatDateOptions, type FormatDisplayNameOptions, type FormatListOptions, type FormatNumberOptions } from "@formatjs/intl";
+import * as React from "react";
+import { type IntlShape } from "../types.js";
 type Formatter = {
-    formatDate: FormatDateOptions;
-    formatTime: FormatDateOptions;
-    formatNumber: FormatNumberOptions;
-    formatList: FormatListOptions;
-    formatDisplayName: FormatDisplayNameOptions;
+	formatDate: FormatDateOptions;
+	formatTime: FormatDateOptions;
+	formatNumber: FormatNumberOptions;
+	formatList: FormatListOptions;
+	formatDisplayName: FormatDisplayNameOptions;
 };
-export declare const FormattedNumberParts: React.FC<Formatter['formatNumber'] & {
-    value: Parameters<IntlShape['formatNumber']>[0];
-    children(val: Intl.NumberFormatPart[]): React.ReactElement | null;
+export declare const FormattedNumberParts: React.FC<Formatter["formatNumber"] & {
+	value: Parameters<IntlShape["formatNumber"]>[0];
+	children(val: Intl.NumberFormatPart[]): React.ReactElement | null;
 }>;
-export declare const FormattedListParts: React.FC<Formatter['formatList'] & {
-    value: Parameters<IntlShape['formatList']>[0];
-    children(val: ReturnType<Intl.ListFormat['formatToParts']>): React.ReactElement | null;
+export declare const FormattedListParts: React.FC<Formatter["formatList"] & {
+	value: Parameters<IntlShape["formatList"]>[0];
+	children(val: ReturnType<Intl.ListFormat["formatToParts"]>): React.ReactElement | null;
 }>;
-export declare function createFormattedDateTimePartsComponent<Name extends 'formatDate' | 'formatTime'>(name: Name): React.FC<Formatter[Name] & {
-    value: Parameters<IntlShape[Name]>[0];
-    children(val: Intl.DateTimeFormatPart[]): React.ReactElement | null;
+export declare function createFormattedDateTimePartsComponent<Name extends "formatDate" | "formatTime">(name: Name): React.FC<Formatter[Name] & {
+	value: Parameters<IntlShape[Name]>[0];
+	children(val: Intl.DateTimeFormatPart[]): React.ReactElement | null;
 }>;
 export declare function createFormattedComponent<Name extends keyof Formatter>(name: Name): React.FC<Formatter[Name] & {
-    value: Parameters<IntlShape[Name]>[0];
-    children?(val: string): React.ReactElement | null;
+	value: Parameters<IntlShape[Name]>[0];
+	children?(val: string): React.ReactElement | null;
 }>;
 export {};

package/src/components/createFormattedComponent.js

@@ -1,63 +1,60 @@
-import { __rest } from "tslib";
+import "@formatjs/intl";
+import * as React from "react";
+import "../types.js";
+import useIntl from "./useIntl.js";
 import { jsx as _jsx } from "react/jsx-runtime";
-import * as React from 'react';
-import useIntl from './useIntl.js';
-var DisplayName;
-(function (DisplayName) {
-    DisplayName["formatDate"] = "FormattedDate";
-    DisplayName["formatTime"] = "FormattedTime";
-    DisplayName["formatNumber"] = "FormattedNumber";
-    DisplayName["formatList"] = "FormattedList";
-    // Note that this DisplayName is the locale display name, not to be confused with
-    // the name of the enum, which is for React component display name in dev tools.
-    DisplayName["formatDisplayName"] = "FormattedDisplayName";
-})(DisplayName || (DisplayName = {}));
-var DisplayNameParts;
-(function (DisplayNameParts) {
-    DisplayNameParts["formatDate"] = "FormattedDateParts";
-    DisplayNameParts["formatTime"] = "FormattedTimeParts";
-    DisplayNameParts["formatNumber"] = "FormattedNumberParts";
-    DisplayNameParts["formatList"] = "FormattedListParts";
-})(DisplayNameParts || (DisplayNameParts = {}));
-export var FormattedNumberParts = function (props) {
-    var intl = useIntl();
-    var value = props.value, children = props.children, formatProps = __rest(props, ["value", "children"]);
-    return children(intl.formatNumberToParts(value, formatProps));
+var DisplayName = /* @__PURE__ */ function(DisplayName) {
+	DisplayName["formatDate"] = "FormattedDate";
+	DisplayName["formatTime"] = "FormattedTime";
+	DisplayName["formatNumber"] = "FormattedNumber";
+	DisplayName["formatList"] = "FormattedList";
+	// Note that this DisplayName is the locale display name, not to be confused with
+	// the name of the enum, which is for React component display name in dev tools.
+	DisplayName["formatDisplayName"] = "FormattedDisplayName";
+	return DisplayName;
+}(DisplayName || {});
+var DisplayNameParts = /* @__PURE__ */ function(DisplayNameParts) {
+	DisplayNameParts["formatDate"] = "FormattedDateParts";
+	DisplayNameParts["formatTime"] = "FormattedTimeParts";
+	DisplayNameParts["formatNumber"] = "FormattedNumberParts";
+	DisplayNameParts["formatList"] = "FormattedListParts";
+	return DisplayNameParts;
+}(DisplayNameParts || {});
+export const FormattedNumberParts = (props) => {
+	const intl = useIntl();
+	const { value, children, ...formatProps } = props;
+	return children(intl.formatNumberToParts(value, formatProps));
 };
-FormattedNumberParts.displayName = 'FormattedNumberParts';
-export var FormattedListParts = function (props) {
-    var intl = useIntl();
-    var value = props.value, children = props.children, formatProps = __rest(props, ["value", "children"]);
-    return children(intl.formatListToParts(value, formatProps));
+FormattedNumberParts.displayName = "FormattedNumberParts";
+export const FormattedListParts = (props) => {
+	const intl = useIntl();
+	const { value, children, ...formatProps } = props;
+	return children(intl.formatListToParts(value, formatProps));
 };
-FormattedNumberParts.displayName = 'FormattedNumberParts';
+FormattedNumberParts.displayName = "FormattedNumberParts";
 export function createFormattedDateTimePartsComponent(name) {
-    var ComponentParts = function (props) {
-        var intl = useIntl();
-        var value = props.value, children = props.children, formatProps = __rest(props, ["value", "children"]);
-        var date = typeof value === 'string' ? new Date(value || 0) : value;
-        var formattedParts = name === 'formatDate'
-            ? intl.formatDateToParts(date, formatProps)
-            : intl.formatTimeToParts(date, formatProps);
-        return children(formattedParts);
-    };
-    ComponentParts.displayName = DisplayNameParts[name];
-    return ComponentParts;
+	const ComponentParts = (props) => {
+		const intl = useIntl();
+		const { value, children, ...formatProps } = props;
+		const date = typeof value === "string" ? new Date(value || 0) : value;
+		const formattedParts = name === "formatDate" ? intl.formatDateToParts(date, formatProps) : intl.formatTimeToParts(date, formatProps);
+		return children(formattedParts);
+	};
+	ComponentParts.displayName = DisplayNameParts[name];
+	return ComponentParts;
 }
 export function createFormattedComponent(name) {
-    var Component = function (props) {
-        var intl = useIntl();
-        var value = props.value, children = props.children, formatProps = __rest(props
-        // TODO: fix TS type definition for localeMatcher upstream
-        , ["value", "children"]);
-        // TODO: fix TS type definition for localeMatcher upstream
-        var formattedValue = intl[name](value, formatProps);
-        if (typeof children === 'function') {
-            return children(formattedValue);
-        }
-        var Text = intl.textComponent || React.Fragment;
-        return _jsx(Text, { children: formattedValue });
-    };
-    Component.displayName = DisplayName[name];
-    return Component;
+	const Component = (props) => {
+		const intl = useIntl();
+		const { value, children, ...formatProps } = props;
+		// TODO: fix TS type definition for localeMatcher upstream
+		const formattedValue = intl[name](value, formatProps);
+		if (typeof children === "function") {
+			return children(formattedValue);
+		}
+		const Text = intl.textComponent || React.Fragment;
+		return /* @__PURE__ */ _jsx(Text, { children: formattedValue });
+	};
+	Component.displayName = DisplayName[name];
+	return Component;
 }

package/src/components/createIntl.d.ts

@@ -1,9 +1,14 @@
-import { CreateIntlFn } from '@formatjs/intl';
-import * as React from 'react';
-import type { IntlConfig, IntlShape } from '../types.js';
+/*
+* Copyright 2015, Yahoo Inc.
+* Copyrights licensed under the New BSD License.
+* See the accompanying LICENSE file for terms.
+*/
+import { type CreateIntlFn } from "@formatjs/intl";
+import * as React from "react";
+import type { IntlConfig, IntlShape } from "../types.js";
 /**
- * Create intl object
- * @param config intl config
- * @param cache cache for formatter instances to prevent memory leak
- */
+* Create intl object
+* @param config intl config
+* @param cache cache for formatter instances to prevent memory leak
+*/
 export declare const createIntl: CreateIntlFn<React.ReactNode, IntlConfig, IntlShape>;

package/src/components/createIntl.js

@@ -1,58 +1,56 @@
 /*
- * Copyright 2015, Yahoo Inc.
- * Copyrights licensed under the New BSD License.
- * See the accompanying LICENSE file for terms.
- */
-import { __assign, __rest, __spreadArray } from "tslib";
-import { createIntl as coreCreateIntl, formatMessage as coreFormatMessage, } from '@formatjs/intl';
-import { isFormatXMLElementFn, } from 'intl-messageformat';
-import { DEFAULT_INTL_CONFIG, assignUniqueKeysToParts, toKeyedReactNodeArray, } from '../utils.js';
+* Copyright 2015, Yahoo Inc.
+* Copyrights licensed under the New BSD License.
+* See the accompanying LICENSE file for terms.
+*/
+import { createIntl as coreCreateIntl, formatMessage as coreFormatMessage } from "@formatjs/intl";
+import { isFormatXMLElementFn } from "intl-messageformat";
+import * as React from "react";
+import { DEFAULT_INTL_CONFIG, assignUniqueKeysToParts, toKeyedReactNodeArray } from "../utils.js";
 function assignUniqueKeysToFormatXMLElementFnArgument(values) {
-    if (!values) {
-        return values;
-    }
-    return Object.keys(values).reduce(function (acc, k) {
-        var v = values[k];
-        acc[k] = isFormatXMLElementFn(v)
-            ? assignUniqueKeysToParts(v)
-            : v;
-        return acc;
-    }, {});
+	if (!values) {
+		return values;
+	}
+	return Object.keys(values).reduce((acc, k) => {
+		const v = values[k];
+		acc[k] = isFormatXMLElementFn(v) ? assignUniqueKeysToParts(v) : v;
+		return acc;
+	}, {});
 }
-var formatMessage = function (config, formatters, descriptor, rawValues) {
-    var rest = [];
-    for (var _i = 4; _i < arguments.length; _i++) {
-        rest[_i - 4] = arguments[_i];
-    }
-    var values = assignUniqueKeysToFormatXMLElementFnArgument(rawValues);
-    var chunks = coreFormatMessage.apply(void 0, __spreadArray([config,
-        formatters,
-        descriptor,
-        values], rest, false));
-    if (Array.isArray(chunks)) {
-        return toKeyedReactNodeArray(chunks);
-    }
-    return chunks;
+const formatMessage = (config, formatters, descriptor, rawValues, ...rest) => {
+	const values = assignUniqueKeysToFormatXMLElementFnArgument(rawValues);
+	const chunks = coreFormatMessage(config, formatters, descriptor, values, ...rest);
+	if (Array.isArray(chunks)) {
+		return toKeyedReactNodeArray(chunks);
+	}
+	return chunks;
 };
 /**
- * Create intl object
- * @param config intl config
- * @param cache cache for formatter instances to prevent memory leak
- */
-export var createIntl = function (_a, cache) {
-    var rawDefaultRichTextElements = _a.defaultRichTextElements, config = __rest(_a, ["defaultRichTextElements"]);
-    var defaultRichTextElements = assignUniqueKeysToFormatXMLElementFnArgument(rawDefaultRichTextElements);
-    var coreIntl = coreCreateIntl(__assign(__assign(__assign({}, DEFAULT_INTL_CONFIG), config), { defaultRichTextElements: defaultRichTextElements }), cache);
-    var resolvedConfig = {
-        locale: coreIntl.locale,
-        timeZone: coreIntl.timeZone,
-        fallbackOnEmptyString: coreIntl.fallbackOnEmptyString,
-        formats: coreIntl.formats,
-        defaultLocale: coreIntl.defaultLocale,
-        defaultFormats: coreIntl.defaultFormats,
-        messages: coreIntl.messages,
-        onError: coreIntl.onError,
-        defaultRichTextElements: defaultRichTextElements,
-    };
-    return __assign(__assign({}, coreIntl), { formatMessage: formatMessage.bind(null, resolvedConfig, coreIntl.formatters), $t: formatMessage.bind(null, resolvedConfig, coreIntl.formatters) });
+* Create intl object
+* @param config intl config
+* @param cache cache for formatter instances to prevent memory leak
+*/
+export const createIntl = ({ defaultRichTextElements: rawDefaultRichTextElements, ...config }, cache) => {
+	const defaultRichTextElements = assignUniqueKeysToFormatXMLElementFnArgument(rawDefaultRichTextElements);
+	const coreIntl = coreCreateIntl({
+		...DEFAULT_INTL_CONFIG,
+		...config,
+		defaultRichTextElements
+	}, cache);
+	const resolvedConfig = {
+		locale: coreIntl.locale,
+		timeZone: coreIntl.timeZone,
+		fallbackOnEmptyString: coreIntl.fallbackOnEmptyString,
+		formats: coreIntl.formats,
+		defaultLocale: coreIntl.defaultLocale,
+		defaultFormats: coreIntl.defaultFormats,
+		messages: coreIntl.messages,
+		onError: coreIntl.onError,
+		defaultRichTextElements
+	};
+	return {
+		...coreIntl,
+		formatMessage: formatMessage.bind(null, resolvedConfig, coreIntl.formatters),
+		$t: formatMessage.bind(null, resolvedConfig, coreIntl.formatters)
+	};
 };

package/src/components/dateTimeRange.d.ts

@@ -1,9 +1,9 @@
-import { FormatDateTimeRangeOptions } from '@formatjs/intl';
-import * as React from 'react';
+import { type FormatDateTimeRangeOptions } from "@formatjs/intl";
+import * as React from "react";
 interface Props extends FormatDateTimeRangeOptions {
-    from: Parameters<Intl.DateTimeFormat['formatRange']>[0];
-    to: Parameters<Intl.DateTimeFormat['formatRange']>[1];
-    children?(value: React.ReactNode): React.ReactElement | null;
+	from: Parameters<Intl.DateTimeFormat["formatRange"]>[0];
+	to: Parameters<Intl.DateTimeFormat["formatRange"]>[1];
+	children?(value: React.ReactNode): React.ReactElement | null;
 }
 declare const FormattedDateTimeRange: React.FC<Props>;
 export default FormattedDateTimeRange;

package/src/components/dateTimeRange.js

@@ -1,16 +1,16 @@
-import { __rest } from "tslib";
+import "@formatjs/intl";
+import * as React from "react";
+import useIntl from "./useIntl.js";
 import { jsx as _jsx } from "react/jsx-runtime";
-import * as React from 'react';
-import useIntl from './useIntl.js';
-var FormattedDateTimeRange = function (props) {
-    var intl = useIntl();
-    var from = props.from, to = props.to, children = props.children, formatProps = __rest(props, ["from", "to", "children"]);
-    var formattedValue = intl.formatDateTimeRange(from, to, formatProps);
-    if (typeof children === 'function') {
-        return children(formattedValue);
-    }
-    var Text = intl.textComponent || React.Fragment;
-    return _jsx(Text, { children: formattedValue });
+const FormattedDateTimeRange = (props) => {
+	const intl = useIntl();
+	const { from, to, children, ...formatProps } = props;
+	const formattedValue = intl.formatDateTimeRange(from, to, formatProps);
+	if (typeof children === "function") {
+		return children(formattedValue);
+	}
+	const Text = intl.textComponent || React.Fragment;
+	return /* @__PURE__ */ _jsx(Text, { children: formattedValue });
 };
-FormattedDateTimeRange.displayName = 'FormattedDateTimeRange';
+FormattedDateTimeRange.displayName = "FormattedDateTimeRange";
 export default FormattedDateTimeRange;

package/src/components/injectIntl.d.ts

@@ -1,39 +1,53 @@
-import * as React from 'react';
-import { IntlShape } from '../types.js';
+import * as React from "react";
+import { type IntlShape } from "../types.js";
 declare global {
-    interface Window {
-        /**
-         * Set this to `true` prior to mounting to bypass using a globally-exposed context.
-         */
-        __REACT_INTL_BYPASS_GLOBAL_CONTEXT__: boolean | undefined;
-        __REACT_INTL_CONTEXT__: React.Context<IntlShape> | undefined;
-    }
+	interface Window {
+		/**
+		* Set this to `true` prior to mounting to bypass using a globally-exposed context.
+		*/
+		__REACT_INTL_BYPASS_GLOBAL_CONTEXT__: boolean | undefined;
+		__REACT_INTL_CONTEXT__: React.Context<IntlShape> | undefined;
+	}
 }
 export declare const Provider: React.Provider<IntlShape>;
 export declare const Context: React.Context<IntlShape>;
-export interface Opts<IntlPropName extends string = 'intl', ForwardRef extends boolean = false> {
-    intlPropName?: IntlPropName;
-    forwardRef?: ForwardRef;
-    enforceContext?: boolean;
+export interface Opts<
+	IntlPropName extends string = "intl",
+	ForwardRef extends boolean = false
+> {
+	intlPropName?: IntlPropName;
+	forwardRef?: ForwardRef;
+	enforceContext?: boolean;
 }
-export type WrappedComponentProps<IntlPropName extends string = 'intl'> = {
-    [k in IntlPropName]: IntlShape;
-};
+export type WrappedComponentProps<IntlPropName extends string = "intl"> = { [k in IntlPropName] : IntlShape };
 /**
- * Utility type to help deal with the fact that `Omit` doesn't play well with unions:
- * - https://github.com/microsoft/TypeScript/issues/31501
- * - https://github.com/microsoft/TypeScript/issues/28339
- *
- * @example
- *      DistributedOmit<X | Y, K>  -->  Omit<X, K> | Omit<Y, K>
- */
-export type DistributedOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+* Utility type to help deal with the fact that `Omit` doesn't play well with unions:
+* - https://github.com/microsoft/TypeScript/issues/31501
+* - https://github.com/microsoft/TypeScript/issues/28339
+*
+* @example
+*      DistributedOmit<X | Y, K>  -->  Omit<X, K> | Omit<Y, K>
+*/
+export type DistributedOmit<
+	T,
+	K extends PropertyKey
+> = T extends unknown ? Omit<T, K> : never;
 export type WithIntlProps<P> = DistributedOmit<P, keyof WrappedComponentProps> & {
-    forwardedRef?: React.Ref<any>;
+	forwardedRef?: React.Ref<any>;
 };
-export default function injectIntl<IntlPropName extends string = 'intl', P extends WrappedComponentProps<IntlPropName> = WrappedComponentProps<any>>(WrappedComponent: React.ComponentType<P>, options?: Opts<IntlPropName, false>): React.FC<WithIntlProps<P>> & {
-    WrappedComponent: React.ComponentType<P>;
+// TODO: type hoisted static methods.
+// Non ref forwarding overload
+export default function injectIntl<
+	IntlPropName extends string = "intl",
+	P extends WrappedComponentProps<IntlPropName> = WrappedComponentProps<any>
+>(WrappedComponent: React.ComponentType<P>, options?: Opts<IntlPropName, false>): React.FC<WithIntlProps<P>> & {
+	WrappedComponent: React.ComponentType<P>;
 };
-export default function injectIntl<IntlPropName extends string = 'intl', P extends WrappedComponentProps<IntlPropName> = WrappedComponentProps<any>, T extends React.ComponentType<P> = any>(WrappedComponent: React.ComponentType<P>, options?: Opts<IntlPropName, true>): React.ForwardRefExoticComponent<React.PropsWithoutRef<WithIntlProps<React.PropsWithChildren<P>>> & React.RefAttributes<T>> & {
-    WrappedComponent: React.ComponentType<P>;
+// Ref forwarding overload.
+export default function injectIntl<
+	IntlPropName extends string = "intl",
+	P extends WrappedComponentProps<IntlPropName> = WrappedComponentProps<any>,
+	T extends React.ComponentType<P> = any
+>(WrappedComponent: React.ComponentType<P>, options?: Opts<IntlPropName, true>): React.ForwardRefExoticComponent<React.PropsWithoutRef<WithIntlProps<React.PropsWithChildren<P>>> & React.RefAttributes<T>> & {
+	WrappedComponent: React.ComponentType<P>;
 };

package/src/components/injectIntl.js

@@ -1,38 +1,42 @@
-var _a;
-import { __assign } from "tslib";
+import * as hoistNonReactStaticsNs from "hoist-non-react-statics";
+import * as React from "react";
+import "../types.js";
+import { invariantIntlContext } from "../utils.js";
 import { jsx as _jsx } from "react/jsx-runtime";
-import * as hoistNonReactStaticsNs from 'hoist-non-react-statics';
-import * as React from 'react';
-import { invariantIntlContext } from '../utils.js';
-var hoistNonReactStatics = (_a = hoistNonReactStaticsNs.default) !== null && _a !== void 0 ? _a : hoistNonReactStaticsNs;
+const hoistNonReactStatics = hoistNonReactStaticsNs.default ?? hoistNonReactStaticsNs;
 function getDisplayName(Component) {
-    return Component.displayName || Component.name || 'Component';
+	return Component.displayName || Component.name || "Component";
 }
 // This is primarily dealing with packaging systems where multiple copies of react-intl
 // might exist
-var IntlContext = typeof window !== 'undefined' && !window.__REACT_INTL_BYPASS_GLOBAL_CONTEXT__
-    ? window.__REACT_INTL_CONTEXT__ ||
-        (window.__REACT_INTL_CONTEXT__ = React.createContext(null))
-    : React.createContext(null);
-var IntlConsumer = IntlContext.Consumer, IntlProvider = IntlContext.Provider;
-export var Provider = IntlProvider;
-export var Context = IntlContext;
+const IntlContext = typeof window !== "undefined" && !window.__REACT_INTL_BYPASS_GLOBAL_CONTEXT__ ? window.__REACT_INTL_CONTEXT__ || (window.__REACT_INTL_CONTEXT__ = React.createContext(null)) : React.createContext(null);
+const { Consumer: IntlConsumer, Provider: IntlProvider } = IntlContext;
+export const Provider = IntlProvider;
+export const Context = IntlContext;
 export default function injectIntl(WrappedComponent, options) {
-    var _a = options || {}, _b = _a.intlPropName, intlPropName = _b === void 0 ? 'intl' : _b, _c = _a.forwardRef, forwardRef = _c === void 0 ? false : _c, _d = _a.enforceContext, enforceContext = _d === void 0 ? true : _d;
-    var WithIntl = function (props) { return (_jsx(IntlConsumer, { children: function (intl) {
-            var _a;
-            if (enforceContext) {
-                invariantIntlContext(intl);
-            }
-            var intlProp = (_a = {}, _a[intlPropName] = intl, _a);
-            return (_jsx(WrappedComponent, __assign({}, props, intlProp, { ref: forwardRef ? props.forwardedRef : null })));
-        } })); };
-    WithIntl.displayName = "injectIntl(".concat(getDisplayName(WrappedComponent), ")");
-    WithIntl.WrappedComponent = WrappedComponent;
-    if (forwardRef) {
-        return hoistNonReactStatics(
-        // @ts-expect-error
-        React.forwardRef(function (props, ref) { return (_jsx(WithIntl, __assign({}, props, { forwardedRef: ref }))); }), WrappedComponent);
-    }
-    return hoistNonReactStatics(WithIntl, WrappedComponent);
+	const { intlPropName = "intl", forwardRef = false, enforceContext = true } = options || {};
+	const WithIntl = (props) => /* @__PURE__ */ _jsx(IntlConsumer, { children: (intl) => {
+		if (enforceContext) {
+			invariantIntlContext(intl);
+		}
+		const intlProp = { [intlPropName]: intl };
+		return /* @__PURE__ */ _jsx(WrappedComponent, {
+			...props,
+			...intlProp,
+			ref: forwardRef ? props.forwardedRef : null
+		});
+	} });
+	WithIntl.displayName = `injectIntl(${getDisplayName(WrappedComponent)})`;
+	WithIntl.WrappedComponent = WrappedComponent;
+	if (forwardRef) {
+		return hoistNonReactStatics(
+			// @ts-expect-error
+			React.forwardRef((props, ref) => /* @__PURE__ */ _jsx(WithIntl, {
+				...props,
+				forwardedRef: ref
+			})),
+			WrappedComponent
+		);
+	}
+	return hoistNonReactStatics(WithIntl, WrappedComponent);
 }

package/src/components/message.d.ts

@@ -1,11 +1,16 @@
-import type { FormatXMLElementFn, Options as IntlMessageFormatOptions, PrimitiveType } from 'intl-messageformat';
-import * as React from 'react';
-import { MessageDescriptor } from '@formatjs/intl';
+/*
+* Copyright 2015, Yahoo Inc.
+* Copyrights licensed under the New BSD License.
+* See the accompanying LICENSE file for terms.
+*/
+import type { FormatXMLElementFn, Options as IntlMessageFormatOptions, PrimitiveType } from "intl-messageformat";
+import * as React from "react";
+import { type MessageDescriptor } from "@formatjs/intl";
 export interface Props<V extends Record<string, any> = Record<string, React.ReactNode | PrimitiveType | FormatXMLElementFn<React.ReactNode>>> extends MessageDescriptor {
-    values?: V;
-    tagName?: React.ElementType<any>;
-    children?(nodes: React.ReactNode[]): React.ReactNode | null;
-    ignoreTag?: IntlMessageFormatOptions['ignoreTag'];
+	values?: V;
+	tagName?: React.ElementType<any>;
+	children?(nodes: React.ReactNode[]): React.ReactNode | null;
+	ignoreTag?: IntlMessageFormatOptions["ignoreTag"];
 }
 declare const MemoizedFormattedMessage: React.ComponentType<Props>;
 export default MemoizedFormattedMessage;

package/src/components/message.js

@@ -1,31 +1,32 @@
-import { __rest } from "tslib";
+import * as React from "react";
+import "@formatjs/intl";
+import { shallowEqual } from "../utils.js";
+import useIntl from "./useIntl.js";
 import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
-import * as React from 'react';
-import { shallowEqual } from '../utils.js';
-import useIntl from './useIntl.js';
 function areEqual(prevProps, nextProps) {
-    var values = prevProps.values, otherProps = __rest(prevProps, ["values"]);
-    var nextValues = nextProps.values, nextOtherProps = __rest(nextProps, ["values"]);
-    return (shallowEqual(nextValues, values) &&
-        shallowEqual(otherProps, nextOtherProps));
+	const { values, ...otherProps } = prevProps;
+	const { values: nextValues, ...nextOtherProps } = nextProps;
+	return shallowEqual(nextValues, values) && shallowEqual(otherProps, nextOtherProps);
 }
 function FormattedMessage(props) {
-    var intl = useIntl();
-    var formatMessage = intl.formatMessage, _a = intl.textComponent, Text = _a === void 0 ? React.Fragment : _a;
-    var id = props.id, description = props.description, defaultMessage = props.defaultMessage, values = props.values, children = props.children, _b = props.tagName, Component = _b === void 0 ? Text : _b, ignoreTag = props.ignoreTag;
-    var descriptor = { id: id, description: description, defaultMessage: defaultMessage };
-    var nodes = formatMessage(descriptor, values, {
-        ignoreTag: ignoreTag,
-    });
-    if (typeof children === 'function') {
-        return children(Array.isArray(nodes) ? nodes : [nodes]);
-    }
-    if (Component) {
-        return _jsx(Component, { children: nodes });
-    }
-    return _jsx(_Fragment, { children: nodes });
+	const intl = useIntl();
+	const { formatMessage, textComponent: Text = React.Fragment } = intl;
+	const { id, description, defaultMessage, values, children, tagName: Component = Text, ignoreTag } = props;
+	const descriptor = {
+		id,
+		description,
+		defaultMessage
+	};
+	const nodes = formatMessage(descriptor, values, { ignoreTag });
+	if (typeof children === "function") {
+		return children(Array.isArray(nodes) ? nodes : [nodes]);
+	}
+	if (Component) {
+		return /* @__PURE__ */ _jsx(Component, { children: nodes });
+	}
+	return /* @__PURE__ */ _jsx(_Fragment, { children: nodes });
 }
-FormattedMessage.displayName = 'FormattedMessage';
-var MemoizedFormattedMessage = React.memo(FormattedMessage, areEqual);
-MemoizedFormattedMessage.displayName = 'MemoizedFormattedMessage';
+FormattedMessage.displayName = "FormattedMessage";
+const MemoizedFormattedMessage = React.memo(FormattedMessage, areEqual);
+MemoizedFormattedMessage.displayName = "MemoizedFormattedMessage";
 export default MemoizedFormattedMessage;

package/src/components/plural.d.ts

@@ -1,14 +1,19 @@
-import * as React from 'react';
-import { FormatPluralOptions } from '@formatjs/intl';
+/*
+* Copyright 2015, Yahoo Inc.
+* Copyrights licensed under the New BSD License.
+* See the accompanying LICENSE file for terms.
+*/
+import * as React from "react";
+import { type FormatPluralOptions } from "@formatjs/intl";
 interface Props extends FormatPluralOptions {
-    value: number;
-    other: React.ReactNode;
-    zero?: React.ReactNode;
-    one?: React.ReactNode;
-    two?: React.ReactNode;
-    few?: React.ReactNode;
-    many?: React.ReactNode;
-    children?(value: React.ReactNode): React.ReactElement | null;
+	value: number;
+	other: React.ReactNode;
+	zero?: React.ReactNode;
+	one?: React.ReactNode;
+	two?: React.ReactNode;
+	few?: React.ReactNode;
+	many?: React.ReactNode;
+	children?(value: React.ReactNode): React.ReactElement | null;
 }
 declare const FormattedPlural: React.FC<Props>;
 export default FormattedPlural;