urfu-ui-kit-react 2.1.3 → 2.1.4

package/dist/vendor/date-fns/locale/ru/_lib/localize.js

@@ -0,0 +1,177 @@
+import { buildLocalizeFn$u as n } from "../../_lib/buildLocalizeFn.js";
+const r = {
+  narrow: ["до н.э.", "н.э."],
+  abbreviated: ["до н. э.", "н. э."],
+  wide: ["до нашей эры", "нашей эры"]
+}, d = {
+  narrow: ["1", "2", "3", "4"],
+  abbreviated: ["1-й кв.", "2-й кв.", "3-й кв.", "4-й кв."],
+  wide: ["1-й квартал", "2-й квартал", "3-й квартал", "4-й квартал"]
+}, m = {
+  narrow: ["Я", "Ф", "М", "А", "М", "И", "И", "А", "С", "О", "Н", "Д"],
+  abbreviated: [
+    "янв.",
+    "фев.",
+    "март",
+    "апр.",
+    "май",
+    "июнь",
+    "июль",
+    "авг.",
+    "сент.",
+    "окт.",
+    "нояб.",
+    "дек."
+  ],
+  wide: [
+    "январь",
+    "февраль",
+    "март",
+    "апрель",
+    "май",
+    "июнь",
+    "июль",
+    "август",
+    "сентябрь",
+    "октябрь",
+    "ноябрь",
+    "декабрь"
+  ]
+}, u = {
+  narrow: ["Я", "Ф", "М", "А", "М", "И", "И", "А", "С", "О", "Н", "Д"],
+  abbreviated: [
+    "янв.",
+    "фев.",
+    "мар.",
+    "апр.",
+    "мая",
+    "июн.",
+    "июл.",
+    "авг.",
+    "сент.",
+    "окт.",
+    "нояб.",
+    "дек."
+  ],
+  wide: [
+    "января",
+    "февраля",
+    "марта",
+    "апреля",
+    "мая",
+    "июня",
+    "июля",
+    "августа",
+    "сентября",
+    "октября",
+    "ноября",
+    "декабря"
+  ]
+}, g = {
+  narrow: ["В", "П", "В", "С", "Ч", "П", "С"],
+  short: ["вс", "пн", "вт", "ср", "чт", "пт", "сб"],
+  abbreviated: ["вск", "пнд", "втр", "срд", "чтв", "птн", "суб"],
+  wide: [
+    "воскресенье",
+    "понедельник",
+    "вторник",
+    "среда",
+    "четверг",
+    "пятница",
+    "суббота"
+  ]
+}, l = {
+  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: "ночь"
+  }
+}, s = {
+  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: "ночи"
+  }
+}, h = (i, t) => {
+  const o = Number(i), e = t == null ? void 0 : t.unit;
+  let a;
+  return e === "date" ? a = "-е" : e === "week" || e === "minute" || e === "second" ? a = "-я" : a = "-й", o + a;
+}, w = {
+  ordinalNumber: h,
+  era: n({
+    values: r,
+    defaultWidth: "wide"
+  }),
+  quarter: n({
+    values: d,
+    defaultWidth: "wide",
+    argumentCallback: (i) => i - 1
+  }),
+  month: n({
+    values: m,
+    defaultWidth: "wide",
+    formattingValues: u,
+    defaultFormattingWidth: "wide"
+  }),
+  day: n({
+    values: g,
+    defaultWidth: "wide"
+  }),
+  dayPeriod: n({
+    values: l,
+    defaultWidth: "any",
+    formattingValues: s,
+    defaultFormattingWidth: "wide"
+  })
+};
+export { w as localize$u };

package/dist/vendor/date-fns/locale/ru/_lib/match.js

