@uzum-tech/ui 1.13.2 → 1.14.0

package/dist/index.js

@@ -15182,14 +15182,16 @@
               bPrefix: clsPrefix ? `.${clsPrefix}-` : void 0
             },
             anchorMetaName: cssrAnchorMetaName,
-            ssr: ssrAdapter
+            ssr: ssrAdapter,
+            parent: UConfigProvider?.styleMountTarget
           });
           if (!UConfigProvider?.preflightStyleDisabled) {
             globalStyle.mount({
               id: "u-global",
               head: true,
               anchorMetaName: cssrAnchorMetaName,
-              ssr: ssrAdapter
+              ssr: ssrAdapter,
+              parent: UConfigProvider?.styleMountTarget
             });
           }
         };
@@ -15275,7 +15277,7 @@
       return UConfigProvider ? UConfigProvider.mergedClsPrefixRef : vue.shallowRef(defaultClsPrefix);
     }
 
-    const enUS$1 = {
+    const enUS$2 = {
       name: "en-US",
       global: {
         undo: "Undo",
@@ -15575,487 +15577,650 @@
       }
     };
 
-    var formatDistanceLocale$1 = {
-      lessThanXSeconds: {
-        one: 'less than a second',
-        other: 'less than {{count}} seconds'
-      },
-      xSeconds: {
-        one: '1 second',
-        other: '{{count}} seconds'
-      },
-      halfAMinute: 'half a minute',
-      lessThanXMinutes: {
-        one: 'less than a minute',
-        other: 'less than {{count}} minutes'
-      },
-      xMinutes: {
-        one: '1 minute',
-        other: '{{count}} minutes'
-      },
-      aboutXHours: {
-        one: 'about 1 hour',
-        other: 'about {{count}} hours'
-      },
-      xHours: {
-        one: '1 hour',
-        other: '{{count}} hours'
-      },
-      xDays: {
-        one: '1 day',
-        other: '{{count}} days'
-      },
-      aboutXWeeks: {
-        one: 'about 1 week',
-        other: 'about {{count}} weeks'
-      },
-      xWeeks: {
-        one: '1 week',
-        other: '{{count}} weeks'
-      },
-      aboutXMonths: {
-        one: 'about 1 month',
-        other: 'about {{count}} months'
-      },
-      xMonths: {
-        one: '1 month',
-        other: '{{count}} months'
-      },
-      aboutXYears: {
-        one: 'about 1 year',
-        other: 'about {{count}} years'
-      },
-      xYears: {
-        one: '1 year',
-        other: '{{count}} years'
-      },
-      overXYears: {
-        one: 'over 1 year',
-        other: 'over {{count}} years'
-      },
-      almostXYears: {
-        one: 'almost 1 year',
-        other: 'almost {{count}} years'
-      }
-    };
-    var formatDistance$2 = function (token, count, options) {
-      var result;
-      var tokenValue = formatDistanceLocale$1[token];
-      if (typeof tokenValue === 'string') {
-        result = tokenValue;
-      } else if (count === 1) {
-        result = tokenValue.one;
-      } else {
-        result = tokenValue.other.replace('{{count}}', count.toString());
-      }
-      if (options !== null && options !== void 0 && options.addSuffix) {
-        if (options.comparison && options.comparison > 0) {
-          return 'in ' + result;
-        } else {
-          return result + ' ago';
-        }
-      }
-      return result;
-    };
+    var enUS$1 = {exports: {}};
 
-    function buildFormatLongFn$1(args) {
-      return function () {
-        var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-        // TODO: Remove String()
-        var width = options.width ? String(options.width) : args.defaultWidth;
-        var format = args.formats[width] || args.formats[args.defaultWidth];
-        return format;
-      };
-    }
+    var formatDistance$2 = {exports: {}};
 
-    var dateFormats$1 = {
-      full: 'EEEE, MMMM do, y',
-      long: 'MMMM do, y',
-      medium: 'MMM d, y',
-      short: 'MM/dd/yyyy'
-    };
-    var timeFormats$1 = {
-      full: 'h:mm:ss a zzzz',
-      long: 'h:mm:ss a z',
-      medium: 'h:mm:ss a',
-      short: 'h:mm a'
-    };
-    var dateTimeFormats$1 = {
-      full: "{{date}} 'at' {{time}}",
-      long: "{{date}} 'at' {{time}}",
-      medium: '{{date}}, {{time}}',
-      short: '{{date}}, {{time}}'
-    };
-    var formatLong$2 = {
-      date: buildFormatLongFn$1({
-        formats: dateFormats$1,
-        defaultWidth: 'full'
-      }),
-      time: buildFormatLongFn$1({
-        formats: timeFormats$1,
-        defaultWidth: 'full'
-      }),
-      dateTime: buildFormatLongFn$1({
-        formats: dateTimeFormats$1,
-        defaultWidth: 'full'
-      })
-    };
+    (function (module, exports) {
 
-    var formatRelativeLocale$1 = {
-      lastWeek: "'last' eeee 'at' p",
-      yesterday: "'yesterday at' p",
-      today: "'today at' p",
-      tomorrow: "'tomorrow at' p",
-      nextWeek: "eeee 'at' p",
-      other: 'P'
-    };
-    var formatRelative$2 = function (token, _date, _baseDate, _options) {
-      return formatRelativeLocale$1[token];
-    };
+    	Object.defineProperty(exports, "__esModule", {
+    	  value: true
+    	});
+    	exports.default = void 0;
+    	var formatDistanceLocale = {
+    	  lessThanXSeconds: {
+    	    one: 'less than a second',
+    	    other: 'less than {{count}} seconds'
+    	  },
+    	  xSeconds: {
+    	    one: '1 second',
+    	    other: '{{count}} seconds'
+    	  },
+    	  halfAMinute: 'half a minute',
+    	  lessThanXMinutes: {
+    	    one: 'less than a minute',
+    	    other: 'less than {{count}} minutes'
+    	  },
+    	  xMinutes: {
+    	    one: '1 minute',
+    	    other: '{{count}} minutes'
+    	  },
+    	  aboutXHours: {
+    	    one: 'about 1 hour',
+    	    other: 'about {{count}} hours'
+    	  },
+    	  xHours: {
+    	    one: '1 hour',
+    	    other: '{{count}} hours'
+    	  },
+    	  xDays: {
+    	    one: '1 day',
+    	    other: '{{count}} days'
+    	  },
+    	  aboutXWeeks: {
+    	    one: 'about 1 week',
+    	    other: 'about {{count}} weeks'
+    	  },
+    	  xWeeks: {
+    	    one: '1 week',
+    	    other: '{{count}} weeks'
+    	  },
+    	  aboutXMonths: {
+    	    one: 'about 1 month',
+    	    other: 'about {{count}} months'
+    	  },
+    	  xMonths: {
+    	    one: '1 month',
+    	    other: '{{count}} months'
+    	  },
+    	  aboutXYears: {
+    	    one: 'about 1 year',
+    	    other: 'about {{count}} years'
+    	  },
+    	  xYears: {
+    	    one: '1 year',
+    	    other: '{{count}} years'
+    	  },
+    	  overXYears: {
+    	    one: 'over 1 year',
+    	    other: 'over {{count}} years'
+    	  },
+    	  almostXYears: {
+    	    one: 'almost 1 year',
+    	    other: 'almost {{count}} years'
+    	  }
+    	};
+    	var formatDistance = function (token, count, options) {
+    	  var result;
+    	  var tokenValue = formatDistanceLocale[token];
+    	  if (typeof tokenValue === 'string') {
+    	    result = tokenValue;
+    	  } else if (count === 1) {
+    	    result = tokenValue.one;
+    	  } else {
+    	    result = tokenValue.other.replace('{{count}}', count.toString());
+    	  }
+    	  if (options !== null && options !== void 0 && options.addSuffix) {
+    	    if (options.comparison && options.comparison > 0) {
+    	      return 'in ' + result;
+    	    } else {
+    	      return result + ' ago';
+    	    }
+    	  }
+    	  return result;
+    	};
+    	var _default = formatDistance;
+    	exports.default = _default;
+    	module.exports = exports.default; 
+    } (formatDistance$2, formatDistance$2.exports));
 
-    function buildLocalizeFn$1(args) {
-      return function (dirtyIndex, dirtyOptions) {
-        var options = dirtyOptions || {};
-        var context = options.context ? String(options.context) : 'standalone';
-        var valuesArray;
-        if (context === 'formatting' && args.formattingValues) {
-          var defaultWidth = args.defaultFormattingWidth || args.defaultWidth;
-          var width = options.width ? String(options.width) : defaultWidth;
-          valuesArray = args.formattingValues[width] || args.formattingValues[defaultWidth];
-        } else {
-          var _defaultWidth = args.defaultWidth;
-          var _width = options.width ? String(options.width) : args.defaultWidth;
-          valuesArray = args.values[_width] || args.values[_defaultWidth];
-        }
-        var index = args.argumentCallback ? args.argumentCallback(dirtyIndex) : dirtyIndex; // @ts-ignore: For some reason TypeScript just don't want to match it, no matter how hard we try. I challenge you to try to remove it!
+    var formatDistanceExports = formatDistance$2.exports;
 
-        return valuesArray[index];
-      };
-    }
+    var formatLong$2 = {exports: {}};
 
-    var eraValues$1 = {
-      narrow: ['B', 'A'],
-      abbreviated: ['BC', 'AD'],
-      wide: ['Before Christ', 'Anno Domini']
-    };
-    var quarterValues$1 = {
-      narrow: ['1', '2', '3', '4'],
-      abbreviated: ['Q1', 'Q2', 'Q3', 'Q4'],
-      wide: ['1st quarter', '2nd quarter', '3rd quarter', '4th quarter']
-    }; // Note: in English, the names of days of the week and months are capitalized.
-    // If you are making a new locale based on this one, check if the same is true for the language you're working on.
-    // Generally, formatted dates should look like they are in the middle of a sentence,
-    // e.g. in Spanish language the weekdays and months should be in the lowercase.
+    var buildFormatLongFn$1 = {exports: {}};
 
-    var monthValues$1 = {
-      narrow: ['J', 'F', 'M', 'A', 'M', 'J', 'J', 'A', 'S', 'O', 'N', 'D'],
-      abbreviated: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
-      wide: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
-    };
-    var dayValues$1 = {
-      narrow: ['S', 'M', 'T', 'W', 'T', 'F', 'S'],
-      short: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'],
-      abbreviated: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
-      wide: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
-    };
-    var dayPeriodValues$1 = {
-      narrow: {
-        am: 'a',
-        pm: 'p',
-        midnight: 'mi',
-        noon: 'n',
-        morning: 'morning',
-        afternoon: 'afternoon',
-        evening: 'evening',
-        night: 'night'
-      },
-      abbreviated: {
-        am: 'AM',
-        pm: 'PM',
-        midnight: 'midnight',
-        noon: 'noon',
-        morning: 'morning',
-        afternoon: 'afternoon',
-        evening: 'evening',
-        night: 'night'
-      },
-      wide: {
-        am: 'a.m.',
-        pm: 'p.m.',
-        midnight: 'midnight',
-        noon: 'noon',
-        morning: 'morning',
-        afternoon: 'afternoon',
-        evening: 'evening',
-        night: 'night'
-      }
-    };
-    var formattingDayPeriodValues$1 = {
-      narrow: {
-        am: 'a',
-        pm: 'p',
-        midnight: 'mi',
-        noon: 'n',
-        morning: 'in the morning',
-        afternoon: 'in the afternoon',
-        evening: 'in the evening',
-        night: 'at night'
-      },
-      abbreviated: {
-        am: 'AM',
-        pm: 'PM',
-        midnight: 'midnight',
-        noon: 'noon',
-        morning: 'in the morning',
-        afternoon: 'in the afternoon',
-        evening: 'in the evening',
-        night: 'at night'
-      },
-      wide: {
-        am: 'a.m.',
-        pm: 'p.m.',
-        midnight: 'midnight',
-        noon: 'noon',
-        morning: 'in the morning',
-        afternoon: 'in the afternoon',
-        evening: 'in the evening',
-        night: 'at night'
-      }
-    };
-    var ordinalNumber$1 = function (dirtyNumber, _options) {
-      var number = Number(dirtyNumber); // If ordinal numbers depend on context, for example,
-      // if they are different for different grammatical genders,
-      // use `options.unit`.
-      //
-      // `unit` can be 'year', 'quarter', 'month', 'week', 'date', 'dayOfYear',
-      // 'day', 'hour', 'minute', 'second'.
+    (function (module, exports) {
+
+    	Object.defineProperty(exports, "__esModule", {
+    	  value: true
+    	});
+    	exports.default = buildFormatLongFn;
+    	function buildFormatLongFn(args) {
+    	  return function () {
+    	    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    	    // TODO: Remove String()
+    	    var width = options.width ? String(options.width) : args.defaultWidth;
+    	    var format = args.formats[width] || args.formats[args.defaultWidth];
+    	    return format;
+    	  };
+    	}
+    	module.exports = exports.default; 
+    } (buildFormatLongFn$1, buildFormatLongFn$1.exports));
+
+    var buildFormatLongFnExports = buildFormatLongFn$1.exports;
+
+    (function (module, exports) {
+
+    	Object.defineProperty(exports, "__esModule", {
+    	  value: true
+    	});
+    	exports.default = void 0;
+    	var _index = _interopRequireDefault(buildFormatLongFnExports);
+    	function _interopRequireDefault(obj) {
+    	  return obj && obj.__esModule ? obj : {
+    	    default: obj
+    	  };
+    	}
+    	var dateFormats = {
+    	  full: 'EEEE, MMMM do, y',
+    	  long: 'MMMM do, y',
+    	  medium: 'MMM d, y',
+    	  short: 'MM/dd/yyyy'
+    	};
+    	var timeFormats = {
+    	  full: 'h:mm:ss a zzzz',
+    	  long: 'h:mm:ss a z',
+    	  medium: 'h:mm:ss a',
+    	  short: 'h:mm a'
+    	};
+    	var dateTimeFormats = {
+    	  full: "{{date}} 'at' {{time}}",
+    	  long: "{{date}} 'at' {{time}}",
+    	  medium: '{{date}}, {{time}}',
+    	  short: '{{date}}, {{time}}'
+    	};
+    	var formatLong = {
+    	  date: (0, _index.default)({
+    	    formats: dateFormats,
+    	    defaultWidth: 'full'
+    	  }),
+    	  time: (0, _index.default)({
+    	    formats: timeFormats,
+    	    defaultWidth: 'full'
+    	  }),
+    	  dateTime: (0, _index.default)({
+    	    formats: dateTimeFormats,
+    	    defaultWidth: 'full'
+    	  })
+    	};
+    	var _default = formatLong;
+    	exports.default = _default;
+    	module.exports = exports.default; 
+    } (formatLong$2, formatLong$2.exports));
+
+    var formatLongExports = formatLong$2.exports;
+
+    var formatRelative$2 = {exports: {}};
+
+    (function (module, exports) {
+
+    	Object.defineProperty(exports, "__esModule", {
+    	  value: true
+    	});
+    	exports.default = void 0;
+    	var formatRelativeLocale = {
+    	  lastWeek: "'last' eeee 'at' p",
+    	  yesterday: "'yesterday at' p",
+    	  today: "'today at' p",
+    	  tomorrow: "'tomorrow at' p",
+    	  nextWeek: "eeee 'at' p",
+    	  other: 'P'
+    	};
+    	var formatRelative = function (token, _date, _baseDate, _options) {
+    	  return formatRelativeLocale[token];
+    	};
+    	var _default = formatRelative;
+    	exports.default = _default;
+    	module.exports = exports.default; 
+    } (formatRelative$2, formatRelative$2.exports));
+
+    var formatRelativeExports = formatRelative$2.exports;
+
+    var localize$2 = {exports: {}};
+
+    var buildLocalizeFn$1 = {exports: {}};
+
+    (function (module, exports) {
+
+    	Object.defineProperty(exports, "__esModule", {
+    	  value: true
+    	});
+    	exports.default = buildLocalizeFn;
+    	function buildLocalizeFn(args) {
+    	  return function (dirtyIndex, dirtyOptions) {
+    	    var options = dirtyOptions || {};
+    	    var context = options.context ? String(options.context) : 'standalone';
+    	    var valuesArray;
+    	    if (context === 'formatting' && args.formattingValues) {
+    	      var defaultWidth = args.defaultFormattingWidth || args.defaultWidth;
+    	      var width = options.width ? String(options.width) : defaultWidth;
+    	      valuesArray = args.formattingValues[width] || args.formattingValues[defaultWidth];
+    	    } else {
+    	      var _defaultWidth = args.defaultWidth;
+    	      var _width = options.width ? String(options.width) : args.defaultWidth;
+    	      valuesArray = args.values[_width] || args.values[_defaultWidth];
+    	    }
+    	    var index = args.argumentCallback ? args.argumentCallback(dirtyIndex) : dirtyIndex; // @ts-ignore: For some reason TypeScript just don't want to match it, no matter how hard we try. I challenge you to try to remove it!
+
+    	    return valuesArray[index];
+    	  };
+    	}
+    	module.exports = exports.default; 
+    } (buildLocalizeFn$1, buildLocalizeFn$1.exports));
+
+    var buildLocalizeFnExports = buildLocalizeFn$1.exports;
+
+    (function (module, exports) {
+
+    	Object.defineProperty(exports, "__esModule", {
+    	  value: true
+    	});
+    	exports.default = void 0;
+    	var _index = _interopRequireDefault(buildLocalizeFnExports);
+    	function _interopRequireDefault(obj) {
+    	  return obj && obj.__esModule ? obj : {
+    	    default: obj
+    	  };
+    	}
+    	var eraValues = {
+    	  narrow: ['B', 'A'],
+    	  abbreviated: ['BC', 'AD'],
+    	  wide: ['Before Christ', 'Anno Domini']
+    	};
+    	var quarterValues = {
+    	  narrow: ['1', '2', '3', '4'],
+    	  abbreviated: ['Q1', 'Q2', 'Q3', 'Q4'],
+    	  wide: ['1st quarter', '2nd quarter', '3rd quarter', '4th quarter']
+    	}; // Note: in English, the names of days of the week and months are capitalized.
+    	// If you are making a new locale based on this one, check if the same is true for the language you're working on.
+    	// Generally, formatted dates should look like they are in the middle of a sentence,
+    	// e.g. in Spanish language the weekdays and months should be in the lowercase.
+
+    	var monthValues = {
+    	  narrow: ['J', 'F', 'M', 'A', 'M', 'J', 'J', 'A', 'S', 'O', 'N', 'D'],
+    	  abbreviated: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
+    	  wide: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
+    	};
+    	var dayValues = {
+    	  narrow: ['S', 'M', 'T', 'W', 'T', 'F', 'S'],
+    	  short: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'],
+    	  abbreviated: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
+    	  wide: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
+    	};
+    	var dayPeriodValues = {
+    	  narrow: {
+    	    am: 'a',
+    	    pm: 'p',
+    	    midnight: 'mi',
+    	    noon: 'n',
+    	    morning: 'morning',
+    	    afternoon: 'afternoon',
+    	    evening: 'evening',
+    	    night: 'night'
+    	  },
+    	  abbreviated: {
+    	    am: 'AM',
+    	    pm: 'PM',
+    	    midnight: 'midnight',
+    	    noon: 'noon',
+    	    morning: 'morning',
+    	    afternoon: 'afternoon',
+    	    evening: 'evening',
+    	    night: 'night'
+    	  },
+    	  wide: {
+    	    am: 'a.m.',
+    	    pm: 'p.m.',
+    	    midnight: 'midnight',
+    	    noon: 'noon',
+    	    morning: 'morning',
+    	    afternoon: 'afternoon',
+    	    evening: 'evening',
+    	    night: 'night'
+    	  }
+    	};
+    	var formattingDayPeriodValues = {
+    	  narrow: {
+    	    am: 'a',
+    	    pm: 'p',
+    	    midnight: 'mi',
+    	    noon: 'n',
+    	    morning: 'in the morning',
+    	    afternoon: 'in the afternoon',
+    	    evening: 'in the evening',
+    	    night: 'at night'
+    	  },
+    	  abbreviated: {
+    	    am: 'AM',
+    	    pm: 'PM',
+    	    midnight: 'midnight',
+    	    noon: 'noon',
+    	    morning: 'in the morning',
+    	    afternoon: 'in the afternoon',
+    	    evening: 'in the evening',
+    	    night: 'at night'
+    	  },
+    	  wide: {
+    	    am: 'a.m.',
+    	    pm: 'p.m.',
+    	    midnight: 'midnight',
+    	    noon: 'noon',
+    	    morning: 'in the morning',
+    	    afternoon: 'in the afternoon',
+    	    evening: 'in the evening',
+    	    night: 'at night'
+    	  }
+    	};
+    	var ordinalNumber = function (dirtyNumber, _options) {
+    	  var number = Number(dirtyNumber); // If ordinal numbers depend on context, for example,
+    	  // if they are different for different grammatical genders,
+    	  // use `options.unit`.
+    	  //
+    	  // `unit` can be 'year', 'quarter', 'month', 'week', 'date', 'dayOfYear',
+    	  // 'day', 'hour', 'minute', 'second'.
+
+    	  var rem100 = number % 100;
+    	  if (rem100 > 20 || rem100 < 10) {
+    	    switch (rem100 % 10) {
+    	      case 1:
+    	        return number + 'st';
+    	      case 2:
+    	        return number + 'nd';
+    	      case 3:
+    	        return number + 'rd';
+    	    }
+    	  }
+    	  return number + 'th';
+    	};
+    	var localize = {
+    	  ordinalNumber: ordinalNumber,
+    	  era: (0, _index.default)({
+    	    values: eraValues,
+    	    defaultWidth: 'wide'
+    	  }),
+    	  quarter: (0, _index.default)({
+    	    values: quarterValues,
+    	    defaultWidth: 'wide',
+    	    argumentCallback: function (quarter) {
+    	      return quarter - 1;
+    	    }
+    	  }),
+    	  month: (0, _index.default)({
+    	    values: monthValues,
+    	    defaultWidth: 'wide'
+    	  }),
+    	  day: (0, _index.default)({
+    	    values: dayValues,
+    	    defaultWidth: 'wide'
+    	  }),
+    	  dayPeriod: (0, _index.default)({
+    	    values: dayPeriodValues,
+    	    defaultWidth: 'wide',
+    	    formattingValues: formattingDayPeriodValues,
+    	    defaultFormattingWidth: 'wide'
+    	  })
+    	};
+    	var _default = localize;
+    	exports.default = _default;
+    	module.exports = exports.default; 
+    } (localize$2, localize$2.exports));
+
+    var localizeExports = localize$2.exports;
+
+    var match$2 = {exports: {}};
+
+    var buildMatchFn$1 = {exports: {}};
+
+    (function (module, exports) {
+
+    	Object.defineProperty(exports, "__esModule", {
+    	  value: true
+    	});
+    	exports.default = buildMatchFn;
+    	function buildMatchFn(args) {
+    	  return function (string) {
+    	    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    	    var width = options.width;
+    	    var matchPattern = width && args.matchPatterns[width] || args.matchPatterns[args.defaultMatchWidth];
+    	    var matchResult = string.match(matchPattern);
+    	    if (!matchResult) {
+    	      return null;
+    	    }
+    	    var matchedString = matchResult[0];
+    	    var parsePatterns = width && args.parsePatterns[width] || args.parsePatterns[args.defaultParseWidth];
+    	    var key = Array.isArray(parsePatterns) ? findIndex(parsePatterns, function (pattern) {
+    	      return pattern.test(matchedString);
+    	    }) : findKey(parsePatterns, function (pattern) {
+    	      return pattern.test(matchedString);
+    	    });
+    	    var value;
+    	    value = args.valueCallback ? args.valueCallback(key) : key;
+    	    value = options.valueCallback ? options.valueCallback(value) : value;
+    	    var rest = string.slice(matchedString.length);
+    	    return {
+    	      value: value,
+    	      rest: rest
+    	    };
+    	  };
+    	}
+    	function findKey(object, predicate) {
+    	  for (var key in object) {
+    	    if (object.hasOwnProperty(key) && predicate(object[key])) {
+    	      return key;
+    	    }
+    	  }
+    	  return undefined;
+    	}
+    	function findIndex(array, predicate) {
+    	  for (var key = 0; key < array.length; key++) {
+    	    if (predicate(array[key])) {
+    	      return key;
+    	    }
+    	  }
+    	  return undefined;
+    	}
+    	module.exports = exports.default; 
+    } (buildMatchFn$1, buildMatchFn$1.exports));
+
+    var buildMatchFnExports = buildMatchFn$1.exports;
+
+    var buildMatchPatternFn$1 = {exports: {}};
+
+    (function (module, exports) {
+
+    	Object.defineProperty(exports, "__esModule", {
+    	  value: true
+    	});
+    	exports.default = buildMatchPatternFn;
+    	function buildMatchPatternFn(args) {
+    	  return function (string) {
+    	    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    	    var matchResult = string.match(args.matchPattern);
+    	    if (!matchResult) return null;
+    	    var matchedString = matchResult[0];
+    	    var parseResult = string.match(args.parsePattern);
+    	    if (!parseResult) return null;
+    	    var value = args.valueCallback ? args.valueCallback(parseResult[0]) : parseResult[0];
+    	    value = options.valueCallback ? options.valueCallback(value) : value;
+    	    var rest = string.slice(matchedString.length);
+    	    return {
+    	      value: value,
+    	      rest: rest
+    	    };
+    	  };
+    	}
+    	module.exports = exports.default; 
+    } (buildMatchPatternFn$1, buildMatchPatternFn$1.exports));
+
+    var buildMatchPatternFnExports = buildMatchPatternFn$1.exports;
+
+    (function (module, exports) {
+
+    	Object.defineProperty(exports, "__esModule", {
+    	  value: true
+    	});
+    	exports.default = void 0;
+    	var _index = _interopRequireDefault(buildMatchFnExports);
+    	var _index2 = _interopRequireDefault(buildMatchPatternFnExports);
+    	function _interopRequireDefault(obj) {
+    	  return obj && obj.__esModule ? obj : {
+    	    default: obj
+    	  };
+    	}
+    	var matchOrdinalNumberPattern = /^(\d+)(th|st|nd|rd)?/i;
+    	var parseOrdinalNumberPattern = /\d+/i;
+    	var matchEraPatterns = {
+    	  narrow: /^(b|a)/i,
+    	  abbreviated: /^(b\.?\s?c\.?|b\.?\s?c\.?\s?e\.?|a\.?\s?d\.?|c\.?\s?e\.?)/i,
+    	  wide: /^(before christ|before common era|anno domini|common era)/i
+    	};
+    	var parseEraPatterns = {
+    	  any: [/^b/i, /^(a|c)/i]
+    	};
+    	var matchQuarterPatterns = {
+    	  narrow: /^[1234]/i,
+    	  abbreviated: /^q[1234]/i,
+    	  wide: /^[1234](th|st|nd|rd)? quarter/i
+    	};
+    	var parseQuarterPatterns = {
+    	  any: [/1/i, /2/i, /3/i, /4/i]
+    	};
+    	var matchMonthPatterns = {
+    	  narrow: /^[jfmasond]/i,
+    	  abbreviated: /^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i,
+    	  wide: /^(january|february|march|april|may|june|july|august|september|october|november|december)/i
+    	};
+    	var parseMonthPatterns = {
+    	  narrow: [/^j/i, /^f/i, /^m/i, /^a/i, /^m/i, /^j/i, /^j/i, /^a/i, /^s/i, /^o/i, /^n/i, /^d/i],
+    	  any: [/^ja/i, /^f/i, /^mar/i, /^ap/i, /^may/i, /^jun/i, /^jul/i, /^au/i, /^s/i, /^o/i, /^n/i, /^d/i]
+    	};
+    	var matchDayPatterns = {
+    	  narrow: /^[smtwf]/i,
+    	  short: /^(su|mo|tu|we|th|fr|sa)/i,
+    	  abbreviated: /^(sun|mon|tue|wed|thu|fri|sat)/i,
+    	  wide: /^(sunday|monday|tuesday|wednesday|thursday|friday|saturday)/i
+    	};
+    	var parseDayPatterns = {
+    	  narrow: [/^s/i, /^m/i, /^t/i, /^w/i, /^t/i, /^f/i, /^s/i],
+    	  any: [/^su/i, /^m/i, /^tu/i, /^w/i, /^th/i, /^f/i, /^sa/i]
+    	};
+    	var matchDayPeriodPatterns = {
+    	  narrow: /^(a|p|mi|n|(in the|at) (morning|afternoon|evening|night))/i,
+    	  any: /^([ap]\.?\s?m\.?|midnight|noon|(in the|at) (morning|afternoon|evening|night))/i
+    	};
+    	var parseDayPeriodPatterns = {
+    	  any: {
+    	    am: /^a/i,
+    	    pm: /^p/i,
+    	    midnight: /^mi/i,
+    	    noon: /^no/i,
+    	    morning: /morning/i,
+    	    afternoon: /afternoon/i,
+    	    evening: /evening/i,
+    	    night: /night/i
+    	  }
+    	};
+    	var match = {
+    	  ordinalNumber: (0, _index2.default)({
+    	    matchPattern: matchOrdinalNumberPattern,
+    	    parsePattern: parseOrdinalNumberPattern,
+    	    valueCallback: function (value) {
+    	      return parseInt(value, 10);
+    	    }
+    	  }),
+    	  era: (0, _index.default)({
+    	    matchPatterns: matchEraPatterns,
+    	    defaultMatchWidth: 'wide',
+    	    parsePatterns: parseEraPatterns,
+    	    defaultParseWidth: 'any'
+    	  }),
+    	  quarter: (0, _index.default)({
+    	    matchPatterns: matchQuarterPatterns,
+    	    defaultMatchWidth: 'wide',
+    	    parsePatterns: parseQuarterPatterns,
+    	    defaultParseWidth: 'any',
+    	    valueCallback: function (index) {
+    	      return index + 1;
+    	    }
+    	  }),
+    	  month: (0, _index.default)({
+    	    matchPatterns: matchMonthPatterns,
+    	    defaultMatchWidth: 'wide',
+    	    parsePatterns: parseMonthPatterns,
+    	    defaultParseWidth: 'any'
+    	  }),
+    	  day: (0, _index.default)({
+    	    matchPatterns: matchDayPatterns,
+    	    defaultMatchWidth: 'wide',
+    	    parsePatterns: parseDayPatterns,
+    	    defaultParseWidth: 'any'
+    	  }),
+    	  dayPeriod: (0, _index.default)({
+    	    matchPatterns: matchDayPeriodPatterns,
+    	    defaultMatchWidth: 'any',
+    	    parsePatterns: parseDayPeriodPatterns,
+    	    defaultParseWidth: 'any'
+    	  })
+    	};
+    	var _default = match;
+    	exports.default = _default;
+    	module.exports = exports.default; 
+    } (match$2, match$2.exports));
 
-      var rem100 = number % 100;
-      if (rem100 > 20 || rem100 < 10) {
-        switch (rem100 % 10) {
-          case 1:
-            return number + 'st';
-          case 2:
-            return number + 'nd';
-          case 3:
-            return number + 'rd';
-        }
-      }
-      return number + 'th';
-    };
-    var localize$2 = {
-      ordinalNumber: ordinalNumber$1,
-      era: buildLocalizeFn$1({
-        values: eraValues$1,
-        defaultWidth: 'wide'
-      }),
-      quarter: buildLocalizeFn$1({
-        values: quarterValues$1,
-        defaultWidth: 'wide',
-        argumentCallback: function (quarter) {
-          return quarter - 1;
-        }
-      }),
-      month: buildLocalizeFn$1({
-        values: monthValues$1,
-        defaultWidth: 'wide'
-      }),
-      day: buildLocalizeFn$1({
-        values: dayValues$1,
-        defaultWidth: 'wide'
-      }),
-      dayPeriod: buildLocalizeFn$1({
-        values: dayPeriodValues$1,
-        defaultWidth: 'wide',
-        formattingValues: formattingDayPeriodValues$1,
-        defaultFormattingWidth: 'wide'
-      })
-    };
+    var matchExports = match$2.exports;
 
-    function buildMatchFn$1(args) {
-      return function (string) {
-        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-        var width = options.width;
-        var matchPattern = width && args.matchPatterns[width] || args.matchPatterns[args.defaultMatchWidth];
-        var matchResult = string.match(matchPattern);
-        if (!matchResult) {
-          return null;
-        }
-        var matchedString = matchResult[0];
-        var parsePatterns = width && args.parsePatterns[width] || args.parsePatterns[args.defaultParseWidth];
-        var key = Array.isArray(parsePatterns) ? findIndex$1(parsePatterns, function (pattern) {
-          return pattern.test(matchedString);
-        }) : findKey$1(parsePatterns, function (pattern) {
-          return pattern.test(matchedString);
-        });
-        var value;
-        value = args.valueCallback ? args.valueCallback(key) : key;
-        value = options.valueCallback ? options.valueCallback(value) : value;
-        var rest = string.slice(matchedString.length);
-        return {
-          value: value,
-          rest: rest
-        };
-      };
-    }
-    function findKey$1(object, predicate) {
-      for (var key in object) {
-        if (object.hasOwnProperty(key) && predicate(object[key])) {
-          return key;
-        }
-      }
-      return undefined;
-    }
-    function findIndex$1(array, predicate) {
-      for (var key = 0; key < array.length; key++) {
-        if (predicate(array[key])) {
-          return key;
-        }
-      }
-      return undefined;
-    }
+    (function (module, exports) {
 
-    function buildMatchPatternFn$1(args) {
-      return function (string) {
-        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-        var matchResult = string.match(args.matchPattern);
-        if (!matchResult) return null;
-        var matchedString = matchResult[0];
-        var parseResult = string.match(args.parsePattern);
-        if (!parseResult) return null;
-        var value = args.valueCallback ? args.valueCallback(parseResult[0]) : parseResult[0];
-        value = options.valueCallback ? options.valueCallback(value) : value;
-        var rest = string.slice(matchedString.length);
-        return {
-          value: value,
-          rest: rest
-        };
-      };
-    }
+    	Object.defineProperty(exports, "__esModule", {
+    	  value: true
+    	});
+    	exports.default = void 0;
+    	var _index = _interopRequireDefault(formatDistanceExports);
+    	var _index2 = _interopRequireDefault(formatLongExports);
+    	var _index3 = _interopRequireDefault(formatRelativeExports);
+    	var _index4 = _interopRequireDefault(localizeExports);
+    	var _index5 = _interopRequireDefault(matchExports);
+    	function _interopRequireDefault(obj) {
+    	  return obj && obj.__esModule ? obj : {
+    	    default: obj
+    	  };
+    	}
 
-    var matchOrdinalNumberPattern$1 = /^(\d+)(th|st|nd|rd)?/i;
-    var parseOrdinalNumberPattern$1 = /\d+/i;
-    var matchEraPatterns$1 = {
-      narrow: /^(b|a)/i,
-      abbreviated: /^(b\.?\s?c\.?|b\.?\s?c\.?\s?e\.?|a\.?\s?d\.?|c\.?\s?e\.?)/i,
-      wide: /^(before christ|before common era|anno domini|common era)/i
-    };
-    var parseEraPatterns$1 = {
-      any: [/^b/i, /^(a|c)/i]
-    };
-    var matchQuarterPatterns$1 = {
-      narrow: /^[1234]/i,
-      abbreviated: /^q[1234]/i,
-      wide: /^[1234](th|st|nd|rd)? quarter/i
-    };
-    var parseQuarterPatterns$1 = {
-      any: [/1/i, /2/i, /3/i, /4/i]
-    };
-    var matchMonthPatterns$1 = {
-      narrow: /^[jfmasond]/i,
-      abbreviated: /^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i,
-      wide: /^(january|february|march|april|may|june|july|august|september|october|november|december)/i
-    };
-    var parseMonthPatterns$1 = {
-      narrow: [/^j/i, /^f/i, /^m/i, /^a/i, /^m/i, /^j/i, /^j/i, /^a/i, /^s/i, /^o/i, /^n/i, /^d/i],
-      any: [/^ja/i, /^f/i, /^mar/i, /^ap/i, /^may/i, /^jun/i, /^jul/i, /^au/i, /^s/i, /^o/i, /^n/i, /^d/i]
-    };
-    var matchDayPatterns$1 = {
-      narrow: /^[smtwf]/i,
-      short: /^(su|mo|tu|we|th|fr|sa)/i,
-      abbreviated: /^(sun|mon|tue|wed|thu|fri|sat)/i,
-      wide: /^(sunday|monday|tuesday|wednesday|thursday|friday|saturday)/i
-    };
-    var parseDayPatterns$1 = {
-      narrow: [/^s/i, /^m/i, /^t/i, /^w/i, /^t/i, /^f/i, /^s/i],
-      any: [/^su/i, /^m/i, /^tu/i, /^w/i, /^th/i, /^f/i, /^sa/i]
-    };
-    var matchDayPeriodPatterns$1 = {
-      narrow: /^(a|p|mi|n|(in the|at) (morning|afternoon|evening|night))/i,
-      any: /^([ap]\.?\s?m\.?|midnight|noon|(in the|at) (morning|afternoon|evening|night))/i
-    };
-    var parseDayPeriodPatterns$1 = {
-      any: {
-        am: /^a/i,
-        pm: /^p/i,
-        midnight: /^mi/i,
-        noon: /^no/i,
-        morning: /morning/i,
-        afternoon: /afternoon/i,
-        evening: /evening/i,
-        night: /night/i
-      }
-    };
-    var match$2 = {
-      ordinalNumber: buildMatchPatternFn$1({
-        matchPattern: matchOrdinalNumberPattern$1,
-        parsePattern: parseOrdinalNumberPattern$1,
-        valueCallback: function (value) {
-          return parseInt(value, 10);
-        }
-      }),
-      era: buildMatchFn$1({
-        matchPatterns: matchEraPatterns$1,
-        defaultMatchWidth: 'wide',
-        parsePatterns: parseEraPatterns$1,
-        defaultParseWidth: 'any'
-      }),
-      quarter: buildMatchFn$1({
-        matchPatterns: matchQuarterPatterns$1,
-        defaultMatchWidth: 'wide',
-        parsePatterns: parseQuarterPatterns$1,
-        defaultParseWidth: 'any',
-        valueCallback: function (index) {
-          return index + 1;
-        }
-      }),
-      month: buildMatchFn$1({
-        matchPatterns: matchMonthPatterns$1,
-        defaultMatchWidth: 'wide',
-        parsePatterns: parseMonthPatterns$1,
-        defaultParseWidth: 'any'
-      }),
-      day: buildMatchFn$1({
-        matchPatterns: matchDayPatterns$1,
-        defaultMatchWidth: 'wide',
-        parsePatterns: parseDayPatterns$1,
-        defaultParseWidth: 'any'
-      }),
-      dayPeriod: buildMatchFn$1({
-        matchPatterns: matchDayPeriodPatterns$1,
-        defaultMatchWidth: 'any',
-        parsePatterns: parseDayPeriodPatterns$1,
-        defaultParseWidth: 'any'
-      })
-    };
+    	/**
+    	 * @type {Locale}
+    	 * @category Locales
+    	 * @summary English locale (United States).
+    	 * @language English
+    	 * @iso-639-2 eng
+    	 * @author Sasha Koss [@kossnocorp]{@link https://github.com/kossnocorp}
+    	 * @author Lesha Koss [@leshakoss]{@link https://github.com/leshakoss}
+    	 */
+    	var locale = {
+    	  code: 'en-US',
+    	  formatDistance: _index.default,
+    	  formatLong: _index2.default,
+    	  formatRelative: _index3.default,
+    	  localize: _index4.default,
+    	  match: _index5.default,
+    	  options: {
+    	    weekStartsOn: 0
+    	    /* Sunday */,
 
-    /**
-     * @type {Locale}
-     * @category Locales
-     * @summary English locale (United States).
-     * @language English
-     * @iso-639-2 eng
-     * @author Sasha Koss [@kossnocorp]{@link https://github.com/kossnocorp}
-     * @author Lesha Koss [@leshakoss]{@link https://github.com/leshakoss}
-     */
-    var locale$1 = {
-      code: 'en-US',
-      formatDistance: formatDistance$2,
-      formatLong: formatLong$2,
-      formatRelative: formatRelative$2,
-      localize: localize$2,
-      match: match$2,
-      options: {
-        weekStartsOn: 0
-        /* Sunday */,
+    	    firstWeekContainsDate: 1
+    	  }
+    	};
+    	var _default = locale;
+    	exports.default = _default;
+    	module.exports = exports.default; 
+    } (enUS$1, enUS$1.exports));
 
-        firstWeekContainsDate: 1
-      }
-    };
+    var enUSExports = enUS$1.exports;
+    var enUS = /*@__PURE__*/getDefaultExportFromCjs(enUSExports);
 
     const dateEnUs = {
       name: "en-US",
-      locale: locale$1
+      locale: enUS
     };
 
     function declension(scheme, count) {
@@ -16095,7 +16260,7 @@
         }
       };
     }
