react-intl 10.1.0 → 10.1.2

package/index.d.ts

@@ -1,50 +1,170 @@
-import { type NumberFormatOptions } from "@formatjs/ecma402-abstract";
-import { type CustomFormatConfig, type FormatDateOptions, type FormatTimeOptions, type MessageDescriptor } from "@formatjs/intl";
 import * as React from "react";
-import { createIntl } from "./src/components/createIntl.js";
-import { Context as IntlContext, Provider as RawIntlProvider } from "./src/components/context.js";
-import FormattedDateTimeRange from "./src/components/dateTimeRange.js";
-import FormattedMessage from "./src/components/message.js";
-import FormattedPlural from "./src/components/plural.js";
-import IntlProvider from "./src/components/provider.js";
-import FormattedRelativeTime from "./src/components/relative.js";
-import useIntl from "./src/components/useIntl.js";
-import { type IntlShape } from "./src/types.js";
-export { createIntlCache, type CustomFormatConfig, type CustomFormats, type FormatDateOptions, type FormatDisplayNameOptions, type FormatListOptions, type FormatNumberOptions, type FormatPluralOptions, type FormatRelativeTimeOptions, type Formatters, type IntlCache, type IntlFormatters, InvalidConfigError, type MessageDescriptor, MessageFormatError, MissingDataError, MissingTranslationError, IntlError as ReactIntlError, IntlErrorCode as ReactIntlErrorCode, UnsupportedFormatterError } from "@formatjs/intl";
-export { type IntlConfig, type IntlShape, type ResolvedIntlConfig } from "./src/types.js";
-export { createIntl, FormattedDateTimeRange, FormattedMessage, FormattedPlural, FormattedRelativeTime, IntlContext, IntlProvider, RawIntlProvider, useIntl };
-export declare function defineMessages<
-	K extends keyof any,
-	T = MessageDescriptor,
-	U extends Record<K, T> = Record<K, T>
->(msgs: U): U;
-export declare function defineMessage<T extends MessageDescriptor>(msg: T): T;
-export declare const FormattedDate: React.FC<Intl.DateTimeFormatOptions & CustomFormatConfig<"date"> & {
-	value: string | number | Date | undefined;
-	children?(formattedDate: string): React.ReactElement | null;
-}>;
-export declare const FormattedTime: React.FC<Intl.DateTimeFormatOptions & CustomFormatConfig<"time"> & {
-	value: string | number | Date | undefined;
-	children?(formattedTime: string): React.ReactElement | null;
-}>;
-export declare const FormattedNumber: React.FC<Omit<NumberFormatOptions, "localeMatcher"> & CustomFormatConfig<"number"> & {
-	value: Parameters<IntlShape["formatNumber"]>[0];
-	children?(formattedNumber: string): React.ReactElement | null;
-}>;
-export declare const FormattedList: React.FC<Intl.ListFormatOptions & {
-	value: readonly React.ReactNode[];
-}>;
-export declare const FormattedDisplayName: React.FC<Intl.DisplayNamesOptions & {
-	value: string;
-}>;
-export declare const FormattedDateParts: React.FC<FormatDateOptions & {
-	value: Parameters<Intl.DateTimeFormat["format"]>[0] | string;
-	children(val: Intl.DateTimeFormatPart[]): React.ReactElement | null;
-}>;
-export declare const FormattedTimeParts: React.FC<FormatTimeOptions & {
-	value: Parameters<Intl.DateTimeFormat["format"]>[0] | string;
-	children(val: Intl.DateTimeFormatPart[]): React.ReactElement | null;
-}>;
-export type { MessageFormatElement } from "@formatjs/icu-messageformat-parser";
-export type { PrimitiveType } from "intl-messageformat";
-export { FormattedListParts, FormattedNumberParts } from "./src/components/createFormattedComponent.js";
+import { CreateIntlFn, CustomFormatConfig, CustomFormatConfig as CustomFormatConfig$1, CustomFormats, FormatDateOptions, FormatDateOptions as FormatDateOptions$1, FormatDateTimeRangeOptions, FormatDisplayNameOptions, FormatDisplayNameOptions as FormatDisplayNameOptions$1, FormatListOptions, FormatListOptions as FormatListOptions$1, FormatNumberOptions, FormatNumberOptions as FormatNumberOptions$1, FormatPluralOptions, FormatPluralOptions as FormatPluralOptions$1, FormatRelativeTimeOptions, FormatRelativeTimeOptions as FormatRelativeTimeOptions$1, FormatTimeOptions, Formatters, Formatters as Formatters$1, IntlCache, IntlError as ReactIntlError, IntlErrorCode as ReactIntlErrorCode, IntlFormatters, IntlFormatters as IntlFormatters$1, InvalidConfigError, MessageDescriptor, MessageDescriptor as MessageDescriptor$1, MessageFormatError, MissingDataError, MissingTranslationError, ResolvedIntlConfig as ResolvedIntlConfig$1, UnsupportedFormatterError, createIntlCache } from "@formatjs/intl";
+import { FormatXMLElementFn, Options, PrimitiveType, PrimitiveType as PrimitiveType$1 } from "intl-messageformat";
+import { MessageFormatElement } from "@formatjs/icu-messageformat-parser";
+
+//#region packages/ecma402-abstract/types/number.d.ts
+type NumberFormatNotation = "standard" | "scientific" | "engineering" | "compact";
+type RoundingPriorityType = "auto" | "morePrecision" | "lessPrecision";
+type RoundingModeType = "ceil" | "floor" | "expand" | "trunc" | "halfCeil" | "halfFloor" | "halfExpand" | "halfTrunc" | "halfEven";
+type UseGroupingType = "min2" | "auto" | "always" | boolean;
+interface NumberFormatDigitOptions {
+  minimumIntegerDigits?: number;
+  minimumSignificantDigits?: number;
+  maximumSignificantDigits?: number;
+  minimumFractionDigits?: number;
+  maximumFractionDigits?: number;
+  roundingPriority?: RoundingPriorityType;
+  roundingIncrement?: number;
+  roundingMode?: RoundingModeType;
+  trailingZeroDisplay?: TrailingZeroDisplay;
+}
+type NumberFormatOptionsLocaleMatcher = "lookup" | "best fit";
+type NumberFormatOptionsStyle = "decimal" | "percent" | "currency" | "unit";
+type NumberFormatOptionsCompactDisplay = "short" | "long";
+type NumberFormatOptionsCurrencyDisplay = "symbol" | "code" | "name" | "narrowSymbol";
+type NumberFormatOptionsCurrencySign = "standard" | "accounting";
+type NumberFormatOptionsNotation = NumberFormatNotation;
+type NumberFormatOptionsSignDisplay = "auto" | "always" | "never" | "exceptZero" | "negative";
+type NumberFormatOptionsUnitDisplay = "long" | "short" | "narrow";
+type TrailingZeroDisplay = "auto" | "stripIfInteger";
+type NumberFormatOptions = Omit<Intl.NumberFormatOptions, "signDisplay" | "useGrouping"> & NumberFormatDigitOptions & {
+  localeMatcher?: NumberFormatOptionsLocaleMatcher;
+  style?: NumberFormatOptionsStyle;
+  compactDisplay?: NumberFormatOptionsCompactDisplay;
+  currencyDisplay?: NumberFormatOptionsCurrencyDisplay;
+  currencySign?: NumberFormatOptionsCurrencySign;
+  notation?: NumberFormatOptionsNotation;
+  signDisplay?: NumberFormatOptionsSignDisplay;
+  unit?: string;
+  unitDisplay?: NumberFormatOptionsUnitDisplay;
+  numberingSystem?: string;
+  trailingZeroDisplay?: TrailingZeroDisplay;
+  roundingPriority?: RoundingPriorityType;
+  roundingIncrement?: number;
+  roundingMode?: RoundingModeType;
+  useGrouping?: UseGroupingType;
+};
+//#endregion
+//#region packages/react-intl/utils.d.ts
+type DefaultIntlConfig = Pick<ResolvedIntlConfig, "fallbackOnEmptyString" | "formats" | "messages" | "timeZone" | "textComponent" | "defaultLocale" | "defaultFormats" | "onError">;
+declare const DEFAULT_INTL_CONFIG$1: DefaultIntlConfig;
+//#endregion
+//#region packages/react-intl/types.d.ts
+type IntlConfig = Omit<ResolvedIntlConfig, keyof typeof DEFAULT_INTL_CONFIG$1> & Partial<typeof DEFAULT_INTL_CONFIG$1>;
+interface ResolvedIntlConfig extends ResolvedIntlConfig$1<React.ReactNode> {
+  textComponent?: React.ComponentType | keyof React.JSX.IntrinsicElements;
+  wrapRichTextChunksInFragment?: boolean;
+}
+interface IntlShape extends ResolvedIntlConfig, IntlFormatters$1<React.ReactNode> {
+  formatMessage(this: void, descriptor: MessageDescriptor$1, values?: Record<string, PrimitiveType$1 | FormatXMLElementFn<string, string>>, opts?: Options): string;
+  formatMessage(this: void, descriptor: MessageDescriptor$1, values?: Record<string, React.ReactNode | PrimitiveType$1 | FormatXMLElementFn<string, React.ReactNode>>, opts?: Options): Array<React.ReactNode>;
+  formatters: Formatters$1;
+}
+//#endregion
+//#region packages/react-intl/components/createIntl.d.ts
+/**
+* Create intl object
+* @param config intl config
+* @param cache cache for formatter instances to prevent memory leak
+*/
+declare const createIntl: CreateIntlFn<React.ReactNode, IntlConfig, IntlShape>;
+//#endregion
+//#region packages/react-intl/components/context.d.ts
+declare const IntlContext: React.Context<IntlShape>;
+declare const Provider: React.Provider<IntlShape>;
+//#endregion
+//#region packages/react-intl/components/dateTimeRange.d.ts
+interface Props$3 extends FormatDateTimeRangeOptions {
+  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$3>;
+//#endregion
+//#region packages/react-intl/components/message.d.ts
+interface Props$2<V extends Record<string, any> = Record<string, React.ReactNode | PrimitiveType$1 | FormatXMLElementFn<React.ReactNode>>> extends MessageDescriptor$1 {
+  values?: V;
+  tagName?: React.ElementType<any>;
+  children?(nodes: React.ReactNode[]): React.ReactNode | null;
+  ignoreTag?: Options["ignoreTag"];
+}
+declare const MemoizedFormattedMessage: React.ComponentType<Props$2>;
+//#endregion
+//#region packages/react-intl/components/plural.d.ts
+interface Props$1 extends FormatPluralOptions$1 {
+  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$1>;
+//#endregion
+//#region packages/react-intl/components/provider.d.ts
+declare const IntlProvider: React.FC<React.PropsWithChildren<IntlConfig>>;
+//#endregion
+//#region packages/react-intl/components/relative.d.ts
+interface Props extends FormatRelativeTimeOptions$1 {
+  value?: number;
+  unit?: Intl.RelativeTimeFormatUnit;
+  updateIntervalInSeconds?: number;
+  children?(value: string): React.ReactElement | null;
+}
+declare const FormattedRelativeTime: React.FC<Props>;
+//#endregion
+//#region packages/react-intl/components/useIntl.d.ts
+declare function useIntl(this: void): IntlShape;
+//#endregion
+//#region packages/react-intl/components/createFormattedComponent.d.ts
+type Formatter = {
+  formatDate: FormatDateOptions$1;
+  formatTime: FormatDateOptions$1;
+  formatNumber: FormatNumberOptions$1;
+  formatList: FormatListOptions$1;
+  formatDisplayName: FormatDisplayNameOptions$1;
+};
+declare const FormattedNumberParts: React.FC<Formatter["formatNumber"] & {
+  value: Parameters<IntlShape["formatNumber"]>[0];
+  children(val: Intl.NumberFormatPart[]): React.ReactElement | null;
+}>;
+declare const FormattedListParts: React.FC<Formatter["formatList"] & {
+  value: Parameters<IntlShape["formatList"]>[0];
+  children(val: ReturnType<Intl.ListFormat["formatToParts"]>): React.ReactElement | null;
+}>;
+//#endregion
+//#region packages/react-intl/index.d.ts
+declare function defineMessages<K extends keyof any, T = MessageDescriptor$1, U extends Record<K, T> = Record<K, T>>(msgs: U): U;
+declare function defineMessage<T extends MessageDescriptor$1>(msg: T): T;
+declare const FormattedDate: React.FC<Intl.DateTimeFormatOptions & CustomFormatConfig$1<"date"> & {
+  value: string | number | Date | undefined;
+  children?(formattedDate: string): React.ReactElement | null;
+}>;
+declare const FormattedTime: React.FC<Intl.DateTimeFormatOptions & CustomFormatConfig$1<"time"> & {
+  value: string | number | Date | undefined;
+  children?(formattedTime: string): React.ReactElement | null;
+}>;
+declare const FormattedNumber: React.FC<Omit<NumberFormatOptions, "localeMatcher"> & CustomFormatConfig$1<"number"> & {
+  value: Parameters<IntlShape["formatNumber"]>[0];
+  children?(formattedNumber: string): React.ReactElement | null;
+}>;
+declare const FormattedList: React.FC<Intl.ListFormatOptions & {
+  value: readonly React.ReactNode[];
+}>;
+declare const FormattedDisplayName: React.FC<Intl.DisplayNamesOptions & {
+  value: string;
+}>;
+declare const FormattedDateParts: React.FC<FormatDateOptions$1 & {
+  value: Parameters<Intl.DateTimeFormat["format"]>[0] | string;
+  children(val: Intl.DateTimeFormatPart[]): React.ReactElement | null;
+}>;
+declare const FormattedTimeParts: React.FC<FormatTimeOptions & {
+  value: Parameters<Intl.DateTimeFormat["format"]>[0] | string;
+  children(val: Intl.DateTimeFormatPart[]): React.ReactElement | null;
+}>;
+//#endregion
+export { type CustomFormatConfig, type CustomFormats, type FormatDateOptions, type FormatDisplayNameOptions, type FormatListOptions, type FormatNumberOptions, type FormatPluralOptions, type FormatRelativeTimeOptions, FormattedDate, FormattedDateParts, FormattedDateTimeRange, FormattedDisplayName, FormattedList, FormattedListParts, MemoizedFormattedMessage as FormattedMessage, FormattedNumber, FormattedNumberParts, FormattedPlural, FormattedRelativeTime, FormattedTime, FormattedTimeParts, type Formatters, type IntlCache, type IntlConfig, IntlContext, type IntlFormatters, IntlProvider, type IntlShape, InvalidConfigError, type MessageDescriptor, type MessageFormatElement, MessageFormatError, MissingDataError, MissingTranslationError, type PrimitiveType, Provider as RawIntlProvider, ReactIntlError, ReactIntlErrorCode, type ResolvedIntlConfig, UnsupportedFormatterError, createIntl, createIntlCache, defineMessage, defineMessages, useIntl };
+//# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1,36 +1,352 @@
 "use client";
-/*
-* Copyright 2015, Yahoo Inc.
-* Copyrights licensed under the New BSD License.
-* See the accompanying LICENSE file for terms.
-*/
-import "@formatjs/ecma402-abstract";
-import "@formatjs/intl";
 import * as React from "react";
-import { createFormattedComponent, createFormattedDateTimePartsComponent } from "./src/components/createFormattedComponent.js";
-import { createIntl } from "./src/components/createIntl.js";
-import { Context as IntlContext, Provider as RawIntlProvider } from "./src/components/context.js";
-import FormattedDateTimeRange from "./src/components/dateTimeRange.js";
-import FormattedMessage from "./src/components/message.js";
-import FormattedPlural from "./src/components/plural.js";
-import IntlProvider from "./src/components/provider.js";
-import FormattedRelativeTime from "./src/components/relative.js";
-import useIntl from "./src/components/useIntl.js";
-import "./src/types.js";
-export { createIntlCache, InvalidConfigError, MessageFormatError, MissingDataError, MissingTranslationError, IntlError as ReactIntlError, IntlErrorCode as ReactIntlErrorCode, UnsupportedFormatterError } from "@formatjs/intl";
-export { createIntl, FormattedDateTimeRange, FormattedMessage, FormattedPlural, FormattedRelativeTime, IntlContext, IntlProvider, RawIntlProvider, useIntl };
-export function defineMessages(msgs) {
+import { DEFAULT_INTL_CONFIG, IntlError as ReactIntlError, IntlErrorCode as ReactIntlErrorCode, InvalidConfigError, MessageFormatError, MissingDataError, MissingTranslationError, UnsupportedFormatterError, createIntl as createIntl$1, createIntlCache, createIntlCache as createIntlCache$1, formatMessage } from "@formatjs/intl";
+import { Fragment, jsx } from "react/jsx-runtime";
+import { isFormatXMLElementFn } from "intl-messageformat";
+//#region packages/react-intl/utils.tsx
+function invariant(condition, message, Err = Error) {
+	if (!condition) throw new Err(message);
+}
+function invariantIntlContext(intl) {
+	invariant(intl, "[React Intl] Could not find required `intl` object. <IntlProvider> needs to exist in the component ancestry.");
+}
+const DEFAULT_INTL_CONFIG$1 = {
+	...DEFAULT_INTL_CONFIG,
+	textComponent: React.Fragment
+};
+/**
+* Builds an array of {@link React.ReactNode}s with index-based keys, similar to
+* {@link React.Children.toArray}. However, this function tells React that it
+* was intentional, so they won't produce a bunch of warnings about it.
+*
+* React doesn't recommend doing this because it makes reordering inefficient,
+* but we mostly need this for message chunks, which don't tend to reorder to
+* begin with.
+*
+*/
+const toKeyedReactNodeArray = (children) => {
+	return React.Children.toArray(children).map((child, index) => {
+		if (React.isValidElement(child)) return /* @__PURE__ */ jsx(React.Fragment, { children: child }, index);
+		return child;
+	});
+};
+/**
+* Takes a `formatXMLElementFn`, and composes it in function, which passes
+* argument `parts` through, assigning unique key to each part, to prevent
+* "Each child in a list should have a unique "key"" React error.
+* @param formatXMLElementFn
+*/
+function assignUniqueKeysToParts(formatXMLElementFn) {
+	return function(parts) {
+		return formatXMLElementFn(toKeyedReactNodeArray(parts));
+	};
+}
+function shallowEqual(objA, objB) {
+	if (objA === objB) return true;
+	if (!objA || !objB) return false;
+	var aKeys = Object.keys(objA);
+	var bKeys = Object.keys(objB);
+	var len = aKeys.length;
+	if (bKeys.length !== len) return false;
+	for (var i = 0; i < len; i++) {
+		var key = aKeys[i];
+		if (objA[key] !== objB[key] || !Object.prototype.hasOwnProperty.call(objB, key)) return false;
+	}
+	return true;
+}
+//#endregion
+//#region packages/react-intl/components/context.ts
+const IntlContext = React.createContext(null);
+const Provider = IntlContext.Provider;
+//#endregion
+//#region packages/react-intl/components/useIntl.ts
+function useIntl() {
+	const intl = React.useContext(IntlContext);
+	invariantIntlContext(intl);
+	return intl;
+}
+//#endregion
+//#region packages/react-intl/components/createFormattedComponent.tsx
+var DisplayName = /* @__PURE__ */ function(DisplayName) {
+	DisplayName["formatDate"] = "FormattedDate";
+	DisplayName["formatTime"] = "FormattedTime";
+	DisplayName["formatNumber"] = "FormattedNumber";
+	DisplayName["formatList"] = "FormattedList";
+	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 || {});
+const FormattedNumberParts = (props) => {
+	const intl = useIntl();
+	const { value, children, ...formatProps } = props;
+	return children(intl.formatNumberToParts(value, formatProps));
+};
+FormattedNumberParts.displayName = "FormattedNumberParts";
+const FormattedListParts = (props) => {
+	const intl = useIntl();
+	const { value, children, ...formatProps } = props;
+	return children(intl.formatListToParts(value, formatProps));
+};
+FormattedNumberParts.displayName = "FormattedNumberParts";
+function createFormattedDateTimePartsComponent(name) {
+	const ComponentParts = (props) => {
+		const intl = useIntl();
+		const { value, children, ...formatProps } = props;
+		const date = typeof value === "string" ? new Date(value || 0) : value;
+		return children(name === "formatDate" ? intl.formatDateToParts(date, formatProps) : intl.formatTimeToParts(date, formatProps));
+	};
+	ComponentParts.displayName = DisplayNameParts[name];
+	return ComponentParts;
+}
+function createFormattedComponent(name) {
+	const Component = (props) => {
+		const intl = useIntl();
+		const { value, children, ...formatProps } = props;
+		const formattedValue = intl[name](value, formatProps);
+		if (typeof children === "function") return children(formattedValue);
+		return /* @__PURE__ */ jsx(intl.textComponent || React.Fragment, { children: formattedValue });
+	};
+	Component.displayName = DisplayName[name];
+	return Component;
+}
+//#endregion
+//#region packages/react-intl/components/createIntl.ts
+function assignUniqueKeysToFormatXMLElementFnArgument(values) {
+	if (!values) return values;
+	return Object.keys(values).reduce((acc, k) => {
+		const v = values[k];
+		acc[k] = isFormatXMLElementFn(v) ? assignUniqueKeysToParts(v) : v;
+		return acc;
+	}, {});
+}
+const formatMessage$1 = (config, formatters, descriptor, rawValues, ...rest) => {
+	const chunks = formatMessage(config, formatters, descriptor, assignUniqueKeysToFormatXMLElementFnArgument(rawValues), ...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
+*/
+const createIntl = ({ defaultRichTextElements: rawDefaultRichTextElements, ...config }, cache) => {
+	const defaultRichTextElements = assignUniqueKeysToFormatXMLElementFnArgument(rawDefaultRichTextElements);
+	const coreIntl = createIntl$1({
+		...DEFAULT_INTL_CONFIG$1,
+		...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$1.bind(null, resolvedConfig, coreIntl.formatters),
+		$t: formatMessage$1.bind(null, resolvedConfig, coreIntl.formatters)
+	};
+};
+//#endregion
+//#region packages/react-intl/components/dateTimeRange.tsx
+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);
+	return /* @__PURE__ */ jsx(intl.textComponent || React.Fragment, { children: formattedValue });
+};
+FormattedDateTimeRange.displayName = "FormattedDateTimeRange";
+//#endregion
+//#region packages/react-intl/components/message.tsx
+function areEqual(prevProps, nextProps) {
+	const { values, ...otherProps } = prevProps;
+	const { values: nextValues, ...nextOtherProps } = nextProps;
+	return shallowEqual(nextValues, values) && shallowEqual(otherProps, nextOtherProps);
+}
+function FormattedMessage(props) {
+	const { formatMessage, textComponent: Text = React.Fragment } = useIntl();
+	const { id, description, defaultMessage, values, children, tagName: Component = Text, ignoreTag } = props;
+	const nodes = formatMessage({
+		id,
+		description,
+		defaultMessage
+	}, 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";
+const MemoizedFormattedMessage = React.memo(FormattedMessage, areEqual);
+MemoizedFormattedMessage.displayName = "MemoizedFormattedMessage";
+//#endregion
+//#region packages/react-intl/components/plural.tsx
+const FormattedPlural = (props) => {
+	const { formatPlural, textComponent: Text } = useIntl();
+	const { value, other, children } = props;
+	const formattedPlural = props[formatPlural(value, props)] || other;
+	if (typeof children === "function") return children(formattedPlural);
+	if (Text) return /* @__PURE__ */ jsx(Text, { children: formattedPlural });
+	return formattedPlural;
+};
+FormattedPlural.displayName = "FormattedPlural";
+//#endregion
+//#region packages/react-intl/components/provider.tsx
+function processIntlConfig(config) {
+	return {
+		locale: config.locale,
+		timeZone: config.timeZone,
+		fallbackOnEmptyString: config.fallbackOnEmptyString,
+		formats: config.formats,
+		textComponent: config.textComponent,
+		messages: config.messages,
+		defaultLocale: config.defaultLocale,
+		defaultFormats: config.defaultFormats,
+		onError: config.onError,
+		onWarn: config.onWarn,
+		wrapRichTextChunksInFragment: config.wrapRichTextChunksInFragment,
+		defaultRichTextElements: config.defaultRichTextElements
+	};
+}
+function IntlProviderImpl(props) {
+	const cacheRef = React.useRef(createIntlCache$1());
+	const prevConfigRef = React.useRef(void 0);
+	const intlRef = React.useRef(void 0);
+	const filteredProps = {};
+	for (const key in props) if (props[key] !== void 0) filteredProps[key] = props[key];
+	const config = processIntlConfig({
+		...DEFAULT_INTL_CONFIG$1,
+		...filteredProps
+	});
+	if (!prevConfigRef.current || !shallowEqual(prevConfigRef.current, config)) {
+		prevConfigRef.current = config;
+		intlRef.current = createIntl(config, cacheRef.current);
+	}
+	invariantIntlContext(intlRef.current);
+	return /* @__PURE__ */ jsx(Provider, {
+		value: intlRef.current,
+		children: props.children
+	});
+}
+IntlProviderImpl.displayName = "IntlProvider";
+const IntlProvider = IntlProviderImpl;
+//#endregion
+//#region packages/react-intl/components/relative.tsx
+const MINUTE = 60;
+const HOUR = 3600;
+const DAY = 3600 * 24;
+function selectUnit(seconds) {
+	const absValue = Math.abs(seconds);
+	if (absValue < MINUTE) return "second";
+	if (absValue < HOUR) return "minute";
+	if (absValue < DAY) return "hour";
+	return "day";
+}
+function getDurationInSeconds(unit) {
+	switch (unit) {
+		case "second": return 1;
+		case "minute": return MINUTE;
+		case "hour": return HOUR;
+		default: return DAY;
+	}
+}
+function valueToSeconds(value, unit) {
+	if (!value) return 0;
+	switch (unit) {
+		case "second": return value;
+		case "minute": return value * MINUTE;
+		default: return value * HOUR;
+	}
+}
+const INCREMENTABLE_UNITS = [
+	"second",
+	"minute",
+	"hour"
+];
+function canIncrement(unit = "second") {
+	return INCREMENTABLE_UNITS.indexOf(unit) > -1;
+}
+const SimpleFormattedRelativeTime = (props) => {
+	const { formatRelativeTime, textComponent: Text } = useIntl();
+	const { children, value, unit, ...otherProps } = props;
+	const formattedRelativeTime = formatRelativeTime(value || 0, unit, otherProps);
+	if (typeof children === "function") return children(formattedRelativeTime);
+	if (Text) return /* @__PURE__ */ jsx(Text, { children: formattedRelativeTime });
+	return /* @__PURE__ */ jsx(Fragment, { children: formattedRelativeTime });
+};
+const FormattedRelativeTime = ({ value = 0, unit = "second", updateIntervalInSeconds, ...otherProps }) => {
+	invariant(!updateIntervalInSeconds || !!(updateIntervalInSeconds && canIncrement(unit)), "Cannot schedule update with unit longer than hour");
+	const [prevUnit, setPrevUnit] = React.useState();
+	const [prevValue, setPrevValue] = React.useState(0);
+	const [currentValueInSeconds, setCurrentValueInSeconds] = React.useState(0);
+	const updateTimer = React.useRef(void 0);
+	if (unit !== prevUnit || value !== prevValue) {
+		setPrevValue(value || 0);
+		setPrevUnit(unit);
+		setCurrentValueInSeconds(canIncrement(unit) ? valueToSeconds(value, unit) : 0);
+	}
+	React.useEffect(() => {
+		function clearUpdateTimer() {
+			clearTimeout(updateTimer.current);
+		}
+		clearUpdateTimer();
+		if (!updateIntervalInSeconds || !canIncrement(unit)) return clearUpdateTimer;
+		const nextValueInSeconds = currentValueInSeconds - updateIntervalInSeconds;
+		const nextUnit = selectUnit(nextValueInSeconds);
+		if (nextUnit === "day") return clearUpdateTimer;
+		const unitDuration = getDurationInSeconds(nextUnit);
+		const prevInterestingValueInSeconds = nextValueInSeconds - nextValueInSeconds % unitDuration;
+		const nextInterestingValueInSeconds = prevInterestingValueInSeconds >= currentValueInSeconds ? prevInterestingValueInSeconds - unitDuration : prevInterestingValueInSeconds;
+		const delayInSeconds = Math.abs(nextInterestingValueInSeconds - currentValueInSeconds);
+		if (currentValueInSeconds !== nextInterestingValueInSeconds) updateTimer.current = setTimeout(() => setCurrentValueInSeconds(nextInterestingValueInSeconds), delayInSeconds * 1e3);
+		return clearUpdateTimer;
+	}, [
+		currentValueInSeconds,
+		updateIntervalInSeconds,
+		unit
+	]);
+	let currentValue = value || 0;
+	let currentUnit = unit;
+	if (canIncrement(unit) && typeof currentValueInSeconds === "number" && updateIntervalInSeconds) {
+		currentUnit = selectUnit(currentValueInSeconds);
+		const unitDuration = getDurationInSeconds(currentUnit);
+		currentValue = Math.round(currentValueInSeconds / unitDuration);
+	}
+	return /* @__PURE__ */ jsx(SimpleFormattedRelativeTime, {
+		value: currentValue,
+		unit: currentUnit,
+		...otherProps
+	});
+};
+FormattedRelativeTime.displayName = "FormattedRelativeTime";
+//#endregion
+//#region packages/react-intl/index.ts
+function defineMessages(msgs) {
 	return msgs;
 }
-export function defineMessage(msg) {
+function defineMessage(msg) {
 	return msg;
 }
-// IMPORTANT: Explicit here to prevent api-extractor from outputing `import('./src/types').CustomFormatConfig`
-export const FormattedDate = createFormattedComponent("formatDate");
-export const FormattedTime = createFormattedComponent("formatTime");
-export const FormattedNumber = createFormattedComponent("formatNumber");
-export const FormattedList = createFormattedComponent("formatList");
-export const FormattedDisplayName = createFormattedComponent("formatDisplayName");
-export const FormattedDateParts = createFormattedDateTimePartsComponent("formatDate");
-export const FormattedTimeParts = createFormattedDateTimePartsComponent("formatTime");
-export { FormattedListParts, FormattedNumberParts } from "./src/components/createFormattedComponent.js";
+const FormattedDate = createFormattedComponent("formatDate");
+const FormattedTime = createFormattedComponent("formatTime");
+const FormattedNumber = createFormattedComponent("formatNumber");
+const FormattedList = createFormattedComponent("formatList");
+const FormattedDisplayName = createFormattedComponent("formatDisplayName");
+const FormattedDateParts = createFormattedDateTimePartsComponent("formatDate");
+const FormattedTimeParts = createFormattedDateTimePartsComponent("formatTime");
+//#endregion
+export { FormattedDate, FormattedDateParts, FormattedDateTimeRange, FormattedDisplayName, FormattedList, FormattedListParts, MemoizedFormattedMessage as FormattedMessage, FormattedNumber, FormattedNumberParts, FormattedPlural, FormattedRelativeTime, FormattedTime, FormattedTimeParts, IntlContext, IntlProvider, InvalidConfigError, MessageFormatError, MissingDataError, MissingTranslationError, Provider as RawIntlProvider, ReactIntlError, ReactIntlErrorCode, UnsupportedFormatterError, createIntl, createIntlCache, defineMessage, defineMessages, useIntl };
+
+//# sourceMappingURL=index.js.map