@@ -0,0 +1,109 @@
+import { buildMatchFn$u as a } from "../../_lib/buildMatchFn.js";
+import { buildMatchPatternFn$u as i } from "../../_lib/buildMatchPatternFn.js";
+const e = /^(\d+)(-?(е|я|й|ое|ье|ая|ья|ый|ой|ий|ый))?/i, r = /\d+/i, n = {
+  narrow: /^((до )?н\.?\s?э\.?)/i,
+  abbreviated: /^((до )?н\.?\s?э\.?)/i,
+  wide: /^(до нашей эры|нашей эры|наша эра)/i
+}, s = {
+  any: [/^д/i, /^н/i]
+}, d = {
+  narrow: /^[1234]/i,
+  abbreviated: /^[1234](-?[ыои]?й?)? кв.?/i,
+  wide: /^[1234](-?[ыои]?й?)? квартал/i
+}, o = {
+  any: [/1/i, /2/i, /3/i, /4/i]
+}, h = {
+  narrow: /^[яфмаисонд]/i,
+  abbreviated: /^(янв|фев|март?|апр|ма[йя]|июн[ья]?|июл[ья]?|авг|сент?|окт|нояб?|дек)\.?/i,
+  wide: /^(январ[ья]|феврал[ья]|марта?|апрел[ья]|ма[йя]|июн[ья]|июл[ья]|августа?|сентябр[ья]|октябр[ья]|октябр[ья]|ноябр[ья]|декабр[ья])/i
+}, c = {
+  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
+  ]
+}, P = {
+  narrow: /^[впсч]/i,
+  short: /^(вс|во|пн|по|вт|ср|чт|че|пт|пя|сб|су)\.?/i,
+  abbreviated: /^(вск|вос|пнд|пон|втр|вто|срд|сре|чтв|чет|птн|пят|суб).?/i,
+  wide: /^(воскресень[ея]|понедельника?|вторника?|сред[аы]|четверга?|пятниц[аы]|суббот[аы])/i
+}, m = {
+  narrow: [/^в/i, /^п/i, /^в/i, /^с/i, /^ч/i, /^п/i, /^с/i],
+  any: [/^в[ос]/i, /^п[он]/i, /^в/i, /^ср/i, /^ч/i, /^п[ят]/i, /^с[уб]/i]
+}, l = {
+  narrow: /^([дп]п|полн\.?|полд\.?|утр[оа]|день|дня|веч\.?|ноч[ьи])/i,
+  abbreviated: /^([дп]п|полн\.?|полд\.?|утр[оа]|день|дня|веч\.?|ноч[ьи])/i,
+  wide: /^([дп]п|полночь|полдень|утр[оа]|день|дня|вечера?|ноч[ьи])/i
+}, u = {
+  any: {
+    am: /^дп/i,
+    pm: /^пп/i,
+    midnight: /^полн/i,
+    noon: /^полд/i,
+    morning: /^у/i,
+    afternoon: /^д[ен]/i,
+    evening: /^в/i,
+    night: /^н/i
+  }
+}, w = {
+  ordinalNumber: i({
+    matchPattern: e,
+    parsePattern: r,
+    valueCallback: (t) => parseInt(t, 10)
+  }),
+  era: a({
+    matchPatterns: n,
+    defaultMatchWidth: "wide",
+    parsePatterns: s,
+    defaultParseWidth: "any"
+  }),
+  quarter: a({
+    matchPatterns: d,
+    defaultMatchWidth: "wide",
+    parsePatterns: o,
+    defaultParseWidth: "any",
+    valueCallback: (t) => t + 1
+  }),
+  month: a({
+    matchPatterns: h,
+    defaultMatchWidth: "wide",
+    parsePatterns: c,
+    defaultParseWidth: "any"
+  }),
+  day: a({
+    matchPatterns: P,
+    defaultMatchWidth: "wide",
+    parsePatterns: m,
+    defaultParseWidth: "any"
+  }),
+  dayPeriod: a({
+    matchPatterns: l,
+    defaultMatchWidth: "wide",
+    parsePatterns: u,
+    defaultParseWidth: "any"
+  })
+};
+export { w as match$u };

package/dist/vendor/date-fns/locale/ru.js

@@ -0,0 +1,18 @@
+import { formatDistance$u as o } from "./ru/_lib/formatDistance.js";
+import { formatLong$u as t } from "./ru/_lib/formatLong.js";
+import { formatRelative$u as r } from "./ru/_lib/formatRelative.js";
+import { localize$u as m } from "./ru/_lib/localize.js";
+import { match$u as a } from "./ru/_lib/match.js";
+const p = {
+  code: "ru",
+  formatDistance: o,
+  formatLong: t,
+  formatRelative: r,
+  localize: m,
+  match: a,
+  options: {
+    weekStartsOn: 1,
+    firstWeekContainsDate: 1
+  }
+};
+export { p as ru$u };

