@retailcrm/embed-ui-v1-components 0.5.14 → 0.5.16

package/dist/remote.cjs

@@ -3,6 +3,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const vue = require("vue");
 require("@remote-ui/rpc");
 const imagePreview = require("@retailcrm/image-preview");
+const dateFns = require("date-fns");
 const REMOTE_SLOT = "RemoteSlot";
 const toRemoteSlots = (named, slots) => {
   const actual = named.filter((slotName) => slotName in slots);
@@ -181,6 +182,1631 @@ const usePreview = (workers = vue.ref([])) => {
     preview: (url, resize = void 0, crop = void 0) => imagePreview.preview(_workers.value, url, resize, crop)
   };
 };
+function buildFormatLongFn(args) {
+  return (options = {}) => {
+    const width = options.width ? String(options.width) : args.defaultWidth;
+    const format = args.formats[width] || args.formats[args.defaultWidth];
+    return format;
+  };
+}
+function buildLocalizeFn(args) {
+  return (value, options) => {
+    const context = (options == null ? void 0 : options.context) ? String(options.context) : "standalone";
+    let valuesArray;
+    if (context === "formatting" && args.formattingValues) {
+      const defaultWidth = args.defaultFormattingWidth || args.defaultWidth;
+      const width = (options == null ? void 0 : options.width) ? String(options.width) : defaultWidth;
+      valuesArray = args.formattingValues[width] || args.formattingValues[defaultWidth];
+    } else {
+      const defaultWidth = args.defaultWidth;
+      const width = (options == null ? void 0 : options.width) ? String(options.width) : args.defaultWidth;
+      valuesArray = args.values[width] || args.values[defaultWidth];
+    }
+    const index = args.argumentCallback ? args.argumentCallback(value) : value;
+    return valuesArray[index];
+  };
+}
+function buildMatchFn(args) {
+  return (string, options = {}) => {
+    const width = options.width;
+    const matchPattern = width && args.matchPatterns[width] || args.matchPatterns[args.defaultMatchWidth];
+    const matchResult = string.match(matchPattern);
+    if (!matchResult) {
+      return null;
+    }
+    const matchedString = matchResult[0];
+    const parsePatterns = width && args.parsePatterns[width] || args.parsePatterns[args.defaultParseWidth];
+    const key = Array.isArray(parsePatterns) ? findIndex(parsePatterns, (pattern) => pattern.test(matchedString)) : (
+      // [TODO] -- I challenge you to fix the type
+      findKey(parsePatterns, (pattern) => pattern.test(matchedString))
+    );
+    let value;
+    value = args.valueCallback ? args.valueCallback(key) : key;
+    value = options.valueCallback ? (
+      // [TODO] -- I challenge you to fix the type
+      options.valueCallback(value)
+    ) : value;
+    const rest = string.slice(matchedString.length);
+    return { value, rest };
+  };
+}
+function findKey(object, predicate) {
+  for (const key in object) {
+    if (Object.prototype.hasOwnProperty.call(object, key) && predicate(object[key])) {
+      return key;
+    }
+  }
+  return void 0;
+}
+function findIndex(array, predicate) {
+  for (let key = 0; key < array.length; key++) {
+    if (predicate(array[key])) {
+      return key;
+    }
+  }
+  return void 0;
+}
+function buildMatchPatternFn(args) {
+  return (string, options = {}) => {
+    const matchResult = string.match(args.matchPattern);
+    if (!matchResult) return null;
+    const matchedString = matchResult[0];
+    const parseResult = string.match(args.parsePattern);
+    if (!parseResult) return null;
+    let value = args.valueCallback ? args.valueCallback(parseResult[0]) : parseResult[0];
+    value = options.valueCallback ? options.valueCallback(value) : value;
+    const rest = string.slice(matchedString.length);
+    return { value, rest };
+  };
+}
+const constructFromSymbol = Symbol.for("constructDateFrom");
+function constructFrom(date, value) {
+  if (typeof date === "function") return date(value);
+  if (date && typeof date === "object" && constructFromSymbol in date)
+    return date[constructFromSymbol](value);
+  if (date instanceof Date) return new date.constructor(value);
+  return new Date(value);
+}
+function normalizeDates(context, ...dates) {
+  const normalize = constructFrom.bind(
+    null,
+    context || dates.find((date) => typeof date === "object")
+  );
+  return dates.map(normalize);
+}
+let defaultOptions = {};
+function getDefaultOptions() {
+  return defaultOptions;
+}
+function toDate(argument, context) {
+  return constructFrom(context || argument, argument);
+}
+function startOfWeek(date, options) {
+  var _a, _b, _c, _d;
+  const defaultOptions2 = getDefaultOptions();
+  const weekStartsOn = (options == null ? void 0 : options.weekStartsOn) ?? ((_b = (_a = options == null ? void 0 : options.locale) == null ? void 0 : _a.options) == null ? void 0 : _b.weekStartsOn) ?? defaultOptions2.weekStartsOn ?? ((_d = (_c = defaultOptions2.locale) == null ? void 0 : _c.options) == null ? void 0 : _d.weekStartsOn) ?? 0;
+  const _date = toDate(date, options == null ? void 0 : options.in);
+  const day = _date.getDay();
+  const diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;
+  _date.setDate(_date.getDate() - diff);
+  _date.setHours(0, 0, 0, 0);
+  return _date;
+}
+function isSameWeek(laterDate, earlierDate, options) {
+  const [laterDate_, earlierDate_] = normalizeDates(
+    options == null ? void 0 : options.in,
+    laterDate,
+    earlierDate
+  );
+  return +startOfWeek(laterDate_, options) === +startOfWeek(earlierDate_, options);
+}
+const formatDistanceLocale$2 = {
+  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"
+  }
+};
+const formatDistance$2 = (token, count, options) => {
+  let result;
+  const tokenValue = formatDistanceLocale$2[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 ? void 0 : options.addSuffix) {
+    if (options.comparison && options.comparison > 0) {
+      return "in " + result;
+    } else {
+      return result + " ago";
+    }
+  }
+  return result;
+};
+const formatRelativeLocale$2 = {
+  lastWeek: "'last' eeee 'at' p",
+  yesterday: "'yesterday at' p",
+  today: "'today at' p",
+  tomorrow: "'tomorrow at' p",
+  nextWeek: "eeee 'at' p",
+  other: "P"
+};
+const formatRelative$2 = (token, _date, _baseDate, _options) => formatRelativeLocale$2[token];
+const eraValues$2 = {
+  narrow: ["B", "A"],
+  abbreviated: ["BC", "AD"],
+  wide: ["Before Christ", "Anno Domini"]
+};
+const quarterValues$2 = {
+  narrow: ["1", "2", "3", "4"],
+  abbreviated: ["Q1", "Q2", "Q3", "Q4"],
+  wide: ["1st quarter", "2nd quarter", "3rd quarter", "4th quarter"]
+};
+const monthValues$2 = {
+  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"
+  ]
+};
+const dayValues$2 = {
+  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"
+  ]
+};
+const dayPeriodValues$2 = {
+  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"
+  }
+};
+const formattingDayPeriodValues$2 = {
+  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"
+  }
+};
+const ordinalNumber$2 = (dirtyNumber, _options) => {
+  const number = Number(dirtyNumber);
+  const 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";
+};
+const localize$2 = {
+  ordinalNumber: ordinalNumber$2,
+  era: buildLocalizeFn({
+    values: eraValues$2,
+    defaultWidth: "wide"
+  }),
+  quarter: buildLocalizeFn({
+    values: quarterValues$2,
+    defaultWidth: "wide",
+    argumentCallback: (quarter) => quarter - 1
+  }),
+  month: buildLocalizeFn({
+    values: monthValues$2,
+    defaultWidth: "wide"
+  }),
+  day: buildLocalizeFn({
+    values: dayValues$2,
+    defaultWidth: "wide"
+  }),
+  dayPeriod: buildLocalizeFn({
+    values: dayPeriodValues$2,
+    defaultWidth: "wide",
+    formattingValues: formattingDayPeriodValues$2,
+    defaultFormattingWidth: "wide"
+  })
+};
+const matchOrdinalNumberPattern$2 = /^(\d+)(th|st|nd|rd)?/i;
+const parseOrdinalNumberPattern$2 = /\d+/i;
+const matchEraPatterns$2 = {
+  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
+};
+const parseEraPatterns$2 = {
+  any: [/^b/i, /^(a|c)/i]
+};
+const matchQuarterPatterns$2 = {
+  narrow: /^[1234]/i,
+  abbreviated: /^q[1234]/i,
+  wide: /^[1234](th|st|nd|rd)? quarter/i
+};
+const parseQuarterPatterns$2 = {
+  any: [/1/i, /2/i, /3/i, /4/i]
+};
+const matchMonthPatterns$2 = {
+  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
+};
+const parseMonthPatterns$2 = {
+  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
+  ]
+};
+const matchDayPatterns$2 = {
+  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
+};
+const parseDayPatterns$2 = {
+  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]
+};
+const matchDayPeriodPatterns$2 = {
+  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
+};
+const parseDayPeriodPatterns$2 = {
+  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
+  }
+};
+const match$2 = {
+  ordinalNumber: buildMatchPatternFn({
+    matchPattern: matchOrdinalNumberPattern$2,
+    parsePattern: parseOrdinalNumberPattern$2,
+    valueCallback: (value) => parseInt(value, 10)
+  }),
+  era: buildMatchFn({
+    matchPatterns: matchEraPatterns$2,
+    defaultMatchWidth: "wide",
+    parsePatterns: parseEraPatterns$2,
+    defaultParseWidth: "any"
+  }),
+  quarter: buildMatchFn({
+    matchPatterns: matchQuarterPatterns$2,
+    defaultMatchWidth: "wide",
+    parsePatterns: parseQuarterPatterns$2,
+    defaultParseWidth: "any",
+    valueCallback: (index) => index + 1
+  }),
+  month: buildMatchFn({
+    matchPatterns: matchMonthPatterns$2,
+    defaultMatchWidth: "wide",
+    parsePatterns: parseMonthPatterns$2,
+    defaultParseWidth: "any"
+  }),
+  day: buildMatchFn({
+    matchPatterns: matchDayPatterns$2,
+    defaultMatchWidth: "wide",
+    parsePatterns: parseDayPatterns$2,
+    defaultParseWidth: "any"
+  }),
+  dayPeriod: buildMatchFn({
+    matchPatterns: matchDayPeriodPatterns$2,
+    defaultMatchWidth: "any",
+    parsePatterns: parseDayPeriodPatterns$2,
+    defaultParseWidth: "any"
+  })
+};
+const dateFormats$2 = {
+  full: "EEEE, d MMMM yyyy",
+  long: "d MMMM yyyy",
+  medium: "d MMM yyyy",
+  short: "dd/MM/yyyy"
+};
+const timeFormats$2 = {
+  full: "HH:mm:ss zzzz",
+  long: "HH:mm:ss z",
+  medium: "HH:mm:ss",
+  short: "HH:mm"
+};
+const dateTimeFormats$2 = {
+  full: "{{date}} 'at' {{time}}",
+  long: "{{date}} 'at' {{time}}",
+  medium: "{{date}}, {{time}}",
+  short: "{{date}}, {{time}}"
+};
+const formatLong$2 = {
+  date: buildFormatLongFn({
+    formats: dateFormats$2,
+    defaultWidth: "full"
+  }),
+  time: buildFormatLongFn({
+    formats: timeFormats$2,
+    defaultWidth: "full"
+  }),
+  dateTime: buildFormatLongFn({
+    formats: dateTimeFormats$2,
+    defaultWidth: "full"
+  })
+};
+const enGB = {
+  code: "en-GB",
+  formatDistance: formatDistance$2,
+  formatLong: formatLong$2,
+  formatRelative: formatRelative$2,
+  localize: localize$2,
+  match: match$2,
+  options: {
+    weekStartsOn: 1,
+    firstWeekContainsDate: 4
+  }
+};
+const formatDistanceLocale$1 = {
+  lessThanXSeconds: {
+    one: "menos de un segundo",
+    other: "menos de {{count}} segundos"
+  },
+  xSeconds: {
+    one: "1 segundo",
+    other: "{{count}} segundos"
+  },
+  halfAMinute: "medio minuto",
+  lessThanXMinutes: {
+    one: "menos de un minuto",
+    other: "menos de {{count}} minutos"
+  },
+  xMinutes: {
+    one: "1 minuto",
+    other: "{{count}} minutos"
+  },
+  aboutXHours: {
+    one: "alrededor de 1 hora",
+    other: "alrededor de {{count}} horas"
+  },
+  xHours: {
+    one: "1 hora",
+    other: "{{count}} horas"
+  },
+  xDays: {
+    one: "1 día",
+    other: "{{count}} días"
+  },
+  aboutXWeeks: {
+    one: "alrededor de 1 semana",
+    other: "alrededor de {{count}} semanas"
+  },
+  xWeeks: {
+    one: "1 semana",
+    other: "{{count}} semanas"
+  },
+  aboutXMonths: {
+    one: "alrededor de 1 mes",
+    other: "alrededor de {{count}} meses"
+  },
+  xMonths: {
+    one: "1 mes",
+    other: "{{count}} meses"
+  },
+  aboutXYears: {
+    one: "alrededor de 1 año",
+    other: "alrededor de {{count}} años"
+  },
+  xYears: {
+    one: "1 año",
+    other: "{{count}} años"
+  },
+  overXYears: {
+    one: "más de 1 año",
+    other: "más de {{count}} años"
+  },
+  almostXYears: {
+    one: "casi 1 año",
+    other: "casi {{count}} años"
+  }
+};
+const formatDistance$1 = (token, count, options) => {
+  let result;
+  const 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 ? void 0 : options.addSuffix) {
+    if (options.comparison && options.comparison > 0) {
+      return "en " + result;
+    } else {
+      return "hace " + result;
+    }
+  }
+  return result;
+};
+const dateFormats$1 = {
+  full: "EEEE, d 'de' MMMM 'de' y",
+  long: "d 'de' MMMM 'de' y",
+  medium: "d MMM y",
+  short: "dd/MM/y"
+};
+const timeFormats$1 = {
+  full: "HH:mm:ss zzzz",
+  long: "HH:mm:ss z",
+  medium: "HH:mm:ss",
+  short: "HH:mm"
+};
+const dateTimeFormats$1 = {
+  full: "{{date}} 'a las' {{time}}",
+  long: "{{date}} 'a las' {{time}}",
+  medium: "{{date}}, {{time}}",
+  short: "{{date}}, {{time}}"
+};
+const formatLong$1 = {
+  date: buildFormatLongFn({
+    formats: dateFormats$1,
+    defaultWidth: "full"
+  }),
+  time: buildFormatLongFn({
+    formats: timeFormats$1,
+    defaultWidth: "full"
+  }),
+  dateTime: buildFormatLongFn({
+    formats: dateTimeFormats$1,
+    defaultWidth: "full"
+  })
+};
+const formatRelativeLocale$1 = {
+  lastWeek: "'el' eeee 'pasado a la' p",
+  yesterday: "'ayer a la' p",
+  today: "'hoy a la' p",
+  tomorrow: "'mañana a la' p",
+  nextWeek: "eeee 'a la' p",
+  other: "P"
+};
+const formatRelativeLocalePlural = {
+  lastWeek: "'el' eeee 'pasado a las' p",
+  yesterday: "'ayer a las' p",
+  today: "'hoy a las' p",
+  tomorrow: "'mañana a las' p",
+  nextWeek: "eeee 'a las' p",
+  other: "P"
+};
+const formatRelative$1 = (token, date, _baseDate, _options) => {
+  if (date.getHours() !== 1) {
+    return formatRelativeLocalePlural[token];
+  } else {
+    return formatRelativeLocale$1[token];
+  }
+};
+const eraValues$1 = {
+  narrow: ["AC", "DC"],
+  abbreviated: ["AC", "DC"],
+  wide: ["antes de cristo", "después de cristo"]
+};
+const quarterValues$1 = {
+  narrow: ["1", "2", "3", "4"],
+  abbreviated: ["T1", "T2", "T3", "T4"],
+  wide: ["1º trimestre", "2º trimestre", "3º trimestre", "4º trimestre"]
+};
+const monthValues$1 = {
+  narrow: ["e", "f", "m", "a", "m", "j", "j", "a", "s", "o", "n", "d"],
+  abbreviated: [
+    "ene",
+    "feb",
+    "mar",
+    "abr",
+    "may",
+    "jun",
+    "jul",
+    "ago",
+    "sep",
+    "oct",
+    "nov",
+    "dic"
+  ],
+  wide: [
+    "enero",
+    "febrero",
+    "marzo",
+    "abril",
+    "mayo",
+    "junio",
+    "julio",
+    "agosto",
+    "septiembre",
+    "octubre",
+    "noviembre",
+    "diciembre"
+  ]
+};
+const dayValues$1 = {
+  narrow: ["d", "l", "m", "m", "j", "v", "s"],
+  short: ["do", "lu", "ma", "mi", "ju", "vi", "sá"],
+  abbreviated: ["dom", "lun", "mar", "mié", "jue", "vie", "sáb"],
+  wide: [
+    "domingo",
+    "lunes",
+    "martes",
+    "miércoles",
+    "jueves",
+    "viernes",
+    "sábado"
+  ]
+};
+const dayPeriodValues$1 = {
+  narrow: {
+    am: "a",
+    pm: "p",
+    midnight: "mn",
+    noon: "md",
+    morning: "mañana",
+    afternoon: "tarde",
+    evening: "tarde",
+    night: "noche"
+  },
+  abbreviated: {
+    am: "AM",
+    pm: "PM",
+    midnight: "medianoche",
+    noon: "mediodia",
+    morning: "mañana",
+    afternoon: "tarde",
+    evening: "tarde",
+    night: "noche"
+  },
+  wide: {
+    am: "a.m.",
+    pm: "p.m.",
+    midnight: "medianoche",
+    noon: "mediodia",
+    morning: "mañana",
+    afternoon: "tarde",
+    evening: "tarde",
+    night: "noche"
+  }
+};
+const formattingDayPeriodValues$1 = {
+  narrow: {
+    am: "a",
+    pm: "p",
+    midnight: "mn",
+    noon: "md",
+    morning: "de la mañana",
+    afternoon: "de la tarde",
+    evening: "de la tarde",
+    night: "de la noche"
+  },
+  abbreviated: {
+    am: "AM",
+    pm: "PM",
+    midnight: "medianoche",
+    noon: "mediodia",
+    morning: "de la mañana",
+    afternoon: "de la tarde",
+    evening: "de la tarde",
+    night: "de la noche"
+  },
+  wide: {
+    am: "a.m.",
+    pm: "p.m.",
+    midnight: "medianoche",
+    noon: "mediodia",
+    morning: "de la mañana",
+    afternoon: "de la tarde",
+    evening: "de la tarde",
+    night: "de la noche"
+  }
+};
+const ordinalNumber$1 = (dirtyNumber, _options) => {
+  const number = Number(dirtyNumber);
+  return number + "º";
+};
+const localize$1 = {
+  ordinalNumber: ordinalNumber$1,
+  era: buildLocalizeFn({
+    values: eraValues$1,
+    defaultWidth: "wide"
+  }),
+  quarter: buildLocalizeFn({
+    values: quarterValues$1,
+    defaultWidth: "wide",
+    argumentCallback: (quarter) => Number(quarter) - 1
+  }),
+  month: buildLocalizeFn({
+    values: monthValues$1,
+    defaultWidth: "wide"
+  }),
+  day: buildLocalizeFn({
+    values: dayValues$1,
+    defaultWidth: "wide"
+  }),
+  dayPeriod: buildLocalizeFn({
+    values: dayPeriodValues$1,
+    defaultWidth: "wide",
+    formattingValues: formattingDayPeriodValues$1,
+    defaultFormattingWidth: "wide"
+  })
+};
+const matchOrdinalNumberPattern$1 = /^(\d+)(º)?/i;
+const parseOrdinalNumberPattern$1 = /\d+/i;
+const matchEraPatterns$1 = {
+  narrow: /^(ac|dc|a|d)/i,
+  abbreviated: /^(a\.?\s?c\.?|a\.?\s?e\.?\s?c\.?|d\.?\s?c\.?|e\.?\s?c\.?)/i,
+  wide: /^(antes de cristo|antes de la era com[uú]n|despu[eé]s de cristo|era com[uú]n)/i
+};
+const parseEraPatterns$1 = {
+  any: [/^ac/i, /^dc/i],
+  wide: [
+    /^(antes de cristo|antes de la era com[uú]n)/i,
+    /^(despu[eé]s de cristo|era com[uú]n)/i
+  ]
+};
+const matchQuarterPatterns$1 = {
+  narrow: /^[1234]/i,
+  abbreviated: /^T[1234]/i,
+  wide: /^[1234](º)? trimestre/i
+};
+const parseQuarterPatterns$1 = {
+  any: [/1/i, /2/i, /3/i, /4/i]
+};
+const matchMonthPatterns$1 = {
+  narrow: /^[efmajsond]/i,
+  abbreviated: /^(ene|feb|mar|abr|may|jun|jul|ago|sep|oct|nov|dic)/i,
+  wide: /^(enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)/i
+};
+const parseMonthPatterns$1 = {
+  narrow: [
+    /^e/i,
+    /^f/i,
+    /^m/i,
+    /^a/i,
+    /^m/i,
+    /^j/i,
+    /^j/i,
+    /^a/i,
+    /^s/i,
+    /^o/i,
+    /^n/i,
+    /^d/i
+  ],
+  any: [
+    /^en/i,
+    /^feb/i,
+    /^mar/i,
+    /^abr/i,
+    /^may/i,
+    /^jun/i,
+    /^jul/i,
+    /^ago/i,
+    /^sep/i,
+    /^oct/i,
+    /^nov/i,
+    /^dic/i
+  ]
+};
+const matchDayPatterns$1 = {
+  narrow: /^[dlmjvs]/i,
+  short: /^(do|lu|ma|mi|ju|vi|s[áa])/i,
+  abbreviated: /^(dom|lun|mar|mi[ée]|jue|vie|s[áa]b)/i,
+  wide: /^(domingo|lunes|martes|mi[ée]rcoles|jueves|viernes|s[áa]bado)/i
+};
+const parseDayPatterns$1 = {
+  narrow: [/^d/i, /^l/i, /^m/i, /^m/i, /^j/i, /^v/i, /^s/i],
+  any: [/^do/i, /^lu/i, /^ma/i, /^mi/i, /^ju/i, /^vi/i, /^sa/i]
+};
+const matchDayPeriodPatterns$1 = {
+  narrow: /^(a|p|mn|md|(de la|a las) (mañana|tarde|noche))/i,
+  any: /^([ap]\.?\s?m\.?|medianoche|mediodia|(de la|a las) (mañana|tarde|noche))/i
+};
+const parseDayPeriodPatterns$1 = {
+  any: {
+    am: /^a/i,
+    pm: /^p/i,
+    midnight: /^mn/i,
+    noon: /^md/i,
+    morning: /mañana/i,
+    afternoon: /tarde/i,
+    evening: /tarde/i,
+    night: /noche/i
+  }
+};
+const match$1 = {
+  ordinalNumber: buildMatchPatternFn({
+    matchPattern: matchOrdinalNumberPattern$1,
+    parsePattern: parseOrdinalNumberPattern$1,
+    valueCallback: function(value) {
+      return parseInt(value, 10);
+    }
+  }),
+  era: buildMatchFn({
+    matchPatterns: matchEraPatterns$1,
+    defaultMatchWidth: "wide",
+    parsePatterns: parseEraPatterns$1,
+    defaultParseWidth: "any"
+  }),
+  quarter: buildMatchFn({
+    matchPatterns: matchQuarterPatterns$1,
+    defaultMatchWidth: "wide",
+    parsePatterns: parseQuarterPatterns$1,
+    defaultParseWidth: "any",
+    valueCallback: (index) => index + 1
+  }),
+  month: buildMatchFn({
+    matchPatterns: matchMonthPatterns$1,
+    defaultMatchWidth: "wide",
+    parsePatterns: parseMonthPatterns$1,
+    defaultParseWidth: "any"
+  }),
+  day: buildMatchFn({
+    matchPatterns: matchDayPatterns$1,
+    defaultMatchWidth: "wide",
+    parsePatterns: parseDayPatterns$1,
+    defaultParseWidth: "any"
+  }),
+  dayPeriod: buildMatchFn({
+    matchPatterns: matchDayPeriodPatterns$1,
+    defaultMatchWidth: "any",
+    parsePatterns: parseDayPeriodPatterns$1,
+    defaultParseWidth: "any"
+  })
+};
+const es = {
+  code: "es",
+  formatDistance: formatDistance$1,
+  formatLong: formatLong$1,
+  formatRelative: formatRelative$1,
+  localize: localize$1,
+  match: match$1,
+  options: {
+    weekStartsOn: 1,
+    firstWeekContainsDate: 1
+  }
+};
+function declension(scheme, count) {
+  if (scheme.one !== void 0 && count === 1) {
+    return scheme.one;
+  }
+  const rem10 = count % 10;
+  const rem100 = count % 100;
+  if (rem10 === 1 && rem100 !== 11) {
+    return scheme.singularNominative.replace("{{count}}", String(count));
+  } else if (rem10 >= 2 && rem10 <= 4 && (rem100 < 10 || rem100 > 20)) {
+    return scheme.singularGenitive.replace("{{count}}", String(count));
+  } else {
+    return scheme.pluralGenitive.replace("{{count}}", String(count));
+  }
+}
+function buildLocalizeTokenFn(scheme) {
+  return (count, options) => {
+    if (options == null ? void 0 : options.addSuffix) {
+      if (options.comparison && options.comparison > 0) {
+        if (scheme.future) {
+          return declension(scheme.future, count);
+        } else {
+          return "через " + declension(scheme.regular, count);
+        }
+      } else {
+        if (scheme.past) {
+          return declension(scheme.past, count);
+        } else {
+          return declension(scheme.regular, count) + " назад";
+        }
+      }
+    } else {
+      return declension(scheme.regular, count);
+    }
+  };
+}
+const formatDistanceLocale = {
+  lessThanXSeconds: buildLocalizeTokenFn({
+    regular: {
+      one: "меньше секунды",
+      singularNominative: "меньше {{count}} секунды",
+      singularGenitive: "меньше {{count}} секунд",
+      pluralGenitive: "меньше {{count}} секунд"
+    },
+    future: {
+      one: "меньше, чем через секунду",
+      singularNominative: "меньше, чем через {{count}} секунду",
+      singularGenitive: "меньше, чем через {{count}} секунды",
+      pluralGenitive: "меньше, чем через {{count}} секунд"
+    }
+  }),
+  xSeconds: buildLocalizeTokenFn({
+    regular: {
+      singularNominative: "{{count}} секунда",
+      singularGenitive: "{{count}} секунды",
+      pluralGenitive: "{{count}} секунд"
+    },
+    past: {
+      singularNominative: "{{count}} секунду назад",
+      singularGenitive: "{{count}} секунды назад",
+      pluralGenitive: "{{count}} секунд назад"
+    },
+    future: {
+      singularNominative: "через {{count}} секунду",
+      singularGenitive: "через {{count}} секунды",
+      pluralGenitive: "через {{count}} секунд"
+    }
+  }),
+  halfAMinute: (_count, options) => {
+    if (options == null ? void 0 : options.addSuffix) {
+      if (options.comparison && options.comparison > 0) {
+        return "через полминуты";
+      } else {
+        return "полминуты назад";
+      }
+    }
+    return "полминуты";
+  },
+  lessThanXMinutes: buildLocalizeTokenFn({
+    regular: {
+      one: "меньше минуты",
+      singularNominative: "меньше {{count}} минуты",
+      singularGenitive: "меньше {{count}} минут",
+      pluralGenitive: "меньше {{count}} минут"
+    },
+    future: {
+      one: "меньше, чем через минуту",
+      singularNominative: "меньше, чем через {{count}} минуту",
+      singularGenitive: "меньше, чем через {{count}} минуты",
+      pluralGenitive: "меньше, чем через {{count}} минут"
+    }
+  }),
+  xMinutes: buildLocalizeTokenFn({
+    regular: {
+      singularNominative: "{{count}} минута",
+      singularGenitive: "{{count}} минуты",
+      pluralGenitive: "{{count}} минут"
+    },
+    past: {
+      singularNominative: "{{count}} минуту назад",
+      singularGenitive: "{{count}} минуты назад",
+      pluralGenitive: "{{count}} минут назад"
+    },
+    future: {
+      singularNominative: "через {{count}} минуту",
+      singularGenitive: "через {{count}} минуты",
+      pluralGenitive: "через {{count}} минут"
+    }
+  }),
+  aboutXHours: buildLocalizeTokenFn({
+    regular: {
+      singularNominative: "около {{count}} часа",
+      singularGenitive: "около {{count}} часов",
+      pluralGenitive: "около {{count}} часов"
+    },
+    future: {
+      singularNominative: "приблизительно через {{count}} час",
+      singularGenitive: "приблизительно через {{count}} часа",
+      pluralGenitive: "приблизительно через {{count}} часов"
+    }
+  }),
+  xHours: buildLocalizeTokenFn({
+    regular: {
+      singularNominative: "{{count}} час",
+      singularGenitive: "{{count}} часа",
+      pluralGenitive: "{{count}} часов"
+    }
+  }),
+  xDays: buildLocalizeTokenFn({
+    regular: {
+      singularNominative: "{{count}} день",
+      singularGenitive: "{{count}} дня",
+      pluralGenitive: "{{count}} дней"
+    }
+  }),
+  aboutXWeeks: buildLocalizeTokenFn({
+    regular: {
+      singularNominative: "около {{count}} недели",
+      singularGenitive: "около {{count}} недель",
+      pluralGenitive: "около {{count}} недель"
+    },
+    future: {
+      singularNominative: "приблизительно через {{count}} неделю",
+      singularGenitive: "приблизительно через {{count}} недели",
+      pluralGenitive: "приблизительно через {{count}} недель"
+    }
+  }),
+  xWeeks: buildLocalizeTokenFn({
+    regular: {
+      singularNominative: "{{count}} неделя",
+      singularGenitive: "{{count}} недели",
+      pluralGenitive: "{{count}} недель"
+    }
+  }),
+  aboutXMonths: buildLocalizeTokenFn({
+    regular: {
+      singularNominative: "около {{count}} месяца",
+      singularGenitive: "около {{count}} месяцев",
+      pluralGenitive: "около {{count}} месяцев"
+    },
+    future: {
+      singularNominative: "приблизительно через {{count}} месяц",
+      singularGenitive: "приблизительно через {{count}} месяца",
+      pluralGenitive: "приблизительно через {{count}} месяцев"
+    }
+  }),
+  xMonths: buildLocalizeTokenFn({
+    regular: {
+      singularNominative: "{{count}} месяц",
+      singularGenitive: "{{count}} месяца",
+      pluralGenitive: "{{count}} месяцев"
+    }
+  }),
+  aboutXYears: buildLocalizeTokenFn({
+    regular: {
+      singularNominative: "около {{count}} года",
+      singularGenitive: "около {{count}} лет",
+      pluralGenitive: "около {{count}} лет"
+    },
+    future: {
+      singularNominative: "приблизительно через {{count}} год",
+      singularGenitive: "приблизительно через {{count}} года",
+      pluralGenitive: "приблизительно через {{count}} лет"
+    }
+  }),
+  xYears: buildLocalizeTokenFn({
+    regular: {
+      singularNominative: "{{count}} год",
+      singularGenitive: "{{count}} года",
+      pluralGenitive: "{{count}} лет"
+    }
+  }),
+  overXYears: buildLocalizeTokenFn({
+    regular: {
+      singularNominative: "больше {{count}} года",
+      singularGenitive: "больше {{count}} лет",
+      pluralGenitive: "больше {{count}} лет"
+    },
+    future: {
+      singularNominative: "больше, чем через {{count}} год",
+      singularGenitive: "больше, чем через {{count}} года",
+      pluralGenitive: "больше, чем через {{count}} лет"
+    }
+  }),
+  almostXYears: buildLocalizeTokenFn({
+    regular: {
+      singularNominative: "почти {{count}} год",
+      singularGenitive: "почти {{count}} года",
+      pluralGenitive: "почти {{count}} лет"
+    },
+    future: {
+      singularNominative: "почти через {{count}} год",
+      singularGenitive: "почти через {{count}} года",
+      pluralGenitive: "почти через {{count}} лет"
+    }
+  })
+};
+const formatDistance = (token, count, options) => {
+  return formatDistanceLocale[token](count, options);
+};
+const dateFormats = {
+  full: "EEEE, d MMMM y 'г.'",
+  long: "d MMMM y 'г.'",
+  medium: "d MMM y 'г.'",
+  short: "dd.MM.y"
+};
+const timeFormats = {
+  full: "H:mm:ss zzzz",
+  long: "H:mm:ss z",
+  medium: "H:mm:ss",
+  short: "H:mm"
+};
+const dateTimeFormats = {
+  any: "{{date}}, {{time}}"
+};
+const formatLong = {
+  date: buildFormatLongFn({
+    formats: dateFormats,
+    defaultWidth: "full"
+  }),
+  time: buildFormatLongFn({
+    formats: timeFormats,
+    defaultWidth: "full"
+  }),
+  dateTime: buildFormatLongFn({
+    formats: dateTimeFormats,
+    defaultWidth: "any"
+  })
+};
+const accusativeWeekdays = [
+  "воскресенье",
+  "понедельник",
+  "вторник",
+  "среду",
+  "четверг",
+  "пятницу",
+  "субботу"
+];
+function lastWeek(day) {
+  const weekday = accusativeWeekdays[day];
+  switch (day) {
+    case 0:
+      return "'в прошлое " + weekday + " в' p";
+    case 1:
+    case 2:
+    case 4:
+      return "'в прошлый " + weekday + " в' p";
+    case 3:
+    case 5:
+    case 6:
+      return "'в прошлую " + weekday + " в' p";
+  }
+}
+function thisWeek(day) {
+  const weekday = accusativeWeekdays[day];
+  if (day === 2) {
+    return "'во " + weekday + " в' p";
+  } else {
+    return "'в " + weekday + " в' p";
+  }
+}
+function nextWeek(day) {
+  const weekday = accusativeWeekdays[day];
+  switch (day) {
+    case 0:
+      return "'в следующее " + weekday + " в' p";
+    case 1:
+    case 2:
+    case 4:
+      return "'в следующий " + weekday + " в' p";
+    case 3:
+    case 5:
+    case 6:
+      return "'в следующую " + weekday + " в' p";
+  }
+}
+const formatRelativeLocale = {
+  lastWeek: (date, baseDate, options) => {
+    const day = date.getDay();
+    if (isSameWeek(date, baseDate, options)) {
+      return thisWeek(day);
+    } else {
+      return lastWeek(day);
+    }
+  },
+  yesterday: "'вчера в' p",
+  today: "'сегодня в' p",
+  tomorrow: "'завтра в' p",
+  nextWeek: (date, baseDate, options) => {
+    const day = date.getDay();
+    if (isSameWeek(date, baseDate, options)) {
+      return thisWeek(day);
+    } else {
+      return nextWeek(day);
+    }
+  },
+  other: "P"
+};
+const formatRelative = (token, date, baseDate, options) => {
+  const format = formatRelativeLocale[token];
+  if (typeof format === "function") {
+    return format(date, baseDate, options);
+  }
+  return format;
+};
+const eraValues = {
+  narrow: ["до н.э.", "н.э."],
+  abbreviated: ["до н. э.", "н. э."],
+  wide: ["до нашей эры", "нашей эры"]
+};
+const quarterValues = {
+  narrow: ["1", "2", "3", "4"],
+  abbreviated: ["1-й кв.", "2-й кв.", "3-й кв.", "4-й кв."],
+  wide: ["1-й квартал", "2-й квартал", "3-й квартал", "4-й квартал"]
+};
+const monthValues = {
+  narrow: ["Я", "Ф", "М", "А", "М", "И", "И", "А", "С", "О", "Н", "Д"],
+  abbreviated: [
+    "янв.",
+    "фев.",
+    "март",
+    "апр.",
+    "май",
+    "июнь",
+    "июль",
+    "авг.",
+    "сент.",
+    "окт.",
+    "нояб.",
+    "дек."
+  ],
+  wide: [
+    "январь",
+    "февраль",
+    "март",
+    "апрель",
+    "май",
+    "июнь",
+    "июль",
+    "август",
+    "сентябрь",
+    "октябрь",
+    "ноябрь",
+    "декабрь"
+  ]
+};
+const formattingMonthValues = {
+  narrow: ["Я", "Ф", "М", "А", "М", "И", "И", "А", "С", "О", "Н", "Д"],
+  abbreviated: [
+    "янв.",
+    "фев.",
+    "мар.",
+    "апр.",
+    "мая",
+    "июн.",
+    "июл.",
+    "авг.",
+    "сент.",
+    "окт.",
+    "нояб.",
+    "дек."
+  ],
+  wide: [
+    "января",
+    "февраля",
+    "марта",
+    "апреля",
+    "мая",
+    "июня",
+    "июля",
+    "августа",
+    "сентября",
+    "октября",
+    "ноября",
+    "декабря"
+  ]
+};
+const dayValues = {
+  narrow: ["В", "П", "В", "С", "Ч", "П", "С"],
+  short: ["вс", "пн", "вт", "ср", "чт", "пт", "сб"],
+  abbreviated: ["вск", "пнд", "втр", "срд", "чтв", "птн", "суб"],
+  wide: [
+    "воскресенье",
+    "понедельник",
+    "вторник",
+    "среда",
+    "четверг",
+    "пятница",
+    "суббота"
+  ]
+};
+const dayPeriodValues = {
+  narrow: {
+    am: "ДП",
+    pm: "ПП",
+    midnight: "полн.",
+    noon: "полд.",
+    morning: "утро",
+    afternoon: "день",
+    evening: "веч.",
+    night: "ночь"
+  },
+  abbreviated: {
+    am: "ДП",
+    pm: "ПП",
+    midnight: "полн.",
+    noon: "полд.",
+    morning: "утро",
+    afternoon: "день",
+    evening: "веч.",
+    night: "ночь"
+  },
+  wide: {
+    am: "ДП",
+    pm: "ПП",
+    midnight: "полночь",
+    noon: "полдень",
+    morning: "утро",
+    afternoon: "день",
+    evening: "вечер",
+    night: "ночь"
+  }
+};
+const formattingDayPeriodValues = {
+  narrow: {
+    am: "ДП",
+    pm: "ПП",
+    midnight: "полн.",
+    noon: "полд.",
+    morning: "утра",
+    afternoon: "дня",
+    evening: "веч.",
+    night: "ночи"
+  },
+  abbreviated: {
+    am: "ДП",
+    pm: "ПП",
+    midnight: "полн.",
+    noon: "полд.",
+    morning: "утра",
+    afternoon: "дня",
+    evening: "веч.",
+    night: "ночи"
+  },
+  wide: {
+    am: "ДП",
+    pm: "ПП",
+    midnight: "полночь",
+    noon: "полдень",
+    morning: "утра",
+    afternoon: "дня",
+    evening: "вечера",
+    night: "ночи"
+  }
+};
+const ordinalNumber = (dirtyNumber, options) => {
+  const number = Number(dirtyNumber);
+  const unit = options == null ? void 0 : options.unit;
+  let suffix;
+  if (unit === "date") {
+    suffix = "-е";
+  } else if (unit === "week" || unit === "minute" || unit === "second") {
+    suffix = "-я";
+  } else {
+    suffix = "-й";
+  }
+  return number + suffix;
+};
+const localize = {
+  ordinalNumber,
+  era: buildLocalizeFn({
+    values: eraValues,
+    defaultWidth: "wide"
+  }),
+  quarter: buildLocalizeFn({
+    values: quarterValues,
+    defaultWidth: "wide",
+    argumentCallback: (quarter) => quarter - 1
+  }),
+  month: buildLocalizeFn({
+    values: monthValues,
+    defaultWidth: "wide",
+    formattingValues: formattingMonthValues,
+    defaultFormattingWidth: "wide"
+  }),
+  day: buildLocalizeFn({
+    values: dayValues,
+    defaultWidth: "wide"
+  }),
+  dayPeriod: buildLocalizeFn({
+    values: dayPeriodValues,
+    defaultWidth: "any",
+    formattingValues: formattingDayPeriodValues,
+    defaultFormattingWidth: "wide"
+  })
+};
+const matchOrdinalNumberPattern = /^(\d+)(-?(е|я|й|ое|ье|ая|ья|ый|ой|ий|ый))?/i;
+const parseOrdinalNumberPattern = /\d+/i;
+const matchEraPatterns = {
+  narrow: /^((до )?н\.?\s?э\.?)/i,
+  abbreviated: /^((до )?н\.?\s?э\.?)/i,
+  wide: /^(до нашей эры|нашей эры|наша эра)/i
+};
+const parseEraPatterns = {
+  any: [/^д/i, /^н/i]
+};
+const matchQuarterPatterns = {
+  narrow: /^[1234]/i,
+  abbreviated: /^[1234](-?[ыои]?й?)? кв.?/i,
+  wide: /^[1234](-?[ыои]?й?)? квартал/i
+};
+const parseQuarterPatterns = {
+  any: [/1/i, /2/i, /3/i, /4/i]
+};
+const matchMonthPatterns = {
+  narrow: /^[яфмаисонд]/i,
+  abbreviated: /^(янв|фев|март?|апр|ма[йя]|июн[ья]?|июл[ья]?|авг|сент?|окт|нояб?|дек)\.?/i,
+  wide: /^(январ[ья]|феврал[ья]|марта?|апрел[ья]|ма[йя]|июн[ья]|июл[ья]|августа?|сентябр[ья]|октябр[ья]|октябр[ья]|ноябр[ья]|декабр[ья])/i
+};
+const parseMonthPatterns = {
+  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
+  ]
+};
+const matchDayPatterns = {
+  narrow: /^[впсч]/i,
+  short: /^(вс|во|пн|по|вт|ср|чт|че|пт|пя|сб|су)\.?/i,
+  abbreviated: /^(вск|вос|пнд|пон|втр|вто|срд|сре|чтв|чет|птн|пят|суб).?/i,
+  wide: /^(воскресень[ея]|понедельника?|вторника?|сред[аы]|четверга?|пятниц[аы]|суббот[аы])/i
+};
+const parseDayPatterns = {
+  narrow: [/^в/i, /^п/i, /^в/i, /^с/i, /^ч/i, /^п/i, /^с/i],
+  any: [/^в[ос]/i, /^п[он]/i, /^в/i, /^ср/i, /^ч/i, /^п[ят]/i, /^с[уб]/i]
+};
+const matchDayPeriodPatterns = {
+  narrow: /^([дп]п|полн\.?|полд\.?|утр[оа]|день|дня|веч\.?|ноч[ьи])/i,
+  abbreviated: /^([дп]п|полн\.?|полд\.?|утр[оа]|день|дня|веч\.?|ноч[ьи])/i,
+  wide: /^([дп]п|полночь|полдень|утр[оа]|день|дня|вечера?|ноч[ьи])/i
+};
+const parseDayPeriodPatterns = {
+  any: {
+    am: /^дп/i,
+    pm: /^пп/i,
+    midnight: /^полн/i,
+    noon: /^полд/i,
+    morning: /^у/i,
+    afternoon: /^д[ен]/i,
+    evening: /^в/i,
+    night: /^н/i
+  }
+};
+const match = {
+  ordinalNumber: buildMatchPatternFn({
+    matchPattern: matchOrdinalNumberPattern,
+    parsePattern: parseOrdinalNumberPattern,
+    valueCallback: (value) => parseInt(value, 10)
+  }),
+  era: buildMatchFn({
+    matchPatterns: matchEraPatterns,
+    defaultMatchWidth: "wide",
+    parsePatterns: parseEraPatterns,
+    defaultParseWidth: "any"
+  }),
+  quarter: buildMatchFn({
+    matchPatterns: matchQuarterPatterns,
+    defaultMatchWidth: "wide",
+    parsePatterns: parseQuarterPatterns,
+    defaultParseWidth: "any",
+    valueCallback: (index) => 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: "wide",
+    parsePatterns: parseDayPeriodPatterns,
+    defaultParseWidth: "any"
+  })
+};
+const ru = {
+  code: "ru",
+  formatDistance,
+  formatLong,
+  formatRelative,
+  localize,
+  match,
+  options: {
+    weekStartsOn: 1,
+    firstWeekContainsDate: 1
+  }
+};
+const formatDateLat = (date) => dateFns.format(date, "dd/MM/yyyy", { locale: enGB });
+const formatDateRu = (date) => dateFns.format(date, "dd.MM.yyyy", { locale: ru });
+const formatTime = (date) => dateFns.format(date, "HH:mm", { locale: enGB });
+const formatDate = (date, locale = void 0) => {
+  return (locale ?? detectLocale()) === "ru-RU" ? formatDateRu(date) : formatDateLat(date);
+};
+const formatDateTime = (date, locale = void 0) => dateFns.format(date, "Pp", {
+  locale: {
+    "en-GB": enGB,
+    "es-ES": es,
+    "ru-RU": ru
+  }[locale ?? detectLocale()] ?? enGB
+});
+function detectLocale() {
+  var _a, _b, _c, _d;
+  const instance = vue.getCurrentInstance();
+  const i18n = (_d = (_c = (_b = (_a = instance == null ? void 0 : instance.appContext) == null ? void 0 : _a.app) == null ? void 0 : _b.config) == null ? void 0 : _c.globalProperties) == null ? void 0 : _d.$i18n;
+  if (i18n) {
+    try {
+      const locale = (typeof i18n.locale === "object" ? i18n.locale.value : i18n.locale) ?? "en-GB";
+      if (locale.startsWith("en")) return "en-GB";
+      if (locale.startsWith("es")) return "es-ES";
+      if (locale.startsWith("ru")) return "ru-RU";
+    } catch (error) {
+      console.warn("Error detecting locale:", error);
+    }
+  }
+  return "en-GB";
+}
 exports.ImageWorkersKey = ImageWorkersKey;
 exports.UiAvatar = UiAvatar;
 exports.UiAvatarList = UiAvatarList;
@@ -216,4 +1842,7 @@ exports.UiTransition = UiTransition;
 exports.UiTransitionType = UiTransitionType;
 exports.UiYandexMap = UiYandexMap;
 exports.UiYandexMapType = UiYandexMapType;
+exports.formatDate = formatDate;
+exports.formatDateTime = formatDateTime;
+exports.formatTime = formatTime;
 exports.usePreview = usePreview;