-    var formatDistanceLocale = {
+    var formatDistanceLocale$1 = {
       lessThanXSeconds: buildLocalizeTokenFn({
         regular: {
           one: 'меньше секунды',
@@ -16278,35 +16443,45 @@
     };
     function formatDistance$1(token, count, options) {
       options = options || {};
-      return formatDistanceLocale[token](count, options);
+      return formatDistanceLocale$1[token](count, options);
     }
 
-    var dateFormats = {
+    function buildFormatLongFn(args) {
+      return function () {
+        var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+        // TODO: Remove String()
+        var width = options.width ? String(options.width) : args.defaultWidth;
+        var format = args.formats[width] || args.formats[args.defaultWidth];
+        return format;
+      };
+    }
+
+    var dateFormats$1 = {
       full: "EEEE, d MMMM y 'г.'",
       long: "d MMMM y 'г.'",
       medium: "d MMM y 'г.'",
       short: 'dd.MM.y'
     };
-    var timeFormats = {
+    var timeFormats$1 = {
       full: 'H:mm:ss zzzz',
       long: 'H:mm:ss z',
       medium: 'H:mm:ss',
       short: 'H:mm'
     };
-    var dateTimeFormats = {
+    var dateTimeFormats$1 = {
       any: '{{date}}, {{time}}'
     };
     var formatLong$1 = {
-      date: buildFormatLongFn$1({
-        formats: dateFormats,
+      date: buildFormatLongFn({
+        formats: dateFormats$1,
         defaultWidth: 'full'
       }),
-      time: buildFormatLongFn$1({
-        formats: timeFormats,
+      time: buildFormatLongFn({
+        formats: timeFormats$1,
         defaultWidth: 'full'
       }),
-      dateTime: buildFormatLongFn$1({
-        formats: dateTimeFormats,
+      dateTime: buildFormatLongFn({
+        formats: dateTimeFormats$1,
         defaultWidth: 'any'
       })
     };
@@ -16449,7 +16624,7 @@
           return "'в следующую " + weekday + " в' p";
       }
     }
-    var formatRelativeLocale = {
+    var formatRelativeLocale$1 = {
       lastWeek: function (date, baseDate, options) {
         var day = date.getUTCDay();
         if (isSameUTCWeek(date, baseDate, options)) {
@@ -16472,24 +16647,44 @@
       other: 'P'
     };
     function formatRelative$1(token, date, baseDate, options) {
-      var format = formatRelativeLocale[token];
+      var format = formatRelativeLocale$1[token];
       if (typeof format === 'function') {
         return format(date, baseDate, options);
       }
       return format;
     }
 
-    var eraValues = {
+    function buildLocalizeFn(args) {
+      return function (dirtyIndex, dirtyOptions) {
+        var options = dirtyOptions || {};
+        var context = options.context ? String(options.context) : 'standalone';
+        var valuesArray;
+        if (context === 'formatting' && args.formattingValues) {
+          var defaultWidth = args.defaultFormattingWidth || args.defaultWidth;
+          var width = options.width ? String(options.width) : defaultWidth;
+          valuesArray = args.formattingValues[width] || args.formattingValues[defaultWidth];
+        } else {
+          var _defaultWidth = args.defaultWidth;
+          var _width = options.width ? String(options.width) : args.defaultWidth;
+          valuesArray = args.values[_width] || args.values[_defaultWidth];
+        }
+        var index = args.argumentCallback ? args.argumentCallback(dirtyIndex) : dirtyIndex; // @ts-ignore: For some reason TypeScript just don't want to match it, no matter how hard we try. I challenge you to try to remove it!
+
+        return valuesArray[index];
+      };
+    }
+
+    var eraValues$1 = {
       narrow: ['до н.э.', 'н.э.'],
       abbreviated: ['до н. э.', 'н. э.'],
       wide: ['до нашей эры', 'нашей эры']
     };
-    var quarterValues = {
+    var quarterValues$1 = {
       narrow: ['1', '2', '3', '4'],
       abbreviated: ['1-й кв.', '2-й кв.', '3-й кв.', '4-й кв.'],
       wide: ['1-й квартал', '2-й квартал', '3-й квартал', '4-й квартал']
     };
-    var monthValues = {
+    var monthValues$1 = {
       narrow: ['Я', 'Ф', 'М', 'А', 'М', 'И', 'И', 'А', 'С', 'О', 'Н', 'Д'],
       abbreviated: ['янв.', 'фев.', 'март', 'апр.', 'май', 'июнь', 'июль', 'авг.', 'сент.', 'окт.', 'нояб.', 'дек.'],
       wide: ['январь', 'февраль', 'март', 'апрель', 'май', 'июнь', 'июль', 'август', 'сентябрь', 'октябрь', 'ноябрь', 'декабрь']
@@ -16499,13 +16694,13 @@
       abbreviated: ['янв.', 'фев.', 'мар.', 'апр.', 'мая', 'июн.', 'июл.', 'авг.', 'сент.', 'окт.', 'нояб.', 'дек.'],
       wide: ['января', 'февраля', 'марта', 'апреля', 'мая', 'июня', 'июля', 'августа', 'сентября', 'октября', 'ноября', 'декабря']
     };
-    var dayValues = {
+    var dayValues$1 = {
       narrow: ['В', 'П', 'В', 'С', 'Ч', 'П', 'С'],
       short: ['вс', 'пн', 'вт', 'ср', 'чт', 'пт', 'сб'],
       abbreviated: ['вск', 'пнд', 'втр', 'срд', 'чтв', 'птн', 'суб'],
       wide: ['воскресенье', 'понедельник', 'вторник', 'среда', 'четверг', 'пятница', 'суббота']
     };
-    var dayPeriodValues = {
+    var dayPeriodValues$1 = {
       narrow: {
         am: 'ДП',
         pm: 'ПП',
@@ -16537,7 +16732,7 @@
         night: 'ночь'
       }
     };
-    var formattingDayPeriodValues = {
+    var formattingDayPeriodValues$1 = {
       narrow: {
         am: 'ДП',
         pm: 'ПП',
@@ -16569,7 +16764,7 @@
         night: 'ночи'
       }
     };
-    function ordinalNumber(dirtyNumber, dirtyOptions) {
+    function ordinalNumber$1(dirtyNumber, dirtyOptions) {
       var options = dirtyOptions || {};
       var unit = String(options.unit);
       var suffix;
@@ -16583,79 +16778,140 @@
       return dirtyNumber + suffix;
     }
     var localize$1 = {
-      ordinalNumber: ordinalNumber,
-      era: buildLocalizeFn$1({
-        values: eraValues,
+      ordinalNumber: ordinalNumber$1,
+      era: buildLocalizeFn({
+        values: eraValues$1,
         defaultWidth: 'wide'
       }),
-      quarter: buildLocalizeFn$1({
-        values: quarterValues,
+      quarter: buildLocalizeFn({
+        values: quarterValues$1,
         defaultWidth: 'wide',
         argumentCallback: function (quarter) {
           return Number(quarter) - 1;
         }
       }),
-      month: buildLocalizeFn$1({
-        values: monthValues,
+      month: buildLocalizeFn({
+        values: monthValues$1,
         defaultWidth: 'wide',
         formattingValues: formattingMonthValues,
         defaultFormattingWidth: 'wide'
       }),
-      day: buildLocalizeFn$1({
-        values: dayValues,
+      day: buildLocalizeFn({
+        values: dayValues$1,
         defaultWidth: 'wide'
       }),
-      dayPeriod: buildLocalizeFn$1({
-        values: dayPeriodValues,
+      dayPeriod: buildLocalizeFn({
+        values: dayPeriodValues$1,
         defaultWidth: 'any',
-        formattingValues: formattingDayPeriodValues,
+        formattingValues: formattingDayPeriodValues$1,
         defaultFormattingWidth: 'wide'
       })
     };
 
-    var matchOrdinalNumberPattern = /^(\d+)(-?(е|я|й|ое|ье|ая|ья|ый|ой|ий|ый))?/i;
-    var parseOrdinalNumberPattern = /\d+/i;
-    var matchEraPatterns = {
+    function buildMatchPatternFn(args) {
+      return function (string) {
+        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+        var matchResult = string.match(args.matchPattern);
+        if (!matchResult) return null;
+        var matchedString = matchResult[0];
+        var parseResult = string.match(args.parsePattern);
+        if (!parseResult) return null;
+        var value = args.valueCallback ? args.valueCallback(parseResult[0]) : parseResult[0];
+        value = options.valueCallback ? options.valueCallback(value) : value;
+        var rest = string.slice(matchedString.length);
+        return {
+          value: value,
+          rest: rest
+        };
+      };
+    }
+
+    function buildMatchFn(args) {
+      return function (string) {
+        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+        var width = options.width;
+        var matchPattern = width && args.matchPatterns[width] || args.matchPatterns[args.defaultMatchWidth];
+        var matchResult = string.match(matchPattern);
+        if (!matchResult) {
+          return null;
+        }
+        var matchedString = matchResult[0];
+        var parsePatterns = width && args.parsePatterns[width] || args.parsePatterns[args.defaultParseWidth];
+        var key = Array.isArray(parsePatterns) ? findIndex$1(parsePatterns, function (pattern) {
+          return pattern.test(matchedString);
+        }) : findKey$1(parsePatterns, function (pattern) {
+          return pattern.test(matchedString);
+        });
+        var value;
+        value = args.valueCallback ? args.valueCallback(key) : key;
+        value = options.valueCallback ? options.valueCallback(value) : value;
+        var rest = string.slice(matchedString.length);
+        return {
+          value: value,
+          rest: rest
+        };
+      };
+    }
+    function findKey$1(object, predicate) {
+      for (var key in object) {
+        if (object.hasOwnProperty(key) && predicate(object[key])) {
+          return key;
+        }
+      }
+      return undefined;
+    }
+    function findIndex$1(array, predicate) {
+      for (var key = 0; key < array.length; key++) {
+        if (predicate(array[key])) {
+          return key;
+        }
+      }
+      return undefined;
+    }
+
+    var matchOrdinalNumberPattern$1 = /^(\d+)(-?(е|я|й|ое|ье|ая|ья|ый|ой|ий|ый))?/i;
+    var parseOrdinalNumberPattern$1 = /\d+/i;
+    var matchEraPatterns$1 = {
       narrow: /^((до )?н\.?\s?э\.?)/i,
       abbreviated: /^((до )?н\.?\s?э\.?)/i,
       wide: /^(до нашей эры|нашей эры|наша эра)/i
     };
-    var parseEraPatterns = {
+    var parseEraPatterns$1 = {
       any: [/^д/i, /^н/i]
     };
-    var matchQuarterPatterns = {
+    var matchQuarterPatterns$1 = {
       narrow: /^[1234]/i,
       abbreviated: /^[1234](-?[ыои]?й?)? кв.?/i,
       wide: /^[1234](-?[ыои]?й?)? квартал/i
     };
-    var parseQuarterPatterns = {
+    var parseQuarterPatterns$1 = {
       any: [/1/i, /2/i, /3/i, /4/i]
     };
-    var matchMonthPatterns = {
+    var matchMonthPatterns$1 = {
       narrow: /^[яфмаисонд]/i,
       abbreviated: /^(янв|фев|март?|апр|ма[йя]|июн[ья]?|июл[ья]?|авг|сент?|окт|нояб?|дек)\.?/i,
       wide: /^(январ[ья]|феврал[ья]|марта?|апрел[ья]|ма[йя]|июн[ья]|июл[ья]|августа?|сентябр[ья]|октябр[ья]|октябр[ья]|ноябр[ья]|декабр[ья])/i
     };
-    var parseMonthPatterns = {
+    var parseMonthPatterns$1 = {
       narrow: [/^я/i, /^ф/i, /^м/i, /^а/i, /^м/i, /^и/i, /^и/i, /^а/i, /^с/i, /^о/i, /^н/i, /^я/i],
       any: [/^я/i, /^ф/i, /^мар/i, /^ап/i, /^ма[йя]/i, /^июн/i, /^июл/i, /^ав/i, /^с/i, /^о/i, /^н/i, /^д/i]
     };
-    var matchDayPatterns = {
+    var matchDayPatterns$1 = {
       narrow: /^[впсч]/i,
       short: /^(вс|во|пн|по|вт|ср|чт|че|пт|пя|сб|су)\.?/i,
       abbreviated: /^(вск|вос|пнд|пон|втр|вто|срд|сре|чтв|чет|птн|пят|суб).?/i,
       wide: /^(воскресень[ея]|понедельника?|вторника?|сред[аы]|четверга?|пятниц[аы]|суббот[аы])/i
     };
-    var parseDayPatterns = {
+    var parseDayPatterns$1 = {
       narrow: [/^в/i, /^п/i, /^в/i, /^с/i, /^ч/i, /^п/i, /^с/i],
       any: [/^в[ос]/i, /^п[он]/i, /^в/i, /^ср/i, /^ч/i, /^п[ят]/i, /^с[уб]/i]
     };
-    var matchDayPeriodPatterns = {
+    var matchDayPeriodPatterns$1 = {
       narrow: /^([дп]п|полн\.?|полд\.?|утр[оа]|день|дня|веч\.?|ноч[ьи])/i,
       abbreviated: /^([дп]п|полн\.?|полд\.?|утр[оа]|день|дня|веч\.?|ноч[ьи])/i,
       wide: /^([дп]п|полночь|полдень|утр[оа]|день|дня|вечера?|ноч[ьи])/i
     };
-    var parseDayPeriodPatterns = {
+    var parseDayPeriodPatterns$1 = {
       any: {
         am: /^дп/i,
         pm: /^пп/i,
@@ -16668,44 +16924,44 @@
       }
     };
     var match$1 = {
-      ordinalNumber: buildMatchPatternFn$1({
-        matchPattern: matchOrdinalNumberPattern,
-        parsePattern: parseOrdinalNumberPattern,
+      ordinalNumber: buildMatchPatternFn({
+        matchPattern: matchOrdinalNumberPattern$1,
+        parsePattern: parseOrdinalNumberPattern$1,
         valueCallback: function (value) {
           return parseInt(value, 10);
         }
       }),
-      era: buildMatchFn$1({
-        matchPatterns: matchEraPatterns,
+      era: buildMatchFn({
+        matchPatterns: matchEraPatterns$1,
         defaultMatchWidth: 'wide',
-        parsePatterns: parseEraPatterns,
+        parsePatterns: parseEraPatterns$1,
         defaultParseWidth: 'any'
       }),
-      quarter: buildMatchFn$1({
-        matchPatterns: matchQuarterPatterns,
+      quarter: buildMatchFn({
+        matchPatterns: matchQuarterPatterns$1,
         defaultMatchWidth: 'wide',
-        parsePatterns: parseQuarterPatterns,
+        parsePatterns: parseQuarterPatterns$1,
         defaultParseWidth: 'any',
         valueCallback: function (index) {
           return index + 1;
         }
       }),
-      month: buildMatchFn$1({
-        matchPatterns: matchMonthPatterns,
+      month: buildMatchFn({
+        matchPatterns: matchMonthPatterns$1,
         defaultMatchWidth: 'wide',
-        parsePatterns: parseMonthPatterns,
+        parsePatterns: parseMonthPatterns$1,
         defaultParseWidth: 'any'
       }),
-      day: buildMatchFn$1({
-        matchPatterns: matchDayPatterns,
+      day: buildMatchFn({
+        matchPatterns: matchDayPatterns$1,
         defaultMatchWidth: 'wide',
-        parsePatterns: parseDayPatterns,
+        parsePatterns: parseDayPatterns$1,
         defaultParseWidth: 'any'
       }),
-      dayPeriod: buildMatchFn$1({
-        matchPatterns: matchDayPeriodPatterns,
+      dayPeriod: buildMatchFn({
+        matchPatterns: matchDayPeriodPatterns$1,
         defaultMatchWidth: 'wide',
-        parsePatterns: parseDayPeriodPatterns,
+        parsePatterns: parseDayPeriodPatterns$1,
         defaultParseWidth: 'any'
       })
     };
@@ -16720,7 +16976,7 @@
      * @author Lesha Koss [@leshakoss]{@link https://github.com/leshakoss}
      */
 
-    var locale = {
+    var locale$1 = {
       code: 'ru',
       formatDistance: formatDistance$1,
       formatLong: formatLong$1,
@@ -16737,7 +16993,7 @@
 
     const dateRuRU = {
       name: "ru-RU",
-      locale: locale
+      locale: locale$1
     };
 
     function createLocale(locale, fallbackLocale) {
@@ -16750,7 +17006,7 @@
         mergedDateLocaleRef
       } = vue.inject(configProviderInjectionKey, null) || {};
       const localeRef = vue.computed(() => {
-        return mergedLocaleRef?.value?.[ns] ?? enUS$1[ns];
+        return mergedLocaleRef?.value?.[ns] ?? enUS$2[ns];
       });
       const dateLocaleRef = vue.computed(() => {
         return mergedDateLocaleRef?.value ?? dateEnUs;
@@ -16777,14 +17033,16 @@
           props: {
             bPrefix: clsPrefix ? `.${clsPrefix}-` : void 0
           },
-          ssr: ssrAdapter
+          ssr: ssrAdapter,
+          parent: UConfigProvider?.styleMountTarget
         });
         if (!UConfigProvider?.preflightStyleDisabled) {
           globalStyle.mount({
             id: "u-global",
             head: true,
             anchorMetaName: cssrAnchorMetaName,
-            ssr: ssrAdapter
+            ssr: ssrAdapter,
+            parent: UConfigProvider?.styleMountTarget
           });
         }
       };
@@ -16820,7 +17078,9 @@
 
     function useThemeClass(componentName, hashRef, cssVarsRef, props) {
       if (!cssVarsRef) throwError("useThemeClass", "cssVarsRef is not passed");
-      const mergedThemeHashRef = vue.inject(configProviderInjectionKey, null)?.mergedThemeHashRef;
+      const UConfigProvider = vue.inject(configProviderInjectionKey, null);
+      const mergedThemeHashRef = UConfigProvider?.mergedThemeHashRef;
+      const styleMountTarget = UConfigProvider?.styleMountTarget;
       const themeClassRef = vue.ref("");
       const ssrAdapter = useSsrAdapter();
       let renderCallback;
@@ -16850,7 +17110,8 @@
           }
           c$1(`.${finalThemeHash}`, style).mount({
             id: finalThemeHash,
-            ssr: ssrAdapter
+            ssr: ssrAdapter,
+            parent: styleMountTarget
           });
           renderCallback = void 0;
         };
@@ -16882,6 +17143,7 @@
         }
         return componentRtlState;
       });
+      const UConfigProvider = vue.inject(configProviderInjectionKey, null);
       const mountStyle = () => {
         vue.watchEffect(() => {
           const {
@@ -16900,7 +17162,8 @@
             props: {
               bPrefix: clsPrefix ? `.${clsPrefix}-` : void 0
             },
-            ssr: ssrAdapter
+            ssr: ssrAdapter,
+            parent: UConfigProvider?.styleMountTarget
           });
         });
       };
@@ -35468,6 +35731,393 @@
       return date;
     }
 
+    var formatDistanceLocale = {
+      lessThanXSeconds: {
+        one: 'less than a second',
+        other: 'less than {{count}} seconds'
+      },
+      xSeconds: {
+        one: '1 second',
+        other: '{{count}} seconds'
+      },
+      halfAMinute: 'half a minute',
+      lessThanXMinutes: {
+        one: 'less than a minute',
+        other: 'less than {{count}} minutes'
+      },
+      xMinutes: {
+        one: '1 minute',
+        other: '{{count}} minutes'
+      },
+      aboutXHours: {
+        one: 'about 1 hour',
+        other: 'about {{count}} hours'
+      },
+      xHours: {
+        one: '1 hour',
+        other: '{{count}} hours'
+      },
+      xDays: {
+        one: '1 day',
+        other: '{{count}} days'
+      },
+      aboutXWeeks: {
+        one: 'about 1 week',
+        other: 'about {{count}} weeks'
+      },
+      xWeeks: {
+        one: '1 week',
+        other: '{{count}} weeks'
+      },
+      aboutXMonths: {
+        one: 'about 1 month',
+        other: 'about {{count}} months'
+      },
+      xMonths: {
+        one: '1 month',
+        other: '{{count}} months'
+      },
+      aboutXYears: {
+        one: 'about 1 year',
+        other: 'about {{count}} years'
+      },
+      xYears: {
+        one: '1 year',
+        other: '{{count}} years'
+      },
+      overXYears: {
+        one: 'over 1 year',
+        other: 'over {{count}} years'
+      },
+      almostXYears: {
+        one: 'almost 1 year',
+        other: 'almost {{count}} years'
+      }
+    };
+    var formatDistance = function (token, count, options) {
+      var result;
+      var tokenValue = formatDistanceLocale[token];
+      if (typeof tokenValue === 'string') {
+        result = tokenValue;
+      } else if (count === 1) {
+        result = tokenValue.one;
+      } else {
+        result = tokenValue.other.replace('{{count}}', count.toString());
+      }
+      if (options !== null && options !== void 0 && options.addSuffix) {
+        if (options.comparison && options.comparison > 0) {
+          return 'in ' + result;
+        } else {
+          return result + ' ago';
+        }
+      }
+      return result;
+    };
+
+    var dateFormats = {
+      full: 'EEEE, MMMM do, y',
+      long: 'MMMM do, y',
+      medium: 'MMM d, y',
+      short: 'MM/dd/yyyy'
+    };
+    var timeFormats = {
+      full: 'h:mm:ss a zzzz',
+      long: 'h:mm:ss a z',
+      medium: 'h:mm:ss a',
+      short: 'h:mm a'
+    };
+    var dateTimeFormats = {
+      full: "{{date}} 'at' {{time}}",
+      long: "{{date}} 'at' {{time}}",
+      medium: '{{date}}, {{time}}',
+      short: '{{date}}, {{time}}'
+    };
+    var formatLong = {
+      date: buildFormatLongFn({
+        formats: dateFormats,
+        defaultWidth: 'full'
+      }),
+      time: buildFormatLongFn({
+        formats: timeFormats,
+        defaultWidth: 'full'
+      }),
+      dateTime: buildFormatLongFn({
+        formats: dateTimeFormats,
+        defaultWidth: 'full'
+      })
+    };
+
+    var formatRelativeLocale = {
+      lastWeek: "'last' eeee 'at' p",
+      yesterday: "'yesterday at' p",
+      today: "'today at' p",
+      tomorrow: "'tomorrow at' p",
+      nextWeek: "eeee 'at' p",
+      other: 'P'
+    };
+    var formatRelative = function (token, _date, _baseDate, _options) {
+      return formatRelativeLocale[token];
+    };
+
+    var eraValues = {
+      narrow: ['B', 'A'],
+      abbreviated: ['BC', 'AD'],
+      wide: ['Before Christ', 'Anno Domini']
+    };
+    var quarterValues = {
+      narrow: ['1', '2', '3', '4'],
+      abbreviated: ['Q1', 'Q2', 'Q3', 'Q4'],
+      wide: ['1st quarter', '2nd quarter', '3rd quarter', '4th quarter']
+    }; // Note: in English, the names of days of the week and months are capitalized.
+    // If you are making a new locale based on this one, check if the same is true for the language you're working on.
+    // Generally, formatted dates should look like they are in the middle of a sentence,
+    // e.g. in Spanish language the weekdays and months should be in the lowercase.
+
+    var monthValues = {
+      narrow: ['J', 'F', 'M', 'A', 'M', 'J', 'J', 'A', 'S', 'O', 'N', 'D'],
+      abbreviated: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
+      wide: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
+    };
+    var dayValues = {
+      narrow: ['S', 'M', 'T', 'W', 'T', 'F', 'S'],
+      short: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'],
+      abbreviated: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
+      wide: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
+    };
+    var dayPeriodValues = {
+      narrow: {
+        am: 'a',
+        pm: 'p',
+        midnight: 'mi',
+        noon: 'n',
+        morning: 'morning',
+        afternoon: 'afternoon',
+        evening: 'evening',
+        night: 'night'
+      },
+      abbreviated: {
+        am: 'AM',
+        pm: 'PM',
+        midnight: 'midnight',
+        noon: 'noon',
+        morning: 'morning',
+        afternoon: 'afternoon',
+        evening: 'evening',
+        night: 'night'
+      },
+      wide: {
+        am: 'a.m.',
+        pm: 'p.m.',
+        midnight: 'midnight',
+        noon: 'noon',
+        morning: 'morning',
+        afternoon: 'afternoon',
+        evening: 'evening',
+        night: 'night'
+      }
+    };
+    var formattingDayPeriodValues = {
+      narrow: {
+        am: 'a',
+        pm: 'p',
+        midnight: 'mi',
+        noon: 'n',
+        morning: 'in the morning',
+        afternoon: 'in the afternoon',
+        evening: 'in the evening',
+        night: 'at night'
+      },
+      abbreviated: {
+        am: 'AM',
+        pm: 'PM',
+        midnight: 'midnight',
+        noon: 'noon',
+        morning: 'in the morning',
+        afternoon: 'in the afternoon',
+        evening: 'in the evening',
+        night: 'at night'
+      },
+      wide: {
+        am: 'a.m.',
+        pm: 'p.m.',
+        midnight: 'midnight',
+        noon: 'noon',
+        morning: 'in the morning',
+        afternoon: 'in the afternoon',
+        evening: 'in the evening',
+        night: 'at night'
+      }
+    };
+    var ordinalNumber = function (dirtyNumber, _options) {
+      var number = Number(dirtyNumber); // If ordinal numbers depend on context, for example,
+      // if they are different for different grammatical genders,
+      // use `options.unit`.
+      //
+      // `unit` can be 'year', 'quarter', 'month', 'week', 'date', 'dayOfYear',
+      // 'day', 'hour', 'minute', 'second'.
+
+      var rem100 = number % 100;
+      if (rem100 > 20 || rem100 < 10) {
+        switch (rem100 % 10) {
+          case 1:
+            return number + 'st';
+          case 2:
+            return number + 'nd';
+          case 3:
+            return number + 'rd';
+        }
+      }
+      return number + 'th';
+    };
+    var localize = {
+      ordinalNumber: ordinalNumber,
+      era: buildLocalizeFn({
+        values: eraValues,
+        defaultWidth: 'wide'
+      }),
+      quarter: buildLocalizeFn({
+        values: quarterValues,
+        defaultWidth: 'wide',
+        argumentCallback: function (quarter) {
+          return quarter - 1;
+        }
+      }),
+      month: buildLocalizeFn({
+        values: monthValues,
+        defaultWidth: 'wide'
+      }),
+      day: buildLocalizeFn({
+        values: dayValues,
+        defaultWidth: 'wide'
+      }),
+      dayPeriod: buildLocalizeFn({
+        values: dayPeriodValues,
+        defaultWidth: 'wide',
+        formattingValues: formattingDayPeriodValues,
+        defaultFormattingWidth: 'wide'
+      })
+    };
+
+    var matchOrdinalNumberPattern = /^(\d+)(th|st|nd|rd)?/i;
+    var parseOrdinalNumberPattern = /\d+/i;
+    var matchEraPatterns = {
+      narrow: /^(b|a)/i,
+      abbreviated: /^(b\.?\s?c\.?|b\.?\s?c\.?\s?e\.?|a\.?\s?d\.?|c\.?\s?e\.?)/i,
+      wide: /^(before christ|before common era|anno domini|common era)/i
+    };
+    var parseEraPatterns = {
+      any: [/^b/i, /^(a|c)/i]
+    };
+    var matchQuarterPatterns = {
+      narrow: /^[1234]/i,
+      abbreviated: /^q[1234]/i,
+      wide: /^[1234](th|st|nd|rd)? quarter/i
+    };
+    var parseQuarterPatterns = {
+      any: [/1/i, /2/i, /3/i, /4/i]
+    };
+    var matchMonthPatterns = {
+      narrow: /^[jfmasond]/i,
+      abbreviated: /^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i,
+      wide: /^(january|february|march|april|may|june|july|august|september|october|november|december)/i
+    };
+    var parseMonthPatterns = {
+      narrow: [/^j/i, /^f/i, /^m/i, /^a/i, /^m/i, /^j/i, /^j/i, /^a/i, /^s/i, /^o/i, /^n/i, /^d/i],
+      any: [/^ja/i, /^f/i, /^mar/i, /^ap/i, /^may/i, /^jun/i, /^jul/i, /^au/i, /^s/i, /^o/i, /^n/i, /^d/i]
+    };
+    var matchDayPatterns = {
+      narrow: /^[smtwf]/i,
+      short: /^(su|mo|tu|we|th|fr|sa)/i,
+      abbreviated: /^(sun|mon|tue|wed|thu|fri|sat)/i,
+      wide: /^(sunday|monday|tuesday|wednesday|thursday|friday|saturday)/i
+    };
+    var parseDayPatterns = {
+      narrow: [/^s/i, /^m/i, /^t/i, /^w/i, /^t/i, /^f/i, /^s/i],
+      any: [/^su/i, /^m/i, /^tu/i, /^w/i, /^th/i, /^f/i, /^sa/i]
+    };
+    var matchDayPeriodPatterns = {
+      narrow: /^(a|p|mi|n|(in the|at) (morning|afternoon|evening|night))/i,
+      any: /^([ap]\.?\s?m\.?|midnight|noon|(in the|at) (morning|afternoon|evening|night))/i
+    };
+    var parseDayPeriodPatterns = {
+      any: {
+        am: /^a/i,
+        pm: /^p/i,
+        midnight: /^mi/i,
+        noon: /^no/i,
+        morning: /morning/i,
+        afternoon: /afternoon/i,
+        evening: /evening/i,
+        night: /night/i
+      }
+    };
+    var match = {
+      ordinalNumber: buildMatchPatternFn({
+        matchPattern: matchOrdinalNumberPattern,
+        parsePattern: parseOrdinalNumberPattern,
+        valueCallback: function (value) {
+          return parseInt(value, 10);
+        }
+      }),
+      era: buildMatchFn({
+        matchPatterns: matchEraPatterns,
+        defaultMatchWidth: 'wide',
+        parsePatterns: parseEraPatterns,
+        defaultParseWidth: 'any'
+      }),
+      quarter: buildMatchFn({
+        matchPatterns: matchQuarterPatterns,
+        defaultMatchWidth: 'wide',
+        parsePatterns: parseQuarterPatterns,
+        defaultParseWidth: 'any',
+        valueCallback: function (index) {
+          return index + 1;
+        }
+      }),
+      month: buildMatchFn({
+        matchPatterns: matchMonthPatterns,
+        defaultMatchWidth: 'wide',
+        parsePatterns: parseMonthPatterns,
+        defaultParseWidth: 'any'
+      }),
+      day: buildMatchFn({
+        matchPatterns: matchDayPatterns,
+        defaultMatchWidth: 'wide',
+        parsePatterns: parseDayPatterns,
+        defaultParseWidth: 'any'
+      }),
+      dayPeriod: buildMatchFn({
+        matchPatterns: matchDayPeriodPatterns,
+        defaultMatchWidth: 'any',
+        parsePatterns: parseDayPeriodPatterns,
+        defaultParseWidth: 'any'
+      })
+    };
+
+    /**
+     * @type {Locale}
+     * @category Locales
+     * @summary English locale (United States).
+     * @language English
+     * @iso-639-2 eng
+     * @author Sasha Koss [@kossnocorp]{@link https://github.com/kossnocorp}
+     * @author Lesha Koss [@leshakoss]{@link https://github.com/leshakoss}
+     */
+    var locale = {
+      code: 'en-US',
+      formatDistance: formatDistance,
+      formatLong: formatLong,
+      formatRelative: formatRelative,
+      localize: localize,
+      match: match,
+      options: {
+        weekStartsOn: 0
+        /* Sunday */,
+
+        firstWeekContainsDate: 1
+      }
+    };
+
     /**
      * @name subMilliseconds
      * @category Millisecond Helpers
@@ -36961,25 +37611,25 @@
       requiredArgs$1(2, arguments);
       var formatStr = String(dirtyFormatStr);
       var options = dirtyOptions || {};
-      var locale = options.locale || locale$1;
-      var localeFirstWeekContainsDate = locale.options && locale.options.firstWeekContainsDate;
+      var locale$1 = options.locale || locale;
+      var localeFirstWeekContainsDate = locale$1.options && locale$1.options.firstWeekContainsDate;
       var defaultFirstWeekContainsDate = localeFirstWeekContainsDate == null ? 1 : toInteger$3(localeFirstWeekContainsDate);
       var firstWeekContainsDate = options.firstWeekContainsDate == null ? defaultFirstWeekContainsDate : toInteger$3(options.firstWeekContainsDate); // Test if weekStartsOn is between 1 and 7 _and_ is not NaN
 
       if (!(firstWeekContainsDate >= 1 && firstWeekContainsDate <= 7)) {
         throw new RangeError('firstWeekContainsDate must be between 1 and 7 inclusively');
       }
-      var localeWeekStartsOn = locale.options && locale.options.weekStartsOn;
+      var localeWeekStartsOn = locale$1.options && locale$1.options.weekStartsOn;
       var defaultWeekStartsOn = localeWeekStartsOn == null ? 0 : toInteger$3(localeWeekStartsOn);
       var weekStartsOn = options.weekStartsOn == null ? defaultWeekStartsOn : toInteger$3(options.weekStartsOn); // Test if weekStartsOn is between 0 and 6 _and_ is not NaN
 
       if (!(weekStartsOn >= 0 && weekStartsOn <= 6)) {
         throw new RangeError('weekStartsOn must be between 0 and 6 inclusively');
       }
-      if (!locale.localize) {
+      if (!locale$1.localize) {
         throw new RangeError('locale must contain localize property');
       }
-      if (!locale.formatLong) {
+      if (!locale$1.formatLong) {
         throw new RangeError('locale must contain formatLong property');
       }
       var originalDate = toDate$2(dirtyDate);
@@ -36994,14 +37644,14 @@
       var formatterOptions = {
         firstWeekContainsDate: firstWeekContainsDate,
         weekStartsOn: weekStartsOn,
-        locale: locale,
+        locale: locale$1,
         _originalDate: originalDate
       };
       var result = formatStr.match(longFormattingTokensRegExp$1).map(function (substring) {
         var firstCharacter = substring[0];
         if (firstCharacter === 'p' || firstCharacter === 'P') {
           var longFormatter = longFormatters$1[firstCharacter];
-          return longFormatter(substring, locale.formatLong, formatterOptions);
+          return longFormatter(substring, locale$1.formatLong, formatterOptions);
         }
         return substring;
       }).join('').match(formattingTokensRegExp$1).map(function (substring) {
@@ -37021,7 +37671,7 @@
           if (!options.useAdditionalDayOfYearTokens && isProtectedDayOfYearToken$1(substring)) {
             throwProtectedError$1(substring, dirtyFormatStr, dirtyDate);
           }
-          return formatter(utcDate, substring, locale.localize, formatterOptions);
+          return formatter(utcDate, substring, locale$1.localize, formatterOptions);
         }
         if (firstCharacter.match(unescapedLatinCharacterRegExp$1)) {
           throw new RangeError('Format string contains an unescaped latin alphabet character `' + firstCharacter + '`');
@@ -37209,8 +37859,8 @@
     function formatDistanceStrict(dirtyDate, dirtyBaseDate) {
       var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
       requiredArgs$1(2, arguments);
-      var locale = options.locale || locale$1;
-      if (!locale.formatDistance) {
+      var locale$1 = options.locale || locale;
+      if (!locale$1.formatDistance) {
         throw new RangeError('locale must contain localize.formatDistance property');
       }
       var comparison = compareAsc(dirtyDate, dirtyBaseDate);
@@ -37267,22 +37917,22 @@
 
       if (unit === 'second') {
         var seconds = roundingMethodFn(milliseconds / 1000);
-        return locale.formatDistance('xSeconds', seconds, localizeOptions); // 1 up to 60 mins
+        return locale$1.formatDistance('xSeconds', seconds, localizeOptions); // 1 up to 60 mins
       } else if (unit === 'minute') {
         var roundedMinutes = roundingMethodFn(minutes);
-        return locale.formatDistance('xMinutes', roundedMinutes, localizeOptions); // 1 up to 24 hours
+        return locale$1.formatDistance('xMinutes', roundedMinutes, localizeOptions); // 1 up to 24 hours
       } else if (unit === 'hour') {
         var hours = roundingMethodFn(minutes / 60);
-        return locale.formatDistance('xHours', hours, localizeOptions); // 1 up to 30 days
+        return locale$1.formatDistance('xHours', hours, localizeOptions); // 1 up to 30 days
       } else if (unit === 'day') {
         var days = roundingMethodFn(dstNormalizedMinutes / MINUTES_IN_DAY);
-        return locale.formatDistance('xDays', days, localizeOptions); // 1 up to 12 months
+        return locale$1.formatDistance('xDays', days, localizeOptions); // 1 up to 12 months
       } else if (unit === 'month') {
         var months = roundingMethodFn(dstNormalizedMinutes / MINUTES_IN_MONTH);
-        return months === 12 && options.unit !== 'month' ? locale.formatDistance('xYears', 1, localizeOptions) : locale.formatDistance('xMonths', months, localizeOptions); // 1 year up to max Date
+        return months === 12 && options.unit !== 'month' ? locale$1.formatDistance('xYears', 1, localizeOptions) : locale$1.formatDistance('xMonths', months, localizeOptions); // 1 year up to max Date
       } else if (unit === 'year') {
         var years = roundingMethodFn(dstNormalizedMinutes / MINUTES_IN_YEAR);
-        return locale.formatDistance('xYears', years, localizeOptions);
+        return locale$1.formatDistance('xYears', years, localizeOptions);
       }
       throw new RangeError("unit must be 'second', 'minute', 'hour', 'day', 'month' or 'year'");
     }
@@ -39392,18 +40042,18 @@
       var dateString = String(dirtyDateString);
       var formatString = String(dirtyFormatString);
       var options = dirtyOptions || {};
-      var locale = options.locale || locale$1;
-      if (!locale.match) {
+      var locale$1 = options.locale || locale;
+      if (!locale$1.match) {
         throw new RangeError('locale must contain match property');
       }
-      var localeFirstWeekContainsDate = locale.options && locale.options.firstWeekContainsDate;
+      var localeFirstWeekContainsDate = locale$1.options && locale$1.options.firstWeekContainsDate;
       var defaultFirstWeekContainsDate = localeFirstWeekContainsDate == null ? 1 : toInteger$3(localeFirstWeekContainsDate);
       var firstWeekContainsDate = options.firstWeekContainsDate == null ? defaultFirstWeekContainsDate : toInteger$3(options.firstWeekContainsDate); // Test if weekStartsOn is between 1 and 7 _and_ is not NaN
 
       if (!(firstWeekContainsDate >= 1 && firstWeekContainsDate <= 7)) {
         throw new RangeError('firstWeekContainsDate must be between 1 and 7 inclusively');
       }
-      var localeWeekStartsOn = locale.options && locale.options.weekStartsOn;
+      var localeWeekStartsOn = locale$1.options && locale$1.options.weekStartsOn;
       var defaultWeekStartsOn = localeWeekStartsOn == null ? 0 : toInteger$3(localeWeekStartsOn);
       var weekStartsOn = options.weekStartsOn == null ? defaultWeekStartsOn : toInteger$3(options.weekStartsOn); // Test if weekStartsOn is between 0 and 6 _and_ is not NaN
 
@@ -39420,7 +40070,7 @@
       var subFnOptions = {
         firstWeekContainsDate: firstWeekContainsDate,
         weekStartsOn: weekStartsOn,
-        locale: locale
+        locale: locale$1
       }; // If timezone isn't specified, it will be set to the system timezone
 
       var setters = [{
@@ -39434,7 +40084,7 @@
         var firstCharacter = substring[0];
         if (firstCharacter === 'p' || firstCharacter === 'P') {
           var longFormatter = longFormatters$1[firstCharacter];
-          return longFormatter(substring, locale.formatLong, subFnOptions);
+          return longFormatter(substring, locale$1.formatLong, subFnOptions);
         }
         return substring;
       }).join('').match(formattingTokensRegExp);
@@ -39470,7 +40120,7 @@
             token: firstCharacter,
             fullToken: token
           });
-          var parseResult = parser.parse(dateString, token, locale.match, subFnOptions);
+          var parseResult = parser.parse(dateString, token, locale$1.match, subFnOptions);
           if (!parseResult) {
             return new Date(NaN);
           }
@@ -62339,6 +62989,7 @@
         default: "desktop-first"
       },
       preflightStyleDisabled: Boolean,
+      styleMountTarget: Object,
       inlineThemeDisabled: {
         type: Boolean,
         default: void 0
@@ -62540,6 +63191,7 @@
         });
         const inlineThemeDisabled = props.inlineThemeDisabled || UConfigProvider?.inlineThemeDisabled;
         const preflightStyleDisabled = props.preflightStyleDisabled || UConfigProvider?.preflightStyleDisabled;
+        const styleMountTarget = props.styleMountTarget || UConfigProvider?.styleMountTarget;
         const mergedThemeHashRef = vue.computed(() => {
           const {
             value: theme
@@ -62604,7 +63256,8 @@
           mergedThemeRef,
           mergedThemeOverridesRef,
           inlineThemeDisabled: inlineThemeDisabled || false,
-          preflightStyleDisabled: preflightStyleDisabled || false
+          preflightStyleDisabled: preflightStyleDisabled || false,
+          styleMountTarget
         });
         return {
           mergedClsPrefix: mergedClsPrefixRef,
@@ -64318,6 +64971,7 @@
         default: "current"
       },
       scrollbarProps: Object,
+      localStorageKey: String,
       renderCell: Function,
       defaultEmptyValue: [String, Function],
       renderExpandIcon: Function,
@@ -65140,17 +65794,26 @@
     }
     function createCustomWidthStyle(column, resizedWidth) {
       if (resizedWidth !== void 0) {
+        const numWidth = depx(resizedWidth);
+        const minMaxColumn = column && "minWidth" in column && "maxWidth" in column ? column : null;
+        const clampedNum = minMaxColumn ? clampValueFollowCSSRules(numWidth, minMaxColumn.minWidth, minMaxColumn.maxWidth) : numWidth;
+        const clamped = formatLength(clampedNum);
         return {
-          width: resizedWidth,
-          minWidth: resizedWidth,
-          maxWidth: resizedWidth
+          width: clamped,
+          minWidth: clamped,
+          maxWidth: clamped
         };
       }
-      const width = getStringColWidth(column);
-      const {
-        minWidth,
-        maxWidth
-      } = column;
+      const explicitNum = getNumberColWidth(column) ?? void 0;
+      const minWidth = column && "minWidth" in column ? column.minWidth : void 0;
+      const maxWidth = column && "maxWidth" in column ? column.maxWidth : void 0;
+      let widthNum = explicitNum;
+      if (widthNum === void 0 && (minWidth !== void 0 || maxWidth !== void 0)) {
+        widthNum = clampValueFollowCSSRules(maxWidth !== void 0 ? typeof maxWidth === "number" ? maxWidth : parseFloat(maxWidth) : minWidth !== void 0 ? typeof minWidth === "number" ? minWidth : parseFloat(minWidth) : 0, minWidth, maxWidth);
+      } else if (widthNum !== void 0 && (minWidth !== void 0 || maxWidth !== void 0)) {
+        widthNum = clampValueFollowCSSRules(widthNum, minWidth, maxWidth);
+      }
+      const width = widthNum !== void 0 ? formatLength(widthNum) : getStringColWidth(column);
       return {
         width,
         minWidth: formatLength(minWidth) || width,
@@ -65702,6 +66365,7 @@
           headerCheckboxDisabledRef,
           sizeRef,
           onUnstableColumnResize,
+          getResizableWidth,
           doUpdateResizableWidth,
           handleTableHeaderScroll,
           deriveNextSorter,
@@ -65733,13 +66397,22 @@
           deriveNextSorter(nextSorter);
         }
         const resizeStartWidthMap = /* @__PURE__ */ new Map();
+        function getColumnStartWidth(column) {
+          const actual = getCellActualWidth(column.key);
+          if (actual !== void 0 && actual > 0) return actual;
+          const resized = getResizableWidth(column.key);
+          if (resized !== void 0 && resized > 0) return resized;
+          return getNumberColWidth(column);
+        }
         function handleColumnResizeStart(column) {
-          resizeStartWidthMap.set(column.key, getCellActualWidth(column.key));
+          resizeStartWidthMap.set(column.key, getColumnStartWidth(column));
         }
         function handleColumnResize(column, displacementX) {
-          const startWidth = resizeStartWidthMap.get(column.key);
+          let startWidth = resizeStartWidthMap.get(column.key);
           if (startWidth === void 0) {
-            return;
+            startWidth = getColumnStartWidth(column);
+            if (startWidth === void 0) return;
+            resizeStartWidthMap.set(column.key, startWidth);
           }
           const widthAfterResize = startWidth + displacementX;
           const limitWidth = clampValueFollowCSSRules(
@@ -84370,6 +85043,7 @@
           emptyPropsRef
           // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         } = vue.inject(dataTableInjectionKey);
+        const UConfigProvider = vue.inject(configProviderInjectionKey, null);
         const scrollbarInstRef = vue.ref(null);
         const virtualListRef = vue.ref(null);
         const emptyElRef = vue.ref(null);
@@ -84557,13 +85231,15 @@
             id: `u-${componentId}`,
             force: true,
             props: cProps,
-            anchorMetaName: cssrAnchorMetaName
+            anchorMetaName: cssrAnchorMetaName,
+            parent: UConfigProvider?.styleMountTarget
           });
           fixedStyleMounted = true;
         });
         vue.onUnmounted(() => {
           style.unmount({
-            id: `u-${componentId}`
+            id: `u-${componentId}`,
+            parent: UConfigProvider?.styleMountTarget
           });
         });
         return {
@@ -85538,7 +86214,8 @@
         sort,
         sortedDataRef,
         mergedSortStateRef,
-        deriveNextSorter
+        deriveNextSorter,
+        doUpdateSorter
       };
     }
 
@@ -85667,7 +86344,8 @@
         deriveNextSorter,
         mergedSortStateRef,
         sort,
-        clearSorter
+        clearSorter,
+        doUpdateSorter
       } = useSorter(props, {
         dataRelatedColsRef,
         filteredDataRef
@@ -85849,6 +86527,9 @@
           warn$2("data-table", "`filters` is not an object");
         }
       }
+      function restoreSortState(sortState) {
+        doUpdateSorter(sortState);
+      }
       return {
         treeMateRef,
         mergedCurrentPageRef: boundedMergedCurrentPageRef,
@@ -85865,6 +86546,7 @@
         doUpdatePageSize,
         doUpdatePage,
         onUnstableColumnResize,
+        restoreSortState,
         // exported methods
         filter,
         filters,
@@ -86110,7 +86792,8 @@
       return {
         getResizableWidth,
         doUpdateResizableWidth,
-        clearResizableWidth
+        clearResizableWidth,
+        resizableWidthsRef
       };
     }
 
@@ -86267,6 +86950,42 @@
       };
     }
 
+    const STORAGE_KEY_PREFIX = "u-data-table:";
+    function getStorageKey(key) {
+      return `${STORAGE_KEY_PREFIX}${key}`;
+    }
+    function loadTableState(localStorageKey) {
+      try {
+        const raw = localStorage.getItem(getStorageKey(localStorageKey));
+        if (!raw) return null;
+        return JSON.parse(raw);
+      } catch {
+        return null;
+      }
+    }
+    function saveTableState(localStorageKey, state) {
+      try {
+        localStorage.setItem(getStorageKey(localStorageKey), JSON.stringify(state));
+      } catch {
+        console.warn(`Could not set localStorage value for ${localStorageKey}`);
+      }
+    }
+    function restoreSortStateFromStored(stored, dataRelatedCols) {
+      if (!stored?.length) return null;
+      const result = [];
+      for (const item of stored) {
+        const column = dataRelatedCols.find(col => col.type !== "selection" && col.type !== "expand" && "key" in col && col.key === item.columnKey && col.sorter !== void 0);
+        if (column?.sorter) {
+          result.push({
+            columnKey: item.columnKey,
+            order: item.order,
+            sorter: column.sorter
+          });
+        }
+      }
+      return result.length ? result : null;
+    }
+
     const fixedColumnStyle = createFixedColumnStyle();
     var style$P = c$1([cB("data-table", `
     width: 100%;
@@ -86736,7 +87455,12 @@
         );
         const bodyWidthRef = vue.ref(null);
         const mainTableInstRef = vue.ref(null);
-        const { getResizableWidth, clearResizableWidth, doUpdateResizableWidth } = useResizable();
+        const {
+          getResizableWidth,
+          clearResizableWidth,
+          doUpdateResizableWidth,
+          resizableWidthsRef
+        } = useResizable();
         const { rowsRef, colsRef, dataRelatedColsRef, hasEllipsisRef } = useGroupHeader(props, getResizableWidth);
         const {
           treeMateRef,
@@ -86750,9 +87474,11 @@
           mergedSortStateRef,
           childTriggerColIndexRef,
           doUpdatePage,
+          doUpdatePageSize,
           doUpdateFilters,
           onUnstableColumnResize,
           deriveNextSorter,
+          restoreSortState,
           filter,
           filters,
           clearFilter,
@@ -86766,6 +87492,8 @@
           doUncheckAll,
           doCheck,
           doUncheck,
+          doUpdateCheckedRowKeys,
+          mergedCheckedRowKeysRef,
           headerCheckboxDisabledRef,
           someRowsCheckedRef,
           allRowsCheckedRef,
@@ -86801,6 +87529,68 @@
           mainTableInstRef,
           mergedCurrentPageRef
         });
+        vue.onMounted(() => {
+          const key = props.localStorageKey;
+          if (!key) return;
+          const stored = loadTableState(key);
+          if (!stored) return;
+          if (stored.columnWidths && Object.keys(stored.columnWidths).length > 0) {
+            resizableWidthsRef.value = {
+              ...resizableWidthsRef.value,
+              ...stored.columnWidths
+            };
+          }
+          if (props.pagination && stored.page != null) {
+            doUpdatePage(stored.page);
+          }
+          if (props.pagination && stored.pageSize != null) {
+            doUpdatePageSize(stored.pageSize);
+          }
+          if (stored.filters) {
+            filter(stored.filters);
+          }
+          const sortToRestore = restoreSortStateFromStored(
+            stored.sortState,
+            dataRelatedColsRef.value
+          );
+          if (sortToRestore?.length) {
+            restoreSortState(sortToRestore);
+          }
+          if (stored.checkedRowKeys?.length) {
+            doUpdateCheckedRowKeys(stored.checkedRowKeys, void 0, "check");
+          }
+          if (stored.expandedRowKeys?.length) {
+            doUpdateExpandedRowKeys(stored.expandedRowKeys);
+          }
+        });
+        vue.watch(
+          () => props.localStorageKey ? {
+            key: props.localStorageKey,
+            columnWidths: resizableWidthsRef.value,
+            page: mergedPaginationRef.value?.page,
+            pageSize: mergedPaginationRef.value?.pageSize,
+            filters: mergedFilterStateRef.value,
+            sortState: mergedSortStateRef.value.map((s) => ({
+              columnKey: s.columnKey,
+              order: s.order
+            })),
+            checkedRowKeys: mergedCheckedRowKeysRef.value,
+            expandedRowKeys: mergedExpandedRowKeysRef.value
+          } : null,
+          (state) => {
+            if (!state?.key) return;
+            saveTableState(state.key, {
+              columnWidths: state.columnWidths,
+              page: state.page,
+              pageSize: state.pageSize,
+              filters: state.filters,
+              sortState: state.sortState.length ? state.sortState : void 0,
+              checkedRowKeys: state.checkedRowKeys?.length ? state.checkedRowKeys : void 0,
+              expandedRowKeys: state.expandedRowKeys?.length ? state.expandedRowKeys : void 0
+            });
+          },
+          { deep: true }
+        );
         const { localeRef } = useLocale("DataTable");
         const mergedTableLayoutRef = vue.computed(() => {
           if (props.virtualScroll || props.flexHeight || props.maxHeight !== void 0 || hasEllipsisRef.value) {
@@ -87474,855 +88264,175 @@
     	    default: obj
     	  };
     	}
-    	function cloneObject(dirtyObject) {
-    	  return (0, _index.default)({}, dirtyObject);
-    	}
-    	module.exports = exports.default; 
-    } (cloneObject$1, cloneObject$1.exports));
-
-    var cloneObjectExports = cloneObject$1.exports;
-    var cloneObject = /*@__PURE__*/getDefaultExportFromCjs(cloneObjectExports);
-
-    var format$3 = {exports: {}};
-
-    var isValid = {exports: {}};
-
-    var isDate = {exports: {}};
-
-    var requiredArgs = {exports: {}};
-
-    (function (module, exports) {
-
-    	Object.defineProperty(exports, "__esModule", {
-    	  value: true
-    	});
-    	exports.default = requiredArgs;
-    	function requiredArgs(required, args) {
-    	  if (args.length < required) {
-    	    throw new TypeError(required + ' argument' + (required > 1 ? 's' : '') + ' required, but only ' + args.length + ' present');
-    	  }
-    	}
-    	module.exports = exports.default; 
-    } (requiredArgs, requiredArgs.exports));
-
-    var requiredArgsExports = requiredArgs.exports;
-
-    (function (module, exports) {
-
-    	Object.defineProperty(exports, "__esModule", {
-    	  value: true
-    	});
-    	exports.default = isDate;
-    	var _index = _interopRequireDefault(requiredArgsExports);
-    	function _interopRequireDefault(obj) {
-    	  return obj && obj.__esModule ? obj : {
-    	    default: obj
-    	  };
-    	}
-
-    	/**
-    	 * @name isDate
-    	 * @category Common Helpers
-    	 * @summary Is the given value a date?
-    	 *
-    	 * @description
-    	 * Returns true if the given value is an instance of Date. The function works for dates transferred across iframes.
-    	 *
-    	 * ### v2.0.0 breaking changes:
-    	 *
-    	 * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).
-    	 *
-    	 * @param {*} value - the value to check
-    	 * @returns {boolean} true if the given value is a date
-    	 * @throws {TypeError} 1 arguments required
-    	 *
-    	 * @example
-    	 * // For a valid date:
-    	 * const result = isDate(new Date())
-    	 * //=> true
-    	 *
-    	 * @example
-    	 * // For an invalid date:
-    	 * const result = isDate(new Date(NaN))
-    	 * //=> true
-    	 *
-    	 * @example
-    	 * // For some value:
-    	 * const result = isDate('2014-02-31')
-    	 * //=> false
-    	 *
-    	 * @example
-    	 * // For an object:
-    	 * const result = isDate({})
-    	 * //=> false
-    	 */
-    	function isDate(value) {
-    	  (0, _index.default)(1, arguments);
-    	  return value instanceof Date || typeof value === 'object' && Object.prototype.toString.call(value) === '[object Date]';
-    	}
-    	module.exports = exports.default; 
-    } (isDate, isDate.exports));
-
-    var isDateExports = isDate.exports;
-
-    var toDate$1 = {exports: {}};
-
-    (function (module, exports) {
-
-    	Object.defineProperty(exports, "__esModule", {
-    	  value: true
-    	});
-    	exports.default = toDate;
-    	var _index = _interopRequireDefault(requiredArgsExports);
-    	function _interopRequireDefault(obj) {
-    	  return obj && obj.__esModule ? obj : {
-    	    default: obj
-    	  };
-    	}
-
-    	/**
-    	 * @name toDate
-    	 * @category Common Helpers
-    	 * @summary Convert the given argument to an instance of Date.
-    	 *
-    	 * @description
-    	 * Convert the given argument to an instance of Date.
-    	 *
-    	 * If the argument is an instance of Date, the function returns its clone.
-    	 *
-    	 * If the argument is a number, it is treated as a timestamp.
-    	 *
-    	 * If the argument is none of the above, the function returns Invalid Date.
-    	 *
-    	 * **Note**: *all* Date arguments passed to any *date-fns* function is processed by `toDate`.
-    	 *
-    	 * @param {Date|Number} argument - the value to convert
-    	 * @returns {Date} the parsed date in the local time zone
-    	 * @throws {TypeError} 1 argument required
-    	 *
-    	 * @example
-    	 * // Clone the date:
-    	 * const result = toDate(new Date(2014, 1, 11, 11, 30, 30))
-    	 * //=> Tue Feb 11 2014 11:30:30
-    	 *
-    	 * @example
-    	 * // Convert the timestamp to date:
-    	 * const result = toDate(1392098430000)
-    	 * //=> Tue Feb 11 2014 11:30:30
-    	 */
-    	function toDate(argument) {
-    	  (0, _index.default)(1, arguments);
-    	  var argStr = Object.prototype.toString.call(argument); // Clone the date
-
-    	  if (argument instanceof Date || typeof argument === 'object' && argStr === '[object Date]') {
-    	    // Prevent the date to lose the milliseconds when passed to new Date() in IE10
-    	    return new Date(argument.getTime());
-    	  } else if (typeof argument === 'number' || argStr === '[object Number]') {
-    	    return new Date(argument);
-    	  } else {
-    	    if ((typeof argument === 'string' || argStr === '[object String]') && typeof console !== 'undefined') {
-    	      // eslint-disable-next-line no-console
-    	      console.warn("Starting with v2.0.0-beta.1 date-fns doesn't accept strings as date arguments. Please use `parseISO` to parse strings. See: https://git.io/fjule"); // eslint-disable-next-line no-console
-
-    	      console.warn(new Error().stack);
-    	    }
-    	    return new Date(NaN);
-    	  }
-    	}
-    	module.exports = exports.default; 
-    } (toDate$1, toDate$1.exports));
-
-    var toDateExports = toDate$1.exports;
-
-    (function (module, exports) {
-
-    	Object.defineProperty(exports, "__esModule", {
-    	  value: true
-    	});
-    	exports.default = isValid;
-    	var _index = _interopRequireDefault(isDateExports);
-    	var _index2 = _interopRequireDefault(toDateExports);
-    	var _index3 = _interopRequireDefault(requiredArgsExports);
-    	function _interopRequireDefault(obj) {
-    	  return obj && obj.__esModule ? obj : {
-    	    default: obj
-    	  };
-    	}
-
-    	/**
-    	 * @name isValid
-    	 * @category Common Helpers
-    	 * @summary Is the given date valid?
-    	 *
-    	 * @description
-    	 * Returns false if argument is Invalid Date and true otherwise.
-    	 * Argument is converted to Date using `toDate`. See [toDate]{@link https://date-fns.org/docs/toDate}
-    	 * Invalid Date is a Date, whose time value is NaN.
-    	 *
-    	 * Time value of Date: http://es5.github.io/#x15.9.1.1
-    	 *
-    	 * ### v2.0.0 breaking changes:
-    	 *
-    	 * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).
-    	 *
-    	 * - Now `isValid` doesn't throw an exception
-    	 *   if the first argument is not an instance of Date.
-    	 *   Instead, argument is converted beforehand using `toDate`.
-    	 *
-    	 *   Examples:
-    	 *
-    	 *   | `isValid` argument        | Before v2.0.0 | v2.0.0 onward |
-    	 *   |---------------------------|---------------|---------------|
-    	 *   | `new Date()`              | `true`        | `true`        |
-    	 *   | `new Date('2016-01-01')`  | `true`        | `true`        |
-    	 *   | `new Date('')`            | `false`       | `false`       |
-    	 *   | `new Date(1488370835081)` | `true`        | `true`        |
-    	 *   | `new Date(NaN)`           | `false`       | `false`       |
-    	 *   | `'2016-01-01'`            | `TypeError`   | `false`       |
-    	 *   | `''`                      | `TypeError`   | `false`       |
-    	 *   | `1488370835081`           | `TypeError`   | `true`        |
-    	 *   | `NaN`                     | `TypeError`   | `false`       |
-    	 *
-    	 *   We introduce this change to make *date-fns* consistent with ECMAScript behavior
-    	 *   that try to coerce arguments to the expected type
-    	 *   (which is also the case with other *date-fns* functions).
-    	 *
-    	 * @param {*} date - the date to check
-    	 * @returns {Boolean} the date is valid
-    	 * @throws {TypeError} 1 argument required
-    	 *
-    	 * @example
-    	 * // For the valid date:
-    	 * const result = isValid(new Date(2014, 1, 31))
-    	 * //=> true
-    	 *
-    	 * @example
-    	 * // For the value, convertable into a date:
-    	 * const result = isValid(1393804800000)
-    	 * //=> true
-    	 *
-    	 * @example
-    	 * // For the invalid date:
-    	 * const result = isValid(new Date(''))
-    	 * //=> false
-    	 */
-    	function isValid(dirtyDate) {
-    	  (0, _index3.default)(1, arguments);
-    	  if (!(0, _index.default)(dirtyDate) && typeof dirtyDate !== 'number') {
-    	    return false;
-    	  }
-    	  var date = (0, _index2.default)(dirtyDate);
-    	  return !isNaN(Number(date));
-    	}
-    	module.exports = exports.default; 
-    } (isValid, isValid.exports));
-
-    var isValidExports = isValid.exports;
-
-    var enUS = {exports: {}};
-
-    var formatDistance = {exports: {}};
-
-    (function (module, exports) {
-
-    	Object.defineProperty(exports, "__esModule", {
-    	  value: true
-    	});
-    	exports.default = void 0;
-    	var formatDistanceLocale = {
-    	  lessThanXSeconds: {
-    	    one: 'less than a second',
-    	    other: 'less than {{count}} seconds'
-    	  },
-    	  xSeconds: {
-    	    one: '1 second',
-    	    other: '{{count}} seconds'
-    	  },
-    	  halfAMinute: 'half a minute',
-    	  lessThanXMinutes: {
-    	    one: 'less than a minute',
-    	    other: 'less than {{count}} minutes'
-    	  },
-    	  xMinutes: {
-    	    one: '1 minute',
-    	    other: '{{count}} minutes'
-    	  },
-    	  aboutXHours: {
-    	    one: 'about 1 hour',
-    	    other: 'about {{count}} hours'
-    	  },
-    	  xHours: {
-    	    one: '1 hour',
-    	    other: '{{count}} hours'
-    	  },
-    	  xDays: {
-    	    one: '1 day',
-    	    other: '{{count}} days'
-    	  },
-    	  aboutXWeeks: {
-    	    one: 'about 1 week',
-    	    other: 'about {{count}} weeks'
-    	  },
-    	  xWeeks: {
-    	    one: '1 week',
-    	    other: '{{count}} weeks'
-    	  },
-    	  aboutXMonths: {
-    	    one: 'about 1 month',
-    	    other: 'about {{count}} months'
-    	  },
-    	  xMonths: {
-    	    one: '1 month',
-    	    other: '{{count}} months'
-    	  },
-    	  aboutXYears: {
-    	    one: 'about 1 year',
-    	    other: 'about {{count}} years'
-    	  },
-    	  xYears: {
-    	    one: '1 year',
-    	    other: '{{count}} years'
-    	  },
-    	  overXYears: {
-    	    one: 'over 1 year',
-    	    other: 'over {{count}} years'
-    	  },
-    	  almostXYears: {
-    	    one: 'almost 1 year',
-    	    other: 'almost {{count}} years'
-    	  }
-    	};
-    	var formatDistance = function (token, count, options) {
-    	  var result;
-    	  var tokenValue = formatDistanceLocale[token];
-    	  if (typeof tokenValue === 'string') {
-    	    result = tokenValue;
-    	  } else if (count === 1) {
-    	    result = tokenValue.one;
-    	  } else {
-    	    result = tokenValue.other.replace('{{count}}', count.toString());
-    	  }
-    	  if (options !== null && options !== void 0 && options.addSuffix) {
-    	    if (options.comparison && options.comparison > 0) {
-    	      return 'in ' + result;
-    	    } else {
-    	      return result + ' ago';
-    	    }
-    	  }
-    	  return result;
-    	};
-    	var _default = formatDistance;
-    	exports.default = _default;
-    	module.exports = exports.default; 
-    } (formatDistance, formatDistance.exports));
-
-    var formatDistanceExports = formatDistance.exports;
-
-    var formatLong = {exports: {}};
-
-    var buildFormatLongFn = {exports: {}};
-
-    (function (module, exports) {
-
-    	Object.defineProperty(exports, "__esModule", {
-    	  value: true
-    	});
-    	exports.default = buildFormatLongFn;
-    	function buildFormatLongFn(args) {
-    	  return function () {
-    	    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    	    // TODO: Remove String()
-    	    var width = options.width ? String(options.width) : args.defaultWidth;
-    	    var format = args.formats[width] || args.formats[args.defaultWidth];
-    	    return format;
-    	  };
-    	}
-    	module.exports = exports.default; 
-    } (buildFormatLongFn, buildFormatLongFn.exports));
-
-    var buildFormatLongFnExports = buildFormatLongFn.exports;
-
-    (function (module, exports) {
-
-    	Object.defineProperty(exports, "__esModule", {
-    	  value: true
-    	});
-    	exports.default = void 0;
-    	var _index = _interopRequireDefault(buildFormatLongFnExports);
-    	function _interopRequireDefault(obj) {
-    	  return obj && obj.__esModule ? obj : {
-    	    default: obj
-    	  };
-    	}
-    	var dateFormats = {
-    	  full: 'EEEE, MMMM do, y',
-    	  long: 'MMMM do, y',
-    	  medium: 'MMM d, y',
-    	  short: 'MM/dd/yyyy'
-    	};
-    	var timeFormats = {
-    	  full: 'h:mm:ss a zzzz',
-    	  long: 'h:mm:ss a z',
-    	  medium: 'h:mm:ss a',
-    	  short: 'h:mm a'
-    	};
-    	var dateTimeFormats = {
-    	  full: "{{date}} 'at' {{time}}",
-    	  long: "{{date}} 'at' {{time}}",
-    	  medium: '{{date}}, {{time}}',
-    	  short: '{{date}}, {{time}}'
-    	};
-    	var formatLong = {
-    	  date: (0, _index.default)({
-    	    formats: dateFormats,
-    	    defaultWidth: 'full'
-    	  }),
-    	  time: (0, _index.default)({
-    	    formats: timeFormats,
-    	    defaultWidth: 'full'
-    	  }),
-    	  dateTime: (0, _index.default)({
-    	    formats: dateTimeFormats,
-    	    defaultWidth: 'full'
-    	  })
-    	};
-    	var _default = formatLong;
-    	exports.default = _default;
-    	module.exports = exports.default; 
-    } (formatLong, formatLong.exports));
-
-    var formatLongExports = formatLong.exports;
-
-    var formatRelative = {exports: {}};
-
-    (function (module, exports) {
-
-    	Object.defineProperty(exports, "__esModule", {
-    	  value: true
-    	});
-    	exports.default = void 0;
-    	var formatRelativeLocale = {
-    	  lastWeek: "'last' eeee 'at' p",
-    	  yesterday: "'yesterday at' p",
-    	  today: "'today at' p",
-    	  tomorrow: "'tomorrow at' p",
-    	  nextWeek: "eeee 'at' p",
-    	  other: 'P'
-    	};
-    	var formatRelative = function (token, _date, _baseDate, _options) {
-    	  return formatRelativeLocale[token];
-    	};
-    	var _default = formatRelative;
-    	exports.default = _default;
-    	module.exports = exports.default; 
-    } (formatRelative, formatRelative.exports));
-
-    var formatRelativeExports = formatRelative.exports;
-
-    var localize = {exports: {}};
-
-    var buildLocalizeFn = {exports: {}};
-
-    (function (module, exports) {
-
-    	Object.defineProperty(exports, "__esModule", {
-    	  value: true
-    	});
-    	exports.default = buildLocalizeFn;
-    	function buildLocalizeFn(args) {
-    	  return function (dirtyIndex, dirtyOptions) {
-    	    var options = dirtyOptions || {};
-    	    var context = options.context ? String(options.context) : 'standalone';
-    	    var valuesArray;
-    	    if (context === 'formatting' && args.formattingValues) {
-    	      var defaultWidth = args.defaultFormattingWidth || args.defaultWidth;
-    	      var width = options.width ? String(options.width) : defaultWidth;
-    	      valuesArray = args.formattingValues[width] || args.formattingValues[defaultWidth];
-    	    } else {
-    	      var _defaultWidth = args.defaultWidth;
-    	      var _width = options.width ? String(options.width) : args.defaultWidth;
-    	      valuesArray = args.values[_width] || args.values[_defaultWidth];
-    	    }
-    	    var index = args.argumentCallback ? args.argumentCallback(dirtyIndex) : dirtyIndex; // @ts-ignore: For some reason TypeScript just don't want to match it, no matter how hard we try. I challenge you to try to remove it!
-
-    	    return valuesArray[index];
-    	  };
-    	}
-    	module.exports = exports.default; 
-    } (buildLocalizeFn, buildLocalizeFn.exports));
-
-    var buildLocalizeFnExports = buildLocalizeFn.exports;
-
-    (function (module, exports) {
-
-    	Object.defineProperty(exports, "__esModule", {
-    	  value: true
-    	});
-    	exports.default = void 0;
-    	var _index = _interopRequireDefault(buildLocalizeFnExports);
-    	function _interopRequireDefault(obj) {
-    	  return obj && obj.__esModule ? obj : {
-    	    default: obj
-    	  };
-    	}
-    	var eraValues = {
-    	  narrow: ['B', 'A'],
-    	  abbreviated: ['BC', 'AD'],
-    	  wide: ['Before Christ', 'Anno Domini']
-    	};
-    	var quarterValues = {
-    	  narrow: ['1', '2', '3', '4'],
-    	  abbreviated: ['Q1', 'Q2', 'Q3', 'Q4'],
-    	  wide: ['1st quarter', '2nd quarter', '3rd quarter', '4th quarter']
-    	}; // Note: in English, the names of days of the week and months are capitalized.
-    	// If you are making a new locale based on this one, check if the same is true for the language you're working on.
-    	// Generally, formatted dates should look like they are in the middle of a sentence,
-    	// e.g. in Spanish language the weekdays and months should be in the lowercase.
+    	function cloneObject(dirtyObject) {
+    	  return (0, _index.default)({}, dirtyObject);
+    	}
+    	module.exports = exports.default; 
+    } (cloneObject$1, cloneObject$1.exports));
 
-    	var monthValues = {
-    	  narrow: ['J', 'F', 'M', 'A', 'M', 'J', 'J', 'A', 'S', 'O', 'N', 'D'],
-    	  abbreviated: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
-    	  wide: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
-    	};
-    	var dayValues = {
-    	  narrow: ['S', 'M', 'T', 'W', 'T', 'F', 'S'],
-    	  short: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'],
-    	  abbreviated: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
-    	  wide: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
-    	};
-    	var dayPeriodValues = {
-    	  narrow: {
-    	    am: 'a',
-    	    pm: 'p',
-    	    midnight: 'mi',
-    	    noon: 'n',
-    	    morning: 'morning',
-    	    afternoon: 'afternoon',
-    	    evening: 'evening',
-    	    night: 'night'
-    	  },
-    	  abbreviated: {
-    	    am: 'AM',
-    	    pm: 'PM',
-    	    midnight: 'midnight',
-    	    noon: 'noon',
-    	    morning: 'morning',
-    	    afternoon: 'afternoon',
-    	    evening: 'evening',
-    	    night: 'night'
-    	  },
-    	  wide: {
-    	    am: 'a.m.',
-    	    pm: 'p.m.',
-    	    midnight: 'midnight',
-    	    noon: 'noon',
-    	    morning: 'morning',
-    	    afternoon: 'afternoon',
-    	    evening: 'evening',
-    	    night: 'night'
-    	  }
-    	};
-    	var formattingDayPeriodValues = {
-    	  narrow: {
-    	    am: 'a',
-    	    pm: 'p',
-    	    midnight: 'mi',
-    	    noon: 'n',
-    	    morning: 'in the morning',
-    	    afternoon: 'in the afternoon',
-    	    evening: 'in the evening',
-    	    night: 'at night'
-    	  },
-    	  abbreviated: {
-    	    am: 'AM',
-    	    pm: 'PM',
-    	    midnight: 'midnight',
-    	    noon: 'noon',
-    	    morning: 'in the morning',
-    	    afternoon: 'in the afternoon',
-    	    evening: 'in the evening',
-    	    night: 'at night'
-    	  },
-    	  wide: {
-    	    am: 'a.m.',
-    	    pm: 'p.m.',
-    	    midnight: 'midnight',
-    	    noon: 'noon',
-    	    morning: 'in the morning',
-    	    afternoon: 'in the afternoon',
-    	    evening: 'in the evening',
-    	    night: 'at night'
-    	  }
-    	};
-    	var ordinalNumber = function (dirtyNumber, _options) {
-    	  var number = Number(dirtyNumber); // If ordinal numbers depend on context, for example,
-    	  // if they are different for different grammatical genders,
-    	  // use `options.unit`.
-    	  //
-    	  // `unit` can be 'year', 'quarter', 'month', 'week', 'date', 'dayOfYear',
-    	  // 'day', 'hour', 'minute', 'second'.
+    var cloneObjectExports = cloneObject$1.exports;
+    var cloneObject = /*@__PURE__*/getDefaultExportFromCjs(cloneObjectExports);
 
-    	  var rem100 = number % 100;
-    	  if (rem100 > 20 || rem100 < 10) {
-    	    switch (rem100 % 10) {
-    	      case 1:
-    	        return number + 'st';
-    	      case 2:
-    	        return number + 'nd';
-    	      case 3:
-    	        return number + 'rd';
-    	    }
-    	  }
-    	  return number + 'th';
-    	};
-    	var localize = {
-    	  ordinalNumber: ordinalNumber,
-    	  era: (0, _index.default)({
-    	    values: eraValues,
-    	    defaultWidth: 'wide'
-    	  }),
-    	  quarter: (0, _index.default)({
-    	    values: quarterValues,
-    	    defaultWidth: 'wide',
-    	    argumentCallback: function (quarter) {
-    	      return quarter - 1;
-    	    }
-    	  }),
-    	  month: (0, _index.default)({
-    	    values: monthValues,
-    	    defaultWidth: 'wide'
-    	  }),
-    	  day: (0, _index.default)({
-    	    values: dayValues,
-    	    defaultWidth: 'wide'
-    	  }),
-    	  dayPeriod: (0, _index.default)({
-    	    values: dayPeriodValues,
-    	    defaultWidth: 'wide',
-    	    formattingValues: formattingDayPeriodValues,
-    	    defaultFormattingWidth: 'wide'
-    	  })
-    	};
-    	var _default = localize;
-    	exports.default = _default;
-    	module.exports = exports.default; 
-    } (localize, localize.exports));
+    var format$3 = {exports: {}};
 
-    var localizeExports = localize.exports;
+    var isValid = {exports: {}};
 
-    var match = {exports: {}};
+    var isDate = {exports: {}};
 
-    var buildMatchFn = {exports: {}};
+    var requiredArgs = {exports: {}};
 
     (function (module, exports) {
 
     	Object.defineProperty(exports, "__esModule", {
     	  value: true
     	});
-    	exports.default = buildMatchFn;
-    	function buildMatchFn(args) {
-    	  return function (string) {
-    	    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    	    var width = options.width;
-    	    var matchPattern = width && args.matchPatterns[width] || args.matchPatterns[args.defaultMatchWidth];
-    	    var matchResult = string.match(matchPattern);
-    	    if (!matchResult) {
-    	      return null;
-    	    }
-    	    var matchedString = matchResult[0];
-    	    var parsePatterns = width && args.parsePatterns[width] || args.parsePatterns[args.defaultParseWidth];
-    	    var key = Array.isArray(parsePatterns) ? findIndex(parsePatterns, function (pattern) {
-    	      return pattern.test(matchedString);
-    	    }) : findKey(parsePatterns, function (pattern) {
-    	      return pattern.test(matchedString);
-    	    });
-    	    var value;
-    	    value = args.valueCallback ? args.valueCallback(key) : key;
-    	    value = options.valueCallback ? options.valueCallback(value) : value;
-    	    var rest = string.slice(matchedString.length);
-    	    return {
-    	      value: value,
-    	      rest: rest
-    	    };
-    	  };
-    	}
-    	function findKey(object, predicate) {
-    	  for (var key in object) {
-    	    if (object.hasOwnProperty(key) && predicate(object[key])) {
-    	      return key;
-    	    }
-    	  }
-    	  return undefined;
-    	}
-    	function findIndex(array, predicate) {
-    	  for (var key = 0; key < array.length; key++) {
-    	    if (predicate(array[key])) {
-    	      return key;
-    	    }
+    	exports.default = requiredArgs;
+    	function requiredArgs(required, args) {
+    	  if (args.length < required) {
+    	    throw new TypeError(required + ' argument' + (required > 1 ? 's' : '') + ' required, but only ' + args.length + ' present');
     	  }
-    	  return undefined;
     	}
     	module.exports = exports.default; 
-    } (buildMatchFn, buildMatchFn.exports));
-
-    var buildMatchFnExports = buildMatchFn.exports;
+    } (requiredArgs, requiredArgs.exports));
 
-    var buildMatchPatternFn = {exports: {}};
+    var requiredArgsExports = requiredArgs.exports;
 
     (function (module, exports) {
 
     	Object.defineProperty(exports, "__esModule", {
     	  value: true
     	});
-    	exports.default = buildMatchPatternFn;
-    	function buildMatchPatternFn(args) {
-    	  return function (string) {
-    	    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    	    var matchResult = string.match(args.matchPattern);
-    	    if (!matchResult) return null;
-    	    var matchedString = matchResult[0];
-    	    var parseResult = string.match(args.parsePattern);
-    	    if (!parseResult) return null;
-    	    var value = args.valueCallback ? args.valueCallback(parseResult[0]) : parseResult[0];
-    	    value = options.valueCallback ? options.valueCallback(value) : value;
-    	    var rest = string.slice(matchedString.length);
-    	    return {
-    	      value: value,
-    	      rest: rest
-    	    };
+    	exports.default = isDate;
+    	var _index = _interopRequireDefault(requiredArgsExports);
+    	function _interopRequireDefault(obj) {
+    	  return obj && obj.__esModule ? obj : {
+    	    default: obj
     	  };
     	}
+
+    	/**
+    	 * @name isDate
+    	 * @category Common Helpers
+    	 * @summary Is the given value a date?
+    	 *
+    	 * @description
+    	 * Returns true if the given value is an instance of Date. The function works for dates transferred across iframes.
+    	 *
+    	 * ### v2.0.0 breaking changes:
+    	 *
+    	 * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).
+    	 *
+    	 * @param {*} value - the value to check
+    	 * @returns {boolean} true if the given value is a date
+    	 * @throws {TypeError} 1 arguments required
+    	 *
+    	 * @example
+    	 * // For a valid date:
+    	 * const result = isDate(new Date())
+    	 * //=> true
+    	 *
+    	 * @example
+    	 * // For an invalid date:
+    	 * const result = isDate(new Date(NaN))
+    	 * //=> true
+    	 *
+    	 * @example
+    	 * // For some value:
+    	 * const result = isDate('2014-02-31')
+    	 * //=> false
+    	 *
+    	 * @example
+    	 * // For an object:
+    	 * const result = isDate({})
+    	 * //=> false
+    	 */
+    	function isDate(value) {
+    	  (0, _index.default)(1, arguments);
+    	  return value instanceof Date || typeof value === 'object' && Object.prototype.toString.call(value) === '[object Date]';
+    	}
     	module.exports = exports.default; 
-    } (buildMatchPatternFn, buildMatchPatternFn.exports));
+    } (isDate, isDate.exports));
+
+    var isDateExports = isDate.exports;
 
-    var buildMatchPatternFnExports = buildMatchPatternFn.exports;
+    var toDate$1 = {exports: {}};
 
     (function (module, exports) {
 
     	Object.defineProperty(exports, "__esModule", {
     	  value: true
     	});
-    	exports.default = void 0;
-    	var _index = _interopRequireDefault(buildMatchFnExports);
-    	var _index2 = _interopRequireDefault(buildMatchPatternFnExports);
+    	exports.default = toDate;
+    	var _index = _interopRequireDefault(requiredArgsExports);
     	function _interopRequireDefault(obj) {
     	  return obj && obj.__esModule ? obj : {
     	    default: obj
     	  };
     	}
-    	var matchOrdinalNumberPattern = /^(\d+)(th|st|nd|rd)?/i;
-    	var parseOrdinalNumberPattern = /\d+/i;
-    	var matchEraPatterns = {
-    	  narrow: /^(b|a)/i,
-    	  abbreviated: /^(b\.?\s?c\.?|b\.?\s?c\.?\s?e\.?|a\.?\s?d\.?|c\.?\s?e\.?)/i,
-    	  wide: /^(before christ|before common era|anno domini|common era)/i
-    	};
-    	var parseEraPatterns = {
-    	  any: [/^b/i, /^(a|c)/i]
-    	};
-    	var matchQuarterPatterns = {
-    	  narrow: /^[1234]/i,
-    	  abbreviated: /^q[1234]/i,
-    	  wide: /^[1234](th|st|nd|rd)? quarter/i
-    	};
-    	var parseQuarterPatterns = {
-    	  any: [/1/i, /2/i, /3/i, /4/i]
-    	};
-    	var matchMonthPatterns = {
-    	  narrow: /^[jfmasond]/i,
-    	  abbreviated: /^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i,
-    	  wide: /^(january|february|march|april|may|june|july|august|september|october|november|december)/i
-    	};
-    	var parseMonthPatterns = {
-    	  narrow: [/^j/i, /^f/i, /^m/i, /^a/i, /^m/i, /^j/i, /^j/i, /^a/i, /^s/i, /^o/i, /^n/i, /^d/i],
-    	  any: [/^ja/i, /^f/i, /^mar/i, /^ap/i, /^may/i, /^jun/i, /^jul/i, /^au/i, /^s/i, /^o/i, /^n/i, /^d/i]
-    	};
-    	var matchDayPatterns = {
-    	  narrow: /^[smtwf]/i,
-    	  short: /^(su|mo|tu|we|th|fr|sa)/i,
-    	  abbreviated: /^(sun|mon|tue|wed|thu|fri|sat)/i,
-    	  wide: /^(sunday|monday|tuesday|wednesday|thursday|friday|saturday)/i
-    	};
-    	var parseDayPatterns = {
-    	  narrow: [/^s/i, /^m/i, /^t/i, /^w/i, /^t/i, /^f/i, /^s/i],
-    	  any: [/^su/i, /^m/i, /^tu/i, /^w/i, /^th/i, /^f/i, /^sa/i]
-    	};
-    	var matchDayPeriodPatterns = {
-    	  narrow: /^(a|p|mi|n|(in the|at) (morning|afternoon|evening|night))/i,
-    	  any: /^([ap]\.?\s?m\.?|midnight|noon|(in the|at) (morning|afternoon|evening|night))/i
-    	};
-    	var parseDayPeriodPatterns = {
-    	  any: {
-    	    am: /^a/i,
-    	    pm: /^p/i,
-    	    midnight: /^mi/i,
-    	    noon: /^no/i,
-    	    morning: /morning/i,
-    	    afternoon: /afternoon/i,
-    	    evening: /evening/i,
-    	    night: /night/i
-    	  }
-    	};
-    	var match = {
-    	  ordinalNumber: (0, _index2.default)({
-    	    matchPattern: matchOrdinalNumberPattern,
-    	    parsePattern: parseOrdinalNumberPattern,
-    	    valueCallback: function (value) {
-    	      return parseInt(value, 10);
-    	    }
-    	  }),
-    	  era: (0, _index.default)({
-    	    matchPatterns: matchEraPatterns,
-    	    defaultMatchWidth: 'wide',
-    	    parsePatterns: parseEraPatterns,
-    	    defaultParseWidth: 'any'
-    	  }),
-    	  quarter: (0, _index.default)({
-    	    matchPatterns: matchQuarterPatterns,
-    	    defaultMatchWidth: 'wide',
-    	    parsePatterns: parseQuarterPatterns,
-    	    defaultParseWidth: 'any',
-    	    valueCallback: function (index) {
-    	      return index + 1;
+
+    	/**
+    	 * @name toDate
+    	 * @category Common Helpers
+    	 * @summary Convert the given argument to an instance of Date.
+    	 *
+    	 * @description
+    	 * Convert the given argument to an instance of Date.
+    	 *
+    	 * If the argument is an instance of Date, the function returns its clone.
+    	 *
+    	 * If the argument is a number, it is treated as a timestamp.
+    	 *
+    	 * If the argument is none of the above, the function returns Invalid Date.
+    	 *
+    	 * **Note**: *all* Date arguments passed to any *date-fns* function is processed by `toDate`.
+    	 *
+    	 * @param {Date|Number} argument - the value to convert
+    	 * @returns {Date} the parsed date in the local time zone
+    	 * @throws {TypeError} 1 argument required
+    	 *
+    	 * @example
+    	 * // Clone the date:
+    	 * const result = toDate(new Date(2014, 1, 11, 11, 30, 30))
+    	 * //=> Tue Feb 11 2014 11:30:30
+    	 *
+    	 * @example
+    	 * // Convert the timestamp to date:
+    	 * const result = toDate(1392098430000)
+    	 * //=> Tue Feb 11 2014 11:30:30
+    	 */
+    	function toDate(argument) {
+    	  (0, _index.default)(1, arguments);
+    	  var argStr = Object.prototype.toString.call(argument); // Clone the date
+
+    	  if (argument instanceof Date || typeof argument === 'object' && argStr === '[object Date]') {
+    	    // Prevent the date to lose the milliseconds when passed to new Date() in IE10
+    	    return new Date(argument.getTime());
+    	  } else if (typeof argument === 'number' || argStr === '[object Number]') {
+    	    return new Date(argument);
+    	  } else {
+    	    if ((typeof argument === 'string' || argStr === '[object String]') && typeof console !== 'undefined') {
+    	      // eslint-disable-next-line no-console
+    	      console.warn("Starting with v2.0.0-beta.1 date-fns doesn't accept strings as date arguments. Please use `parseISO` to parse strings. See: https://git.io/fjule"); // eslint-disable-next-line no-console
+
+    	      console.warn(new Error().stack);
     	    }
-    	  }),
-    	  month: (0, _index.default)({
-    	    matchPatterns: matchMonthPatterns,
-    	    defaultMatchWidth: 'wide',
-    	    parsePatterns: parseMonthPatterns,
-    	    defaultParseWidth: 'any'
-    	  }),
-    	  day: (0, _index.default)({
-    	    matchPatterns: matchDayPatterns,
-    	    defaultMatchWidth: 'wide',
-    	    parsePatterns: parseDayPatterns,
-    	    defaultParseWidth: 'any'
-    	  }),
-    	  dayPeriod: (0, _index.default)({
-    	    matchPatterns: matchDayPeriodPatterns,
-    	    defaultMatchWidth: 'any',
-    	    parsePatterns: parseDayPeriodPatterns,
-    	    defaultParseWidth: 'any'
-    	  })
-    	};
-    	var _default = match;
-    	exports.default = _default;
+    	    return new Date(NaN);
+    	  }
+    	}
     	module.exports = exports.default; 
-    } (match, match.exports));
+    } (toDate$1, toDate$1.exports));
 
-    var matchExports = match.exports;
+    var toDateExports = toDate$1.exports;
 
     (function (module, exports) {
 
     	Object.defineProperty(exports, "__esModule", {
     	  value: true
     	});
-    	exports.default = void 0;
-    	var _index = _interopRequireDefault(formatDistanceExports);
-    	var _index2 = _interopRequireDefault(formatLongExports);
-    	var _index3 = _interopRequireDefault(formatRelativeExports);
-    	var _index4 = _interopRequireDefault(localizeExports);
-    	var _index5 = _interopRequireDefault(matchExports);
+    	exports.default = isValid;
+    	var _index = _interopRequireDefault(isDateExports);
+    	var _index2 = _interopRequireDefault(toDateExports);
+    	var _index3 = _interopRequireDefault(requiredArgsExports);
     	function _interopRequireDefault(obj) {
     	  return obj && obj.__esModule ? obj : {
     	    default: obj
@@ -88330,34 +88440,74 @@
     	}
 
     	/**
-    	 * @type {Locale}
-    	 * @category Locales
-    	 * @summary English locale (United States).
-    	 * @language English
-    	 * @iso-639-2 eng
-    	 * @author Sasha Koss [@kossnocorp]{@link https://github.com/kossnocorp}
-    	 * @author Lesha Koss [@leshakoss]{@link https://github.com/leshakoss}
+    	 * @name isValid
+    	 * @category Common Helpers
+    	 * @summary Is the given date valid?
+    	 *
+    	 * @description
+    	 * Returns false if argument is Invalid Date and true otherwise.
+    	 * Argument is converted to Date using `toDate`. See [toDate]{@link https://date-fns.org/docs/toDate}
+    	 * Invalid Date is a Date, whose time value is NaN.
+    	 *
+    	 * Time value of Date: http://es5.github.io/#x15.9.1.1
+    	 *
+    	 * ### v2.0.0 breaking changes:
+    	 *
+    	 * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).
+    	 *
+    	 * - Now `isValid` doesn't throw an exception
+    	 *   if the first argument is not an instance of Date.
+    	 *   Instead, argument is converted beforehand using `toDate`.
+    	 *
+    	 *   Examples:
+    	 *
+    	 *   | `isValid` argument        | Before v2.0.0 | v2.0.0 onward |
+    	 *   |---------------------------|---------------|---------------|
+    	 *   | `new Date()`              | `true`        | `true`        |
+    	 *   | `new Date('2016-01-01')`  | `true`        | `true`        |
+    	 *   | `new Date('')`            | `false`       | `false`       |
+    	 *   | `new Date(1488370835081)` | `true`        | `true`        |
+    	 *   | `new Date(NaN)`           | `false`       | `false`       |
+    	 *   | `'2016-01-01'`            | `TypeError`   | `false`       |
+    	 *   | `''`                      | `TypeError`   | `false`       |
+    	 *   | `1488370835081`           | `TypeError`   | `true`        |
+    	 *   | `NaN`                     | `TypeError`   | `false`       |
+    	 *
+    	 *   We introduce this change to make *date-fns* consistent with ECMAScript behavior
+    	 *   that try to coerce arguments to the expected type
+    	 *   (which is also the case with other *date-fns* functions).
+    	 *
+    	 * @param {*} date - the date to check
+    	 * @returns {Boolean} the date is valid
+    	 * @throws {TypeError} 1 argument required
+    	 *
+    	 * @example
+    	 * // For the valid date:
+    	 * const result = isValid(new Date(2014, 1, 31))
+    	 * //=> true
+    	 *
+    	 * @example
+    	 * // For the value, convertable into a date:
+    	 * const result = isValid(1393804800000)
+    	 * //=> true
+    	 *
+    	 * @example
+    	 * // For the invalid date:
+    	 * const result = isValid(new Date(''))
+    	 * //=> false
     	 */
-    	var locale = {
-    	  code: 'en-US',
-    	  formatDistance: _index.default,
-    	  formatLong: _index2.default,
-    	  formatRelative: _index3.default,
-    	  localize: _index4.default,
-    	  match: _index5.default,
-    	  options: {
-    	    weekStartsOn: 0
-    	    /* Sunday */,
-
-    	    firstWeekContainsDate: 1
+    	function isValid(dirtyDate) {
+    	  (0, _index3.default)(1, arguments);
+    	  if (!(0, _index.default)(dirtyDate) && typeof dirtyDate !== 'number') {
+    	    return false;
     	  }
-    	};
-    	var _default = locale;
-    	exports.default = _default;
+    	  var date = (0, _index2.default)(dirtyDate);
+    	  return !isNaN(Number(date));
+    	}
     	module.exports = exports.default; 
-    } (enUS, enUS.exports));
+    } (isValid, isValid.exports));
 
-    var enUSExports = enUS.exports;
+    var isValidExports = isValid.exports;
 
     var subMilliseconds = {exports: {}};
 
@@ -131093,7 +131243,7 @@
         watermarkProps: watermarkProps
     });
 
-    var version = "1.13.2";
+    var version = "1.14.0";
 
     function useExposeProxy(targetRef) {
       return new Proxy({}, {
@@ -132245,7 +132395,7 @@
     exports.ellipsisProps = ellipsisProps;
     exports.emptyDark = emptyDark$1;
     exports.emptyProps = emptyProps;
-    exports.enUS = enUS$1;
+    exports.enUS = enUS$2;
     exports.equationProps = equationProps;
     exports.flexProps = flexProps;
     exports.formDark = formItemDark;