react-intl 4.2.2 → 4.5.0

package/dist/react-intl.d.ts

@@ -1,11 +1,11 @@
-import * as React from 'react';
+import * as React_2 from 'react';
 
 declare type ArgumentElement = BaseElement<TYPE.argument>;
 
 declare interface BaseElement<T extends TYPE> {
     type: T;
     value: string;
-    location?: Location;
+    location?: Location_2;
 }
 
 /**
@@ -32,11 +32,13 @@ declare type DateElement = SimpleFormatElement<TYPE.date, DateTimeSkeleton>;
 declare interface DateTimeSkeleton {
     type: SKELETON_TYPE.dateTime;
     pattern: string;
-    location?: Location;
+    location?: Location_2;
 }
 
 declare const DEFAULT_INTL_CONFIG: Pick<IntlConfig, 'formats' | 'messages' | 'timeZone' | 'textComponent' | 'defaultLocale' | 'defaultFormats' | 'onError'>;
 
+export declare function defineMessage<T>(msg: T): T;
+
 export declare function defineMessages<T, U extends Record<string, T>>(msgs: U): U;
 
 declare class DisplayNames {
@@ -137,7 +139,15 @@ export declare type FormatDisplayNameOptions = Exclude<DisplayNamesOptions, 'loc
 
 declare class FormatError extends Error {
     readonly code: ErrorCode;
-    constructor(msg: string, code: ErrorCode);
+    /**
+     * Original message we're trying to format
+     * `undefined` if we're only dealing w/ AST
+     *
+     * @type {(string | undefined)}
+     * @memberof FormatError
+     */
+    readonly originalMessage: string | undefined;
+    constructor(msg: string, code: ErrorCode, originalMessage?: string);
     toString(): string;
 }
 
