overview-components 1.0.75 → 1.0.76

package/dist/node_modules/luxon/src/impl/regexParser.js

@@ -0,0 +1,202 @@
+import { signedOffset as E, parseMillis as F, parseFloating as l, parseInteger as f, untruncateYear as w, isUndefined as Y } from "./util.js";
+import { weekdaysLong as v, weekdaysShort as z, monthsShort as P } from "./english.js";
+import y from "../zones/fixedOffsetZone.js";
+import q from "../zones/IANAZone.js";
+const W = /[A-Za-z_+-]{1,256}(?::?\/[A-Za-z0-9_+-]{1,256}(?:\/[A-Za-z0-9_+-]{1,256})?)?/;
+function x(...e) {
+  const t = e.reduce((n, r) => n + r.source, "");
+  return RegExp(`^${t}$`);
+}
+function m(...e) {
+  return (t) => e.reduce(
+    ([n, r, o], i) => {
+      const [d, s, c] = i(t, o);
+      return [{ ...n, ...d }, s || r, c];
+    },
+    [{}, null, 1]
+  ).slice(0, 2);
+}
+function T(e, ...t) {
+  if (e == null)
+    return [null, null];
+  for (const [n, r] of t) {
+    const o = n.exec(e);
+    if (o)
+      return r(o);
+  }
+  return [null, null];
+}
+function b(...e) {
+  return (t, n) => {
+    const r = {};
+    let o;
+    for (o = 0; o < e.length; o++)
+      r[e[o]] = f(t[n + o]);
+    return [r, null, n + o];
+  };
+}
+const J = /(?:(Z)|([+-]\d\d)(?::?(\d\d))?)/, G = `(?:${J.source}?(?:\\[(${W.source})\\])?)?`, M = /(\d\d)(?::?(\d\d)(?::?(\d\d)(?:[.,](\d{1,30}))?)?)?/, k = RegExp(`${M.source}${G}`), h = RegExp(`(?:T${k.source})?`), H = /([+-]\d{6}|\d{4})(?:-?(\d\d)(?:-?(\d\d))?)?/, _ = /(\d{4})-?W(\d\d)(?:-?(\d))?/, L = /(\d{4})-?(\d{3})/, U = b("weekYear", "weekNumber", "weekDay"), B = b("year", "ordinal"), Q = /(\d{4})-(\d\d)-(\d\d)/, C = RegExp(
+  `${M.source} ?(?:${J.source}|(${W.source}))?`
+), j = RegExp(`(?: ${C.source})?`);
+function S(e, t, n) {
+  const r = e[t];
+  return Y(r) ? n : f(r);
+}
+function K(e, t) {
+  return [{
+    year: S(e, t),
+    month: S(e, t + 1, 1),
+    day: S(e, t + 2, 1)
+  }, null, t + 3];
+}
+function g(e, t) {
+  return [{
+    hours: S(e, t, 0),
+    minutes: S(e, t + 1, 0),
+    seconds: S(e, t + 2, 0),
+    milliseconds: F(e[t + 3])
+  }, null, t + 4];
+}
+function O(e, t) {
+  const n = !e[t] && !e[t + 1], r = E(e[t + 1], e[t + 2]), o = n ? null : y.instance(r);
+  return [{}, o, t + 3];
+}
+function p(e, t) {
+  const n = e[t] ? q.create(e[t]) : null;
+  return [{}, n, t + 1];
+}
+const V = RegExp(`^T?${M.source}$`), X = /^-?P(?:(?:(-?\d{1,20}(?:\.\d{1,20})?)Y)?(?:(-?\d{1,20}(?:\.\d{1,20})?)M)?(?:(-?\d{1,20}(?:\.\d{1,20})?)W)?(?:(-?\d{1,20}(?:\.\d{1,20})?)D)?(?:T(?:(-?\d{1,20}(?:\.\d{1,20})?)H)?(?:(-?\d{1,20}(?:\.\d{1,20})?)M)?(?:(-?\d{1,20})(?:[.,](-?\d{1,20}))?S)?)?)$/;
+function ee(e) {
+  const [t, n, r, o, i, d, s, c, R] = e, A = t[0] === "-", I = c && c[0] === "-", u = (a, Z = !1) => a !== void 0 && (Z || a && A) ? -a : a;
+  return [
+    {
+      years: u(l(n)),
+      months: u(l(r)),
+      weeks: u(l(o)),
+      days: u(l(i)),
+      hours: u(l(d)),
+      minutes: u(l(s)),
+      seconds: u(l(c), c === "-0"),
+      milliseconds: u(F(R), I)
+    }
+  ];
+}
+const te = {
+  GMT: 0,
+  EDT: -4 * 60,
+  EST: -5 * 60,
+  CDT: -5 * 60,
+  CST: -6 * 60,
+  MDT: -6 * 60,
+  MST: -7 * 60,
+  PDT: -7 * 60,
+  PST: -8 * 60
+};
+function D(e, t, n, r, o, i, d) {
+  const s = {
+    year: t.length === 2 ? w(f(t)) : f(t),
+    month: P.indexOf(n) + 1,
+    day: f(r),
+    hour: f(o),
+    minute: f(i)
+  };
+  return d && (s.second = f(d)), e && (s.weekday = e.length > 3 ? v.indexOf(e) + 1 : z.indexOf(e) + 1), s;
+}
+const ne = /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|(?:([+-]\d\d)(\d\d)))$/;
+function re(e) {
+  const [
+    ,
+    t,
+    n,
+    r,
+    o,
+    i,
+    d,
+    s,
+    c,
+    R,
+    A,
+    I
+  ] = e, u = D(t, o, r, n, i, d, s);
+  let a;
+  return c ? a = te[c] : R ? a = 0 : a = E(A, I), [u, new y(a)];
+}
+function oe(e) {
+  return e.replace(/\([^()]*\)|[\n\t]/g, " ").replace(/(\s\s+)/g, " ").trim();
+}
+const se = /^(Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d\d) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d\d):(\d\d):(\d\d) GMT$/, de = /^(Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\d\d)-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d\d) (\d\d):(\d\d):(\d\d) GMT$/, ie = /^(Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ( \d|\d\d) (\d\d):(\d\d):(\d\d) (\d{4})$/;
+function $(e) {
+  const [, t, n, r, o, i, d, s] = e;
+  return [D(t, o, r, n, i, d, s), y.utcInstance];
+}
+function ce(e) {
+  const [, t, n, r, o, i, d, s] = e;
+  return [D(t, s, n, r, o, i, d), y.utcInstance];
+}
+const ue = x(H, h), ae = x(_, h), fe = x(L, h), le = x(k), N = m(
+  K,
+  g,
+  O,
+  p
+), Se = m(
+  U,
+  g,
+  O,
+  p
+), xe = m(
+  B,
+  g,
+  O,
+  p
+), me = m(
+  g,
+  O,
+  p
+);
+function Me(e) {
+  return T(
+    e,
+    [ue, N],
+    [ae, Se],
+    [fe, xe],
+    [le, me]
+  );
+}
+function he(e) {
+  return T(oe(e), [ne, re]);
+}
+function De(e) {
+  return T(
+    e,
+    [se, $],
+    [de, $],
+    [ie, ce]
+  );
+}
+function $e(e) {
+  return T(e, [X, ee]);
+}
+const Te = m(g);
+function Ee(e) {
+  return T(e, [V, Te]);
+}
+const ge = x(Q, j), Oe = x(C), pe = m(
+  g,
+  O,
+  p
+);
+function Fe(e) {
+  return T(
+    e,
+    [ge, N],
+    [Oe, pe]
+  );
+}
+export {
+  De as parseHTTPDate,
+  Me as parseISODate,
+  $e as parseISODuration,
+  Ee as parseISOTimeOnly,
+  he as parseRFC2822Date,
+  Fe as parseSQL
+};

package/dist/node_modules/luxon/src/impl/tokenParser.js

@@ -0,0 +1,329 @@
+import { hasOwnProperty as m, isUndefined as y, parseMillis as q, signedOffset as $, untruncateYear as M } from "./util.js";
+import g from "./formatter.js";
+import P from "../zones/fixedOffsetZone.js";
+import C from "../zones/IANAZone.js";
+import O from "../datetime.js";
+import { digitRegex as c, parseDigits as H } from "./digits.js";
+import { ConflictingSpecificationError as N } from "../errors.js";
+const z = "missing Intl.DateTimeFormat.formatToParts support";
+function s(e, r = (t) => t) {
+  return { regex: e, deser: ([t]) => r(H(t)) };
+}
+const I = " ", Z = `[ ${I}]`, v = new RegExp(Z, "g");
+function U(e) {
+  return e.replace(/\./g, "\\.?").replace(v, Z);
+}
+function E(e) {
+  return e.replace(/\./g, "").replace(v, " ").toLowerCase();
+}
+function l(e, r) {
+  return e === null ? null : {
+    regex: RegExp(e.map(U).join("|")),
+    deser: ([t]) => e.findIndex((n) => E(t) === E(n)) + r
+  };
+}
+function w(e, r) {
+  return { regex: e, deser: ([, t, n]) => $(t, n), groups: r };
+}
+function h(e) {
+  return { regex: e, deser: ([r]) => r };
+}
+function D(e) {
+  return e.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
+}
+function b(e, r) {
+  const t = c(r), n = c(r, "{2}"), a = c(r, "{3}"), u = c(r, "{4}"), o = c(r, "{6}"), i = c(r, "{1,2}"), f = c(r, "{1,3}"), S = c(r, "{1,6}"), R = c(r, "{1,9}"), k = c(r, "{2,4}"), F = c(r, "{4,6}"), T = (d) => ({ regex: RegExp(D(d.val)), deser: ([L]) => L, literal: !0 }), x = ((d) => {
+    if (e.literal)
+      return T(d);
+    switch (d.val) {
+      case "G":
+        return l(r.eras("short"), 0);
+      case "GG":
+        return l(r.eras("long"), 0);
+      case "y":
+        return s(S);
+      case "yy":
+        return s(k, M);
+      case "yyyy":
+        return s(u);
+      case "yyyyy":
+        return s(F);
+      case "yyyyyy":
+        return s(o);
+      case "M":
+        return s(i);
+      case "MM":
+        return s(n);
+      case "MMM":
+        return l(r.months("short", !0), 1);
+      case "MMMM":
+        return l(r.months("long", !0), 1);
+      case "L":
+        return s(i);
+      case "LL":
+        return s(n);
+      case "LLL":
+        return l(r.months("short", !1), 1);
+      case "LLLL":
+        return l(r.months("long", !1), 1);
+      case "d":
+        return s(i);
+      case "dd":
+        return s(n);
+      case "o":
+        return s(f);
+      case "ooo":
+        return s(a);
+      case "HH":
+        return s(n);
+      case "H":
+        return s(i);
+      case "hh":
+        return s(n);
+      case "h":
+        return s(i);
+      case "mm":
+        return s(n);
+      case "m":
+        return s(i);
+      case "q":
+        return s(i);
+      case "qq":
+        return s(n);
+      case "s":
+        return s(i);
+      case "ss":
+        return s(n);
+      case "S":
+        return s(f);
+      case "SSS":
+        return s(a);
+      case "u":
+        return h(R);
+      case "uu":
+        return h(i);
+      case "uuu":
+        return s(t);
+      case "a":
+        return l(r.meridiems(), 0);
+      case "kkkk":
+        return s(u);
+      case "kk":
+        return s(k, M);
+      case "W":
+        return s(i);
+      case "WW":
+        return s(n);
+      case "E":
+      case "c":
+        return s(t);
+      case "EEE":
+        return l(r.weekdays("short", !1), 1);
+      case "EEEE":
+        return l(r.weekdays("long", !1), 1);
+      case "ccc":
+        return l(r.weekdays("short", !0), 1);
+      case "cccc":
+        return l(r.weekdays("long", !0), 1);
+      case "Z":
+      case "ZZ":
+        return w(new RegExp(`([+-]${i.source})(?::(${n.source}))?`), 2);
+      case "ZZZ":
+        return w(new RegExp(`([+-]${i.source})(${n.source})?`), 2);
+      case "z":
+        return h(/[a-z_+-/]{1,256}?/i);
+      case " ":
+        return h(/[^\S\n\r]/);
+      default:
+        return T(d);
+    }
+  })(e) || {
+    invalidReason: z
+  };
+  return x.token = e, x;
+}
+const G = {
+  year: {
+    "2-digit": "yy",
+    numeric: "yyyyy"
+  },
+  month: {
+    numeric: "M",
+    "2-digit": "MM",
+    short: "MMM",
+    long: "MMMM"
+  },
+  day: {
+    numeric: "d",
+    "2-digit": "dd"
+  },
+  weekday: {
+    short: "EEE",
+    long: "EEEE"
+  },
+  dayperiod: "a",
+  dayPeriod: "a",
+  hour12: {
+    numeric: "h",
+    "2-digit": "hh"
+  },
+  hour24: {
+    numeric: "H",
+    "2-digit": "HH"
+  },
+  minute: {
+    numeric: "m",
+    "2-digit": "mm"
+  },
+  second: {
+    numeric: "s",
+    "2-digit": "ss"
+  },
+  timeZoneName: {
+    long: "ZZZZZ",
+    short: "ZZZ"
+  }
+};
+function W(e, r, t) {
+  const { type: n, value: a } = e;
+  if (n === "literal") {
+    const f = /^\s+$/.test(a);
+    return {
+      literal: !f,
+      val: f ? " " : a
+    };
+  }
+  const u = r[n];
+  let o = n;
+  n === "hour" && (r.hour12 != null ? o = r.hour12 ? "hour12" : "hour24" : r.hourCycle != null ? r.hourCycle === "h11" || r.hourCycle === "h12" ? o = "hour12" : o = "hour24" : o = t.hour12 ? "hour12" : "hour24");
+  let i = G[o];
+  if (typeof i == "object" && (i = i[u]), i)
+    return {
+      literal: !1,
+      val: i
+    };
+}
+function j(e) {
+  return [`^${e.map((t) => t.regex).reduce((t, n) => `${t}(${n.source})`, "")}$`, e];
+}
+function A(e, r, t) {
+  const n = e.match(r);
+  if (n) {
+    const a = {};
+    let u = 1;
+    for (const o in t)
+      if (m(t, o)) {
+        const i = t[o], f = i.groups ? i.groups + 1 : 1;
+        !i.literal && i.token && (a[i.token.val[0]] = i.deser(n.slice(u, u + f))), u += f;
+      }
+    return [n, a];
+  } else
+    return [n, {}];
+}
+function B(e) {
+  const r = (u) => {
+    switch (u) {
+      case "S":
+        return "millisecond";
+      case "s":
+        return "second";
+      case "m":
+        return "minute";
+      case "h":
+      case "H":
+        return "hour";
+      case "d":
+        return "day";
+      case "o":
+        return "ordinal";
+      case "L":
+      case "M":
+        return "month";
+      case "y":
+        return "year";
+      case "E":
+      case "c":
+        return "weekday";
+      case "W":
+        return "weekNumber";
+      case "k":
+        return "weekYear";
+      case "q":
+        return "quarter";
+      default:
+        return null;
+    }
+  };
+  let t = null, n;
+  return y(e.z) || (t = C.create(e.z)), y(e.Z) || (t || (t = new P(e.Z)), n = e.Z), y(e.q) || (e.M = (e.q - 1) * 3 + 1), y(e.h) || (e.h < 12 && e.a === 1 ? e.h += 12 : e.h === 12 && e.a === 0 && (e.h = 0)), e.G === 0 && e.y && (e.y = -e.y), y(e.u) || (e.S = q(e.u)), [Object.keys(e).reduce((u, o) => {
+    const i = r(o);
+    return i && (u[i] = e[o]), u;
+  }, {}), t, n];
+}
+let p = null;
+function V() {
+  return p || (p = O.fromMillis(1555555555555)), p;
+}
+function Y(e, r) {
+  if (e.literal)
+    return e;
+  const t = g.macroTokenToFormatOpts(e.val), n = Q(t, r);
+  return n == null || n.includes(void 0) ? e : n;
+}
+function _(e, r) {
+  return Array.prototype.concat(...e.map((t) => Y(t, r)));
+}
+class J {
+  constructor(r, t) {
+    if (this.locale = r, this.format = t, this.tokens = _(g.parseFormat(t), r), this.units = this.tokens.map((n) => b(n, r)), this.disqualifyingUnit = this.units.find((n) => n.invalidReason), !this.disqualifyingUnit) {
+      const [n, a] = j(this.units);
+      this.regex = RegExp(n, "i"), this.handlers = a;
+    }
+  }
+  explainFromTokens(r) {
+    if (this.isValid) {
+      const [t, n] = A(r, this.regex, this.handlers), [a, u, o] = n ? B(n) : [null, null, void 0];
+      if (m(n, "a") && m(n, "H"))
+        throw new N(
+          "Can't include meridiem when specifying 24-hour format"
+        );
+      return {
+        input: r,
+        tokens: this.tokens,
+        regex: this.regex,
+        rawMatches: t,
+        matches: n,
+        result: a,
+        zone: u,
+        specificOffset: o
+      };
+    } else
+      return { input: r, tokens: this.tokens, invalidReason: this.invalidReason };
+  }
+  get isValid() {
+    return !this.disqualifyingUnit;
+  }
+  get invalidReason() {
+    return this.disqualifyingUnit ? this.disqualifyingUnit.invalidReason : null;
+  }
+}
+function K(e, r, t) {
+  return new J(e, t).explainFromTokens(r);
+}
+function oe(e, r, t) {
+  const { result: n, zone: a, specificOffset: u, invalidReason: o } = K(e, r, t);
+  return [n, a, u, o];
+}
+function Q(e, r) {
+  if (!e)
+    return null;
+  const n = g.create(r, e).dtFormatter(V()), a = n.formatToParts(), u = n.resolvedOptions();
+  return a.map((o) => W(o, e, u));
+}
+export {
+  J as TokenParser,
+  _ as expandMacroTokens,
+  K as explainFromTokens,
+  Q as formatOptsToTokens,
+  oe as parseFromTokens
+};