package/dist/vendor/date-fns/max.js

@@ -0,0 +1,9 @@
+import { toDate$u as o } from "./toDate.js";
+function u(n) {
+  let t;
+  return n.forEach(function(r) {
+    const e = o(r);
+    (t === void 0 || t < e || isNaN(Number(e))) && (t = e);
+  }), t || /* @__PURE__ */ new Date(NaN);
+}
+export { u as max$u };

package/dist/vendor/date-fns/min.js

@@ -0,0 +1,9 @@
+import { toDate$u as a } from "./toDate.js";
+function i(o) {
+  let t;
+  return o.forEach((r) => {
+    const e = a(r);
+    (!t || t > e || isNaN(+e)) && (t = e);
+  }), t || /* @__PURE__ */ new Date(NaN);
+}
+export { i as min$u };

package/dist/vendor/date-fns/parse/_lib/Parser.js

@@ -0,0 +1,20 @@
+import { ValueSetter$u as u } from "./Setter.js";
+class n {
+  run(r, e, s, i) {
+    const t = this.parse(r, e, s, i);
+    return t ? {
+      setter: new u(
+        t.value,
+        this.validate,
+        this.set,
+        this.priority,
+        this.subPriority
+      ),
+      rest: t.rest
+    } : null;
+  }
+  validate(r, e, s) {
+    return !0;
+  }
+}
+export { n as Parser$u };

package/dist/vendor/date-fns/parse/_lib/Setter.js

@@ -0,0 +1,36 @@
+var l = Object.defineProperty;
+var n = (r, t, e) => t in r ? l(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
+var i = (r, t, e) => n(r, typeof t != "symbol" ? t + "" : t, e);
+import { transpose$u as c } from "../../transpose.js";
+import { constructFrom$u as h } from "../../constructFrom.js";
+const m = 10;
+class u {
+  constructor() {
+    i(this, "subPriority", 0);
+  }
+  validate(t, e) {
+    return !0;
+  }
+}
+class I extends u {
+  constructor(t, e, s, o, a) {
+    super(), this.value = t, this.validateValue = e, this.setValue = s, this.priority = o, a && (this.subPriority = a);
+  }
+  validate(t, e) {
+    return this.validateValue(t, this.value, e);
+  }
+  set(t, e, s) {
+    return this.setValue(t, e, this.value, s);
+  }
+}
+class S extends u {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", m);
+    i(this, "subPriority", -1);
+  }
+  set(e, s) {
+    return s.timestampIsSet ? e : h(e, c(e, Date));
+  }
+}
+export { S as DateToSystemTimezoneSetter$u, u as Setter$u, I as ValueSetter$u };

package/dist/vendor/date-fns/parse/_lib/constants.js

@@ -0,0 +1,46 @@
+const d = {
+  month: /^(1[0-2]|0?\d)/,
+  // 0 to 12
+  date: /^(3[0-1]|[0-2]?\d)/,
+  // 0 to 31
+  dayOfYear: /^(36[0-6]|3[0-5]\d|[0-2]?\d?\d)/,
+  // 0 to 366
+  week: /^(5[0-3]|[0-4]?\d)/,
+  // 0 to 53
+  hour23h: /^(2[0-3]|[0-1]?\d)/,
+  // 0 to 23
+  hour24h: /^(2[0-4]|[0-1]?\d)/,
+  // 0 to 24
+  hour11h: /^(1[0-1]|0?\d)/,
+  // 0 to 11
+  hour12h: /^(1[0-2]|0?\d)/,
+  // 0 to 12
+  minute: /^[0-5]?\d/,
+  // 0 to 59
+  second: /^[0-5]?\d/,
+  // 0 to 59
+  singleDigit: /^\d/,
+  // 0 to 9
+  twoDigits: /^\d{1,2}/,
+  // 0 to 99
+  threeDigits: /^\d{1,3}/,
+  // 0 to 999
+  fourDigits: /^\d{1,4}/,
+  // 0 to 9999
+  anyDigitsSigned: /^-?\d+/,
+  singleDigitSigned: /^-?\d/,
+  // 0 to 9, -0 to -9
+  twoDigitsSigned: /^-?\d{1,2}/,
+  // 0 to 99, -0 to -99
+  threeDigitsSigned: /^-?\d{1,3}/,
+  // 0 to 999, -0 to -999
+  fourDigitsSigned: /^-?\d{1,4}/
+  // 0 to 9999, -0 to -9999
+}, i = {
+  basicOptionalMinutes: /^([+-])(\d{2})(\d{2})?|Z/,
+  basic: /^([+-])(\d{2})(\d{2})|Z/,
+  basicOptionalSeconds: /^([+-])(\d{2})(\d{2})((\d{2}))?|Z/,
+  extended: /^([+-])(\d{2}):(\d{2})|Z/,
+  extendedOptionalSeconds: /^([+-])(\d{2}):(\d{2})(:(\d{2}))?|Z/
+};
+export { d as numericPatterns$u, i as timezonePatterns$u };