@@ -157,24 +167,24 @@ declare interface Formats {
 
 declare type FormattableUnit = Unit | Units;
 
-export declare const FormattedDate: React.FC<Intl.DateTimeFormatOptions & CustomFormatConfig & {
+export declare const FormattedDate: React_2.FC<Intl.DateTimeFormatOptions & CustomFormatConfig & {
     value: string | number | Date | undefined;
 }>;
 
-export declare const FormattedDateParts: React.FC<Intl.DateTimeFormatOptions & CustomFormatConfig & {
+export declare const FormattedDateParts: React_2.FC<Intl.DateTimeFormatOptions & CustomFormatConfig & {
     value: string | number | Date | undefined;
-    children(val: Intl.DateTimeFormatPart[]): React.ReactElement<any, string | ((props: any) => React.ReactElement<any, string | any | (new (props: any) => React.Component<any, any, any>)> | null) | (new (props: any) => React.Component<any, any, any>)> | null;
+    children(val: Intl.DateTimeFormatPart[]): React_2.ReactElement<any, string | ((props: any) => React_2.ReactElement<any, string | any | (new (props: any) => React_2.Component<any, any, any>)> | null) | (new (props: any) => React_2.Component<any, any, any>)> | null;
 }>;
 
-export declare const FormattedDisplayName: React.FC<DisplayNamesOptions & {
+export declare const FormattedDisplayName: React_2.FC<DisplayNamesOptions & {
     value: string | number | object;
 }>;
 
-export declare const FormattedList: React.FC<IntlListFormatOptions & {
-    value: React.ReactNode[];
+export declare const FormattedList: React_2.FC<IntlListFormatOptions & {
+    value: React_2.ReactNode[];
 }>;
 
-export declare class FormattedMessage<T = React.ReactNode, V extends Record<string, any> = Record<string, PrimitiveType | React.ReactElement | FormatXMLElementFn<T>>> extends React.Component<Props_3<V>> {
+export declare class FormattedMessage<V extends Record<string, any> = Record<string, PrimitiveType | React_2.ReactElement | FormatXMLElementFn<React_2.ReactNode, React_2.ReactNode>>> extends React_2.Component<Props_3<V>> {
     static displayName: string;
     static defaultProps: {
         values: {};
@@ -183,22 +193,22 @@ export declare class FormattedMessage<T = React.ReactNode, V extends Record<stri
     render(): JSX.Element;
 }
 
-export declare const FormattedNumber: React.FC<UnifiedNumberFormatOptions & CustomFormatConfig & {
+export declare const FormattedNumber: React_2.FC<UnifiedNumberFormatOptions & CustomFormatConfig & {
     value: number;
 }>;
 
-export declare const FormattedNumberParts: React.FC<Formatter['formatNumber'] & {
+export declare const FormattedNumberParts: React_2.FC<Formatter['formatNumber'] & {
     value: Parameters<IntlShape['formatNumber']>[0];
-    children(val: Intl.NumberFormatPart[]): React.ReactElement | null;
+    children(val: Intl.NumberFormatPart[]): React_2.ReactElement | null;
 }>;
 
-export declare const FormattedPlural: React.ForwardRefExoticComponent<Pick<Props_2, "children" | "other" | "zero" | "one" | "two" | "few" | "many" | "localeMatcher" | "format" | "type" | "value"> & {
-    forwardedRef?: ((instance: any) => void) | React.RefObject<any> | null | undefined;
-} & React.RefAttributes<any>> & {
-    WrappedComponent: React.ComponentType<Props_2>;
+export declare const FormattedPlural: React_2.ForwardRefExoticComponent<Pick<Props_2, "children" | "other" | "zero" | "one" | "two" | "few" | "many" | "localeMatcher" | "format" | "type" | "value"> & {
+    forwardedRef?: ((instance: any) => void) | React_2.RefObject<any> | null | undefined;
+} & React_2.RefAttributes<any>> & {
+    WrappedComponent: React_2.ComponentType<Props_2>;
 };
 
-export declare class FormattedRelativeTime extends React.PureComponent<Props, State_2> {
+export declare class FormattedRelativeTime extends React_2.PureComponent<Props, State_2> {
     _updateTimer: any;
     static displayName: string;
     static defaultProps: Pick<Props, 'unit' | 'value'>;
@@ -212,13 +222,13 @@ export declare class FormattedRelativeTime extends React.PureComponent<Props, St
     render(): JSX.Element;
 }
 
-export declare const FormattedTime: React.FC<Intl.DateTimeFormatOptions & CustomFormatConfig & {
+export declare const FormattedTime: React_2.FC<Intl.DateTimeFormatOptions & CustomFormatConfig & {
     value: string | number | Date | undefined;
 }>;
 
-export declare const FormattedTimeParts: React.FC<Intl.DateTimeFormatOptions & CustomFormatConfig & {
+export declare const FormattedTimeParts: React_2.FC<Intl.DateTimeFormatOptions & CustomFormatConfig & {
     value: string | number | Date | undefined;
-    children(val: Intl.DateTimeFormatPart[]): React.ReactElement<any, string | ((props: any) => React.ReactElement<any, string | any | (new (props: any) => React.Component<any, any, any>)> | null) | (new (props: any) => React.Component<any, any, any>)> | null;
+    children(val: Intl.DateTimeFormatPart[]): React_2.ReactElement<any, string | ((props: any) => React_2.ReactElement<any, string | any | (new (props: any) => React_2.Component<any, any, any>)> | null) | (new (props: any) => React_2.Component<any, any, any>)> | null;
 }>;
 
 declare type Formatter = {
@@ -245,14 +255,14 @@ declare interface Formatters_2 {
     getPluralRules(...args: ConstructorParameters<typeof Intl.PluralRules>): Intl.PluralRules;
 }
 
-declare type FormatXMLElementFn<T> = (...args: Array<string | T>) => string | Array<string | T>;
+declare type FormatXMLElementFn<T, R = string | Array<string | T>> = (...args: Array<string | T>) => R;
 
-export declare function injectIntl<IntlPropName extends string, P extends WrappedComponentProps<IntlPropName> = WrappedComponentProps<any>>(WrappedComponent: React.ComponentType<P>, options?: Opts<IntlPropName, false>): React.FC<WithIntlProps<P>> & {
-    WrappedComponent: React.ComponentType<P>;
+export declare function injectIntl<IntlPropName extends string, P extends WrappedComponentProps<IntlPropName> = WrappedComponentProps<any>>(WrappedComponent: React_2.ComponentType<P>, options?: Opts<IntlPropName, false>): React_2.FC<WithIntlProps<P>> & {
+    WrappedComponent: React_2.ComponentType<P>;
 };
 
-export declare 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<P>> & React.RefAttributes<T>> & {
-    WrappedComponent: React.ComponentType<P>;
+export declare function injectIntl<IntlPropName extends string = 'intl', P extends WrappedComponentProps<IntlPropName> = WrappedComponentProps<any>, T extends React_2.ComponentType<P> = any>(WrappedComponent: React_2.ComponentType<P>, options?: Opts<IntlPropName, true>): React_2.ForwardRefExoticComponent<React_2.PropsWithoutRef<WithIntlProps<P>> & React_2.RefAttributes<T>> & {
+    WrappedComponent: React_2.ComponentType<P>;
 };
 
 export declare interface IntlCache {
@@ -269,7 +279,7 @@ export declare interface IntlConfig {
     locale: string;
     timeZone?: string;
     formats: CustomFormats;
-    textComponent?: React.ComponentType | keyof React.ReactHTML;
+    textComponent?: React_2.ComponentType | keyof React_2.ReactHTML;
     messages: Record<string, string> | Record<string, MessageFormatElement[]>;
     defaultLocale: string;
     defaultFormats: CustomFormats;
@@ -277,9 +287,9 @@ export declare interface IntlConfig {
     onError(err: ReactIntlError | FormatError): void;
 }
 
-export declare const IntlContext: React.Context<IntlShape>;
+export declare const IntlContext: React_2.Context<IntlShape>;
 
-export declare interface IntlFormatters<T = React.ReactNode> {
+export declare interface IntlFormatters<T = React_2.ReactNode, R = T> {
     formatDate(value: Parameters<Intl.DateTimeFormat['format']>[0] | string, opts?: FormatDateOptions): string;
     formatTime(value: Parameters<Intl.DateTimeFormat['format']>[0] | string, opts?: FormatDateOptions): string;
     formatDateToParts(value: Parameters<Intl.DateTimeFormat['format']>[0] | string, opts?: FormatDateOptions): Intl.DateTimeFormatPart[];
@@ -289,9 +299,9 @@ export declare interface IntlFormatters<T = React.ReactNode> {
     formatNumberToParts(value: Parameters<Intl.NumberFormat['format']>[0], opts?: FormatNumberOptions): Intl.NumberFormatPart[];
     formatPlural(value: Parameters<Intl.PluralRules['select']>[0], opts?: FormatPluralOptions): ReturnType<Intl.PluralRules['select']>;
     formatMessage(descriptor: MessageDescriptor, values?: Record<string, PrimitiveType>): string;
-    formatMessage(descriptor: MessageDescriptor, values?: Record<string, PrimitiveType | React.ReactElement | FormatXMLElementFn<T>>): string | React.ReactNodeArray;
+    formatMessage(descriptor: MessageDescriptor, values?: Record<string, PrimitiveType | React_2.ReactElement | FormatXMLElementFn<T, R>>): string | React_2.ReactNodeArray;
     formatList(values: Array<string>, opts?: FormatListOptions): string;
-    formatList(values: Array<string | React.ReactNode>, opts?: FormatListOptions): React.ReactNode;
+    formatList(values: Array<string | React_2.ReactNode>, opts?: FormatListOptions): React_2.ReactNode;
     formatDisplayName(value: Parameters<DisplayNames['of']>[0], opts?: FormatDisplayNameOptions): string | undefined;
 }
 
@@ -329,13 +339,14 @@ declare class IntlMessageFormat {
     private readonly message;
     private readonly formatterCache;
     constructor(message: string | MessageFormatElement[], locales?: string | string[], overrideFormats?: Partial<Formats>, opts?: Options);
-    format: <T = void>(values?: Record<string, string | number | boolean | Date | T | FormatXMLElementFn<T> | null | undefined> | undefined) => string | T | (string | T)[];
-    formatToParts: <T>(values?: Record<string, string | number | boolean | Date | T | FormatXMLElementFn<T> | null | undefined> | undefined) => MessageFormatPart<T>[];
+    format: <T = void>(values?: Record<string, string | number | boolean | Date | T | FormatXMLElementFn<T, string | (string | T)[]> | null | undefined> | undefined) => string | T | (string | T)[];
+    formatToParts: <T>(values?: Record<string, string | number | boolean | Date | T | FormatXMLElementFn<T, string | (string | T)[]> | null | undefined> | undefined) => MessageFormatPart<T>[];
     resolvedOptions: () => {
         locale: string;
     };
     getAst: () => MessageFormatElement[];
-    static defaultLocale: string;
+    private static memoizedDefaultLocale;
+    static get defaultLocale(): string;
     static __parse: typeof parse | undefined;
     static formats: {
         number: {
@@ -395,7 +406,7 @@ declare class IntlMessageFormat {
     };
 }
 
-export declare class IntlProvider extends React.PureComponent<OptionalIntlConfig, State> {
+export declare class IntlProvider extends React_2.PureComponent<OptionalIntlConfig, State> {
     static displayName: string;
     static defaultProps: Pick<IntlConfig, "formats" | "messages" | "timeZone" | "textComponent" | "defaultLocale" | "defaultFormats" | "onError">;
     private cache;
@@ -509,7 +520,7 @@ declare type LocaleFieldsData = {
     nu?: Array<string | null>;
 };
 
-declare interface Location {
+declare interface Location_2 {
     start: LocationDetails;
     end: LocationDetails;
 }
@@ -543,7 +554,7 @@ declare interface NumberFormatDigitOptions {
 declare interface NumberSkeleton {
     type: SKELETON_TYPE.number;
     tokens: NumberSkeletonToken[];
-    location?: Location;
+    location?: Location_2;
 }
 
 declare interface NumberSkeletonToken {
@@ -556,9 +567,10 @@ declare interface ObjectPart<T = any> {
     value: T;
 }
 
-export declare type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
+declare type Omit_2<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
+export { Omit_2 as Omit }
 
-declare type OptionalIntlConfig = Omit<IntlConfig, keyof typeof DEFAULT_INTL_CONFIG> & Partial<typeof DEFAULT_INTL_CONFIG>;
+declare type OptionalIntlConfig = Omit_2<IntlConfig, keyof typeof DEFAULT_INTL_CONFIG> & Partial<typeof DEFAULT_INTL_CONFIG>;
 
 declare interface Options {
     formatters?: Formatters_2;
@@ -605,12 +617,12 @@ declare interface PluralElement extends BaseElement<TYPE.plural> {
 
 declare interface PluralOrSelectOption {
     value: MessageFormatElement[];
-    location?: Location;
+    location?: Location_2;
 }
 
 declare interface PoundElement {
     type: TYPE.pound;
-    location?: Location;
+    location?: Location_2;
 }
 
 declare type PrimitiveType = string | number | boolean | null | undefined | Date;
@@ -619,32 +631,33 @@ declare interface Props extends FormatRelativeTimeOptions {
     value?: number;
     unit?: Unit;
     updateIntervalInSeconds?: number;
-    children?(value: string): React.ReactChild;
+    children?(value: string): React_2.ReactChild;
 }
 
 declare interface Props_2 extends FormatPluralOptions {
     value: number;
     intl: IntlShape;
-    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;
+    other: React_2.ReactNode;
+    zero?: React_2.ReactNode;
+    one?: React_2.ReactNode;
+    two?: React_2.ReactNode;
+    few?: React_2.ReactNode;
+    many?: React_2.ReactNode;
+    children?(value: React_2.ReactNode): React_2.ReactElement | null;
 }
 
-declare interface Props_3<V extends Record<string, any> = Record<string, React.ReactNode>> extends MessageDescriptor {
+declare interface Props_3<V extends Record<string, any> = Record<string, React_2.ReactNode>> extends MessageDescriptor {
     values?: V;
-    tagName?: React.ElementType<any>;
-    children?(...nodes: React.ReactNodeArray): React.ReactNode;
+    tagName?: React_2.ElementType<any>;
+    children?(...nodes: React_2.ReactNodeArray): React_2.ReactNode;
 }
 
-export declare const RawIntlProvider: React.Provider<IntlShape>;
+export declare const RawIntlProvider: React_2.Provider<IntlShape>;
 
 export declare class ReactIntlError extends Error {
-    code: ReactIntlErrorCode;
-    constructor(code: ReactIntlErrorCode, message: string, exception?: Error);
+    readonly code: ReactIntlErrorCode;
+    readonly descriptor?: MessageDescriptor;
+    constructor(code: ReactIntlErrorCode, message: string, descriptor?: MessageDescriptor, exception?: Error);
 }
 
 export declare const enum ReactIntlErrorCode {
@@ -772,7 +785,7 @@ declare interface TagElement {
     type: TYPE.tag;
     value: string;
     children: MessageFormatElement[];
-    location?: Location;
+    location?: Location_2;
 }
 
 declare type TimeElement = SimpleFormatElement<TYPE.time, DateTimeSkeleton>;
@@ -861,8 +874,8 @@ export declare function useIntl(): IntlShape;
 
 declare type ValidPluralRule = 'zero' | 'one' | 'two' | 'few' | 'many' | 'other' | string;
 
-export declare type WithIntlProps<P> = Omit<P, keyof WrappedComponentProps> & {
-    forwardedRef?: React.Ref<any>;
+export declare type WithIntlProps<P> = Omit_2<P, keyof WrappedComponentProps> & {
+    forwardedRef?: React_2.Ref<any>;
 };
 
 export declare type WrappedComponentProps<IntlPropName extends string = 'intl'> = {

package/dist/react-intl.js

@@ -277,6 +277,13 @@
 
     TYPE[TYPE["tag"] = 8] = "tag";
   })(TYPE || (TYPE = {}));
+
+  var SKELETON_TYPE;
+
+  (function (SKELETON_TYPE) {
+    SKELETON_TYPE[SKELETON_TYPE["number"] = 0] = "number";
+    SKELETON_TYPE[SKELETON_TYPE["dateTime"] = 1] = "dateTime";
+  })(SKELETON_TYPE || (SKELETON_TYPE = {}));
   /**
    * Type Guards
    */
@@ -3991,7 +3998,7 @@
     return unit.replace(/^(.*?)-/, '');
   }
 
-  var FRACTION_PRECISION_REGEX = /^\.(?:(0+)(\+|#+)?)?$/g;
+  var FRACTION_PRECISION_REGEX = /^\.(?:(0+)(\*)?|(#+)|(0+)(#+))$/g;
   var SIGNIFICANT_PRECISION_REGEX = /^(@+)?(\+|#+)?$/g;
 
   function parseSignificantPrecision(str) {
@@ -4095,6 +4102,7 @@
           continue;
 
         case 'precision-integer':
+        case '.':
           result.maximumFractionDigits = 0;
           continue;
 
@@ -4154,6 +4162,7 @@
           continue;
       } // Precision
       // https://github.com/unicode-org/icu/blob/master/docs/userguide/format_parse/numbers/skeletons.md#fraction-precision
+      // precision-integer case
 
 
       if (FRACTION_PRECISION_REGEX.test(token.stem)) {
@@ -4161,21 +4170,21 @@
           throw new RangeError('Fraction-precision stems only accept a single optional option');
         }
 
-        token.stem.replace(FRACTION_PRECISION_REGEX, function (match, g1, g2) {
-          // precision-integer case
-          if (match === '.') {
-            result.maximumFractionDigits = 0;
-          } // .000+ case
-          else if (g2 === '+') {
-              result.minimumFractionDigits = g2.length;
-            } // .### case
-            else if (g1[0] === '#') {
+        token.stem.replace(FRACTION_PRECISION_REGEX, function (match, g1, g2, g3, g4, g5) {
+          // .000* case (before ICU67 it was .000+)
+          if (g2 === '*') {
+            result.minimumFractionDigits = g1.length;
+          } // .### case
+          else if (g3 && g3[0] === '#') {
+              result.maximumFractionDigits = g3.length;
+            } // .00## case
+            else if (g4 && g5) {
+                result.minimumFractionDigits = g4.length;
+                result.maximumFractionDigits = g4.length + g5.length;
+              } else {
+                result.minimumFractionDigits = g1.length;
                 result.maximumFractionDigits = g1.length;
-              } // .00## or .000 case
-              else {
-                  result.minimumFractionDigits = g1.length;
-                  result.maximumFractionDigits = g1.length + (typeof g2 === 'string' ? g2.length : 0);
-                }
+              }
 
           return '';
         });
@@ -4317,10 +4326,11 @@
   function (_super) {
     __extends$1(FormatError, _super);
 
-    function FormatError(msg, code) {
+    function FormatError(msg, code, originalMessage) {
       var _this = _super.call(this, msg) || this;
 
       _this.code = code;
+      _this.originalMessage = originalMessage;
       return _this;
     }
 
@@ -4336,15 +4346,29 @@
   function (_super) {
     __extends$1(InvalidValueError, _super);
 
-    function InvalidValueError(variableId, value, options) {
+    function InvalidValueError(variableId, value, options, originalMessage) {
       return _super.call(this, "Invalid values for \"" + variableId + "\": \"" + value + "\". Options are \"" + Object.keys(options).join('", "') + "\"", "INVALID_VALUE"
       /* INVALID_VALUE */
-      ) || this;
+      , originalMessage) || this;
     }
 
     return InvalidValueError;
   }(FormatError);
 
+  var InvalidValueTypeError =
+  /** @class */
+  function (_super) {
+    __extends$1(InvalidValueTypeError, _super);
+
+    function InvalidValueTypeError(value, type, originalMessage) {
+      return _super.call(this, "Value for \"" + value + "\" must be of type " + type, "INVALID_VALUE"
+      /* INVALID_VALUE */
+      , originalMessage) || this;
+    }
+
+    return InvalidValueTypeError;
+  }(FormatError);
+
   var MissingValueError =
   /** @class */
   function (_super) {
@@ -4353,7 +4377,7 @@
     function MissingValueError(variableId, originalMessage) {
       return _super.call(this, "The intl string context variable \"" + variableId + "\" was not provided to the string \"" + originalMessage + "\"", "MISSING_VALUE"
       /* MISSING_VALUE */
-      ) || this;
+      , originalMessage) || this;
     }
 
     return MissingValueError;
@@ -4501,7 +4525,7 @@
         var formatFn = values[value_1];
 
         if (!isFormatXMLElementFn(formatFn)) {
-          throw new TypeError("Value for \"" + value_1 + "\" must be a function");
+          throw new InvalidValueTypeError(value_1, 'function', originalMessage);
         }
 
         var parts = formatToParts(children, locales, formatters, formats, values);
@@ -4529,7 +4553,7 @@
         var opt = el.options[value] || el.options.other;
 
         if (!opt) {
-          throw new InvalidValueError(el.value, value, Object.keys(el.options));
+          throw new InvalidValueError(el.value, value, Object.keys(el.options), originalMessage);
         }
 
         result.push.apply(result, formatToParts(opt.value, locales, formatters, formats, values));
@@ -4543,7 +4567,7 @@
           if (!Intl.PluralRules) {
             throw new FormatError("Intl.PluralRules is not available in this environment.\nTry polyfilling it using \"@formatjs/intl-pluralrules\"\n", "MISSING_INTL_API"
             /* MISSING_INTL_API */
-            );
+            , originalMessage);
           }
 
           var rule = formatters.getPluralRules(locales, {
@@ -4553,7 +4577,7 @@
         }
 
         if (!opt) {
-          throw new InvalidValueError(el.value, value, Object.keys(el.options));
+          throw new InvalidValueError(el.value, value, Object.keys(el.options), originalMessage);
         }
 
         result.push.apply(result, formatToParts(opt.value, locales, formatters, formats, values, value - (el.offset || 0)));
@@ -4707,7 +4731,18 @@
       this.formatters = opts && opts.formatters || createDefaultFormatters(this.formatterCache);
     }
 
-    IntlMessageFormat.defaultLocale = new Intl.NumberFormat().resolvedOptions().locale;
+    Object.defineProperty(IntlMessageFormat, "defaultLocale", {
+      get: function get() {
+        if (!IntlMessageFormat.memoizedDefaultLocale) {
+          IntlMessageFormat.memoizedDefaultLocale = new Intl.NumberFormat().resolvedOptions().locale;
+        }
+
+        return IntlMessageFormat.memoizedDefaultLocale;
+      },
+      enumerable: true,
+      configurable: true
+    });
+    IntlMessageFormat.memoizedDefaultLocale = null;
     IntlMessageFormat.__parse = parse; // Default format options used as the prototype of the `formats` provided to the
     // constructor. These are used when constructing the internal Intl.NumberFormat
     // and Intl.DateTimeFormat instances.
@@ -4800,13 +4835,14 @@
 
     var _super = _createSuper(ReactIntlError);
 
-    function ReactIntlError(code, message, exception) {
+    function ReactIntlError(code, message, descriptor, exception) {
       var _this;
 
       _classCallCheck(this, ReactIntlError);
 
       _this = _super.call(this, "[React Intl Error ".concat(code, "] ").concat(message, " ").concat(exception ? "\n".concat(exception.stack) : ''));
       _this.code = code;
+      _this.descriptor = descriptor;
 
       if (typeof Error.captureStackTrace === 'function') {
         Error.captureStackTrace(_assertThisInitialized(_this), ReactIntlError);
@@ -5322,7 +5358,9 @@
           invariantIntlContext(intl);
         }
 
-        return React.createElement(WrappedComponent, Object.assign({}, props, _defineProperty({}, intlPropName, intl), {
+        var intlProp = _defineProperty({}, intlPropName, intl);
+
+        return React.createElement(WrappedComponent, Object.assign({}, props, intlProp, {
           ref: forwardRef ? props.forwardedRef : null
         }));
       });
@@ -5412,7 +5450,8 @@
 
         var value = props.value,
             children = props.children,
-            formatProps = __rest(props, ["value", "children"]); // TODO: fix TS type definition for localeMatcher upstream
+            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);
@@ -5688,7 +5727,7 @@
       } catch (e) {
         onError(new ReactIntlError("FORMAT_ERROR"
         /* FORMAT_ERROR */
-        , "Error formatting message: \"".concat(id, "\" for locale: \"").concat(locale, "\"") + (defaultMessage ? ', using default message as fallback.' : ''), e));
+        , "Error formatting message: \"".concat(id, "\" for locale: \"").concat(locale, "\"") + (defaultMessage ? ', using default message as fallback.' : ''), messageDescriptor, e));
       }
     } else if (!defaultMessage || locale && locale.toLowerCase() !== defaultLocale.toLowerCase()) {
       // This prevents warnings from littering the console in development
@@ -5696,7 +5735,7 @@
       // default locale.
       onError(new ReactIntlError("MISSING_TRANSLATION"
       /* MISSING_TRANSLATION */
-      , "Missing message: \"".concat(id, "\" for locale: \"").concat(locale, "\"") + (defaultMessage ? ', using default message as fallback.' : '')));
+      , "Missing message: \"".concat(id, "\" for locale: \"").concat(locale, "\"") + (defaultMessage ? ', using default message as fallback.' : ''), messageDescriptor));
     }
 
     if (!formattedMessageParts && defaultMessage) {
@@ -5707,14 +5746,14 @@
       } catch (e) {
         onError(new ReactIntlError("FORMAT_ERROR"
         /* FORMAT_ERROR */
-        , "Error formatting the default message for: \"".concat(id, "\""), e));
+        , "Error formatting the default message for: \"".concat(id, "\""), messageDescriptor, e));
       }
     }
 
     if (!formattedMessageParts) {
       onError(new ReactIntlError("FORMAT_ERROR"
       /* FORMAT_ERROR */
-      , "Cannot format message: \"".concat(id, "\", ") + "using message ".concat(message || defaultMessage ? 'source' : 'id', " as fallback.")));
+      , "Cannot format message: \"".concat(id, "\", ") + "using message ".concat(message || defaultMessage ? 'source' : 'id', " as fallback."), messageDescriptor));
 
       if (typeof message === 'string') {
         return message || defaultMessage || String(id);
@@ -6313,6 +6352,9 @@
   function defineMessages(msgs) {
     return msgs;
   }
+  function defineMessage(msg) {
+    return msg;
+  }
 
   var FormattedDate = createFormattedComponent('formatDate');
   var FormattedTime = createFormattedComponent('formatTime');
@@ -6339,6 +6381,7 @@
   exports.ReactIntlError = ReactIntlError;
   exports.createIntl = createIntl;
   exports.createIntlCache = createIntlCache;
+  exports.defineMessage = defineMessage;
   exports.defineMessages = defineMessages;
   exports.injectIntl = injectIntl;
   exports.useIntl = useIntl;