package/dist/vendor/date-fns/parse/_lib/parsers/AMPMMidnightParser.js

@@ -0,0 +1,46 @@
+var b = Object.defineProperty;
+var d = (t, o, r) => o in t ? b(t, o, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[o] = r;
+var i = (t, o, r) => d(t, typeof o != "symbol" ? o + "" : o, r);
+import { Parser$u as n } from "../Parser.js";
+import { dayPeriodEnumToHours$u as s } from "../utils.js";
+class c extends n {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 80);
+    i(this, "incompatibleTokens", ["a", "B", "H", "k", "t", "T"]);
+  }
+  parse(r, a, e) {
+    switch (a) {
+      case "b":
+      case "bb":
+      case "bbb":
+        return e.dayPeriod(r, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || e.dayPeriod(r, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "bbbbb":
+        return e.dayPeriod(r, {
+          width: "narrow",
+          context: "formatting"
+        });
+      default:
+        return e.dayPeriod(r, {
+          width: "wide",
+          context: "formatting"
+        }) || e.dayPeriod(r, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || e.dayPeriod(r, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  set(r, a, e) {
+    return r.setHours(s(e), 0, 0, 0), r;
+  }
+}
+export { c as AMPMMidnightParser$u };

package/dist/vendor/date-fns/parse/_lib/parsers/AMPMParser.js

@@ -0,0 +1,46 @@
+var d = Object.defineProperty;
+var n = (e, a, r) => a in e ? d(e, a, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[a] = r;
+var t = (e, a, r) => n(e, typeof a != "symbol" ? a + "" : a, r);
+import { Parser$u as s } from "../Parser.js";
+import { dayPeriodEnumToHours$u as w } from "../utils.js";
+class u extends s {
+  constructor() {
+    super(...arguments);
+    t(this, "priority", 80);
+    t(this, "incompatibleTokens", ["b", "B", "H", "k", "t", "T"]);
+  }
+  parse(r, i, o) {
+    switch (i) {
+      case "a":
+      case "aa":
+      case "aaa":
+        return o.dayPeriod(r, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || o.dayPeriod(r, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "aaaaa":
+        return o.dayPeriod(r, {
+          width: "narrow",
+          context: "formatting"
+        });
+      default:
+        return o.dayPeriod(r, {
+          width: "wide",
+          context: "formatting"
+        }) || o.dayPeriod(r, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || o.dayPeriod(r, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  set(r, i, o) {
+    return r.setHours(w(o), 0, 0, 0), r;
+  }
+}
+export { u as AMPMParser$u };

package/dist/vendor/date-fns/parse/_lib/parsers/DateParser.js

@@ -0,0 +1,59 @@
+var c = Object.defineProperty;
+var m = (s, e, r) => e in s ? c(s, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : s[e] = r;
+var o = (s, e, r) => m(s, typeof e != "symbol" ? e + "" : e, r);
+import { numericPatterns$u as p } from "../constants.js";
+import { Parser$u as u } from "../Parser.js";
+import { parseNDigits$u as l, parseNumericPattern$u as N, isLeapYearIndex$u as Y } from "../utils.js";
+const _ = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], f = [
+  31,
+  29,
+  31,
+  30,
+  31,
+  30,
+  31,
+  31,
+  30,
+  31,
+  30,
+  31
+];
+class A extends u {
+  constructor() {
+    super(...arguments);
+    o(this, "priority", 90);
+    o(this, "subPriority", 1);
+    o(this, "incompatibleTokens", [
+      "Y",
+      "R",
+      "q",
+      "Q",
+      "w",
+      "I",
+      "D",
+      "i",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(r, t, n) {
+    switch (t) {
+      case "d":
+        return N(p.date, r);
+      case "do":
+        return n.ordinalNumber(r, { unit: "date" });
+      default:
+        return l(t.length, r);
+    }
+  }
+  validate(r, t) {
+    const n = r.getFullYear(), a = Y(n), i = r.getMonth();
+    return a ? t >= 1 && t <= f[i] : t >= 1 && t <= _[i];
+  }
+  set(r, t, n) {
+    return r.setDate(n), r.setHours(0, 0, 0, 0), r;
+  }
+}
+export { A as DateParser$u };

package/dist/vendor/date-fns/parse/_lib/parsers/DayOfYearParser.js

@@ -0,0 +1,49 @@
+var n = Object.defineProperty;
+var o = (t, e, r) => e in t ? n(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
+var i = (t, e, r) => o(t, typeof e != "symbol" ? e + "" : e, r);
+import { numericPatterns$u as p } from "../constants.js";
+import { Parser$u as c } from "../Parser.js";
+import { parseNDigits$u as u, parseNumericPattern$u as m, isLeapYearIndex$u as f } from "../utils.js";
+class L extends c {
+  constructor() {
+    super(...arguments);
+    i(this, "priority", 90);
+    i(this, "subpriority", 1);
+    i(this, "incompatibleTokens", [
+      "Y",
+      "R",
+      "q",
+      "Q",
+      "M",
+      "L",
+      "w",
+      "I",
+      "d",
+      "E",
+      "i",
+      "e",
+      "c",
+      "t",
+      "T"
+    ]);
+  }
+  parse(r, s, a) {
+    switch (s) {
+      case "D":
+      case "DD":
+        return m(p.dayOfYear, r);
+      case "Do":
+        return a.ordinalNumber(r, { unit: "date" });
+      default:
+        return u(s.length, r);
+    }
+  }
+  validate(r, s) {
+    const a = r.getFullYear();
+    return f(a) ? s >= 1 && s <= 366 : s >= 1 && s <= 365;
+  }
+  set(r, s, a) {
+    return r.setMonth(0, a), r.setHours(0, 0, 0, 0), r;
+  }
+}
+export { L as DayOfYearParser$u };

package/dist/vendor/date-fns/parse/_lib/parsers/DayParser.js

@@ -0,0 +1,45 @@
+var s = Object.defineProperty;
+var E = (e, o, t) => o in e ? s(e, o, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[o] = t;
+var n = (e, o, t) => E(e, typeof o != "symbol" ? o + "" : o, t);
+import { setDay$u as w } from "../../../setDay.js";
+import { Parser$u as d } from "../Parser.js";
+class c extends d {
+  constructor() {
+    super(...arguments);
+    n(this, "priority", 90);
+    n(this, "incompatibleTokens", ["D", "i", "e", "c", "t", "T"]);
+  }
+  parse(t, a, r) {
+    switch (a) {
+      // Tue
+      case "E":
+      case "EE":
+      case "EEE":
+        return r.day(t, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || r.day(t, { width: "short", context: "formatting" }) || r.day(t, { width: "narrow", context: "formatting" });
+      // T
+      case "EEEEE":
+        return r.day(t, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // Tu
+      case "EEEEEE":
+        return r.day(t, { width: "short", context: "formatting" }) || r.day(t, { width: "narrow", context: "formatting" });
+      default:
+        return r.day(t, { width: "wide", context: "formatting" }) || r.day(t, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || r.day(t, { width: "short", context: "formatting" }) || r.day(t, { width: "narrow", context: "formatting" });
+    }
+  }
+  validate(t, a) {
+    return a >= 0 && a <= 6;
+  }
+  set(t, a, r, i) {
+    return t = w(t, r, i), t.setHours(0, 0, 0, 0), t;
+  }
+}
+export { c as DayParser$u };