@fewangsit/wangsvue-fats 1.0.1-alpha.50 → 1.0.1-alpha.52

package/vendor/luxon/src/impl/regexParser.es.js

@@ -0,0 +1,202 @@
+import { s as E, u as F, x as l, y as f, z as w, i as z } from "./util.es.js";
+import { h as Y, i as v, j as P } from "./english.es.js";
+import { F as y } from "../zones/fixedOffsetZone.es.js";
+import { I as q } from "../zones/IANAZone.es.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, s) => n + s.source, "");
+  return RegExp(`^${t}$`);
+}
+function m(...e) {
+  return (t) => e.reduce(
+    ([n, s, r], i) => {
+      const [d, o, a] = i(t, r);
+      return [{ ...n, ...d }, o || s, a];
+    },
+    [{}, null, 1]
+  ).slice(0, 2);
+}
+function T(e, ...t) {
+  if (e == null)
+    return [null, null];
+  for (const [n, s] of t) {
+    const r = n.exec(e);
+    if (r)
+      return s(r);
+  }
+  return [null, null];
+}
+function b(...e) {
+  return (t, n) => {
+    const s = {};
+    let r;
+    for (r = 0; r < e.length; r++)
+      s[e[r]] = f(t[n + r]);
+    return [s, null, n + r];
+  };
+}
+const J = /(?:([Zz])|([+-]\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(`(?:[Tt]${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"), j = b("year", "ordinal"), B = /(\d{4})-(\d\d)-(\d\d)/, C = RegExp(
+  `${M.source} ?(?:${J.source}|(${W.source}))?`
+), Q = RegExp(`(?: ${C.source})?`);
+function S(e, t, n) {
+  const s = e[t];
+  return z(s) ? n : f(s);
+}
+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], s = E(e[t + 1], e[t + 2]), r = n ? null : y.instance(s);
+  return [{}, r, 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, s, r, i, d, o, a, R] = e, I = t[0] === "-", A = a && a[0] === "-", c = (u, Z = !1) => u !== void 0 && (Z || u && I) ? -u : u;
+  return [
+    {
+      years: c(l(n)),
+      months: c(l(s)),
+      weeks: c(l(r)),
+      days: c(l(i)),
+      hours: c(l(d)),
+      minutes: c(l(o)),
+      seconds: c(l(a), a === "-0"),
+      milliseconds: c(F(R), A)
+    }
+  ];
+}
+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, s, r, i, d) {
+  const o = {
+    year: t.length === 2 ? w(f(t)) : f(t),
+    month: P.indexOf(n) + 1,
+    day: f(s),
+    hour: f(r),
+    minute: f(i)
+  };
+  return d && (o.second = f(d)), e && (o.weekday = e.length > 3 ? Y.indexOf(e) + 1 : v.indexOf(e) + 1), o;
+}
+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 se(e) {
+  const [
+    ,
+    t,
+    n,
+    s,
+    r,
+    i,
+    d,
+    o,
+    a,
+    R,
+    I,
+    A
+  ] = e, c = D(t, r, s, n, i, d, o);
+  let u;
+  return a ? u = te[a] : R ? u = 0 : u = E(I, A), [c, new y(u)];
+}
+function re(e) {
+  return e.replace(/\([^()]*\)|[\n\t]/g, " ").replace(/(\s\s+)/g, " ").trim();
+}
+const oe = /^(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, s, r, i, d, o] = e;
+  return [D(t, r, s, n, i, d, o), y.utcInstance];
+}
+function ae(e) {
+  const [, t, n, s, r, i, d, o] = e;
+  return [D(t, o, n, s, r, i, d), y.utcInstance];
+}
+const ce = x(H, h), ue = x(_, h), fe = x(L, h), le = x(k), N = m(
+  K,
+  g,
+  O,
+  p
+), Se = m(
+  U,
+  g,
+  O,
+  p
+), xe = m(
+  j,
+  g,
+  O,
+  p
+), me = m(
+  g,
+  O,
+  p
+);
+function Me(e) {
+  return T(
+    e,
+    [ce, N],
+    [ue, Se],
+    [fe, xe],
+    [le, me]
+  );
+}
+function he(e) {
+  return T(re(e), [ne, se]);
+}
+function De(e) {
+  return T(
+    e,
+    [oe, $],
+    [de, $],
+    [ie, ae]
+  );
+}
+function $e(e) {
+  return T(e, [X, ee]);
+}
+const Te = m(g);
+function Ee(e) {
+  return T(e, [V, Te]);
+}
+const ge = x(B, Q), Oe = x(C), pe = m(
+  g,
+  O,
+  p
+);
+function Fe(e) {
+  return T(
+    e,
+    [ge, N],
+    [Oe, pe]
+  );
+}
+export {
+  he as a,
+  De as b,
+  Fe as c,
+  $e as d,
+  Ee as e,
+  Me as p
+};

package/vendor/luxon/src/impl/tokenParser.es.js

@@ -0,0 +1,344 @@
+import { h as m, i as y, u as q, s as $, z as M } from "./util.es.js";
+import { F as g } from "./formatter.es.js";
+import { F as C } from "../zones/fixedOffsetZone.es.js";
+import { I as P } from "../zones/IANAZone.es.js";
+import { D as O } from "../datetime.es.js";
+import { d as c, p as z } from "./digits.es.js";
+import { C as H } from "../errors.es.js";
+const I = "missing Intl.DateTimeFormat.formatToParts support";
+function s(e, r = (t) => t) {
+  return { regex: e, deser: ([t]) => r(z(t)) };
+}
+const N = " ", Z = `[ ${N}]`, v = new RegExp(Z, "g");
+function D(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(D).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 U(e) {
+  return e.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
+}
+function b(e, r) {
+  const t = c(r), n = c(r, "{2}"), o = c(r, "{3}"), u = c(r, "{4}"), a = c(r, "{6}"), i = c(r, "{1,2}"), f = c(r, "{1,3}"), S = c(r, "{1,6}"), F = c(r, "{1,9}"), k = c(r, "{2,4}"), R = c(r, "{4,6}"), T = (d) => ({ regex: RegExp(U(d.val)), deser: ([L]) => L, literal: !0 }), x = ((d) => {
+    if (e.literal)
+      return T(d);
+    switch (d.val) {
+      // era
+      case "G":
+        return l(r.eras("short"), 0);
+      case "GG":
+        return l(r.eras("long"), 0);
+      // years
+      case "y":
+        return s(S);
+      case "yy":
+        return s(k, M);
+      case "yyyy":
+        return s(u);
+      case "yyyyy":
+        return s(R);
+      case "yyyyyy":
+        return s(a);
+      // months
+      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);
+      // dates
+      case "d":
+        return s(i);
+      case "dd":
+        return s(n);
+      // ordinals
+      case "o":
+        return s(f);
+      case "ooo":
+        return s(o);
+      // time
+      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(o);
+      case "u":
+        return h(F);
+      case "uu":
+        return h(i);
+      case "uuu":
+        return s(t);
+      // meridiem
+      case "a":
+        return l(r.meridiems(), 0);
+      // weekYear (k)
+      case "kkkk":
+        return s(u);
+      case "kk":
+        return s(k, M);
+      // weekNumber (W)
+      case "W":
+        return s(i);
+      case "WW":
+        return s(n);
+      // weekdays
+      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);
+      // offset/zone
+      case "Z":
+      case "ZZ":
+        return w(new RegExp(`([+-]${i.source})(?::(${n.source}))?`), 2);
+      case "ZZZ":
+        return w(new RegExp(`([+-]${i.source})(${n.source})?`), 2);
+      // we don't support ZZZZ (PST) or ZZZZZ (Pacific Standard Time) in parsing
+      // because we don't have any way to figure out what they are
+      case "z":
+        return h(/[a-z_+-/]{1,256}?/i);
+      // this special-case "token" represents a place where a macro-token expanded into a white-space literal
+      // in this case we accept any non-newline white-space
+      case " ":
+        return h(/[^\S\n\r]/);
+      default:
+        return T(d);
+    }
+  })(e) || {
+    invalidReason: I
+  };
+  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: o } = e;
+  if (n === "literal") {
+    const f = /^\s+$/.test(o);
+    return {
+      literal: !f,
+      val: f ? " " : o
+    };
+  }
+  const u = r[n];
+  let a = n;
+  n === "hour" && (r.hour12 != null ? a = r.hour12 ? "hour12" : "hour24" : r.hourCycle != null ? r.hourCycle === "h11" || r.hourCycle === "h12" ? a = "hour12" : a = "hour24" : a = t.hour12 ? "hour12" : "hour24");
+  let i = G[a];
+  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 o = {};
+    let u = 1;
+    for (const a in t)
+      if (m(t, a)) {
+        const i = t[a], f = i.groups ? i.groups + 1 : 1;
+        !i.literal && i.token && (o[i.token.val[0]] = i.deser(n.slice(u, u + f))), u += f;
+      }
+    return [n, o];
+  } 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 = P.create(e.z)), y(e.Z) || (t || (t = new C(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, a) => {
+    const i = r(a);
+    return i && (u[i] = e[a]), 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, o] = j(this.units);
+      this.regex = RegExp(n, "i"), this.handlers = o;
+    }
+  }
+  explainFromTokens(r) {
+    if (this.isValid) {
+      const [t, n] = A(r, this.regex, this.handlers), [o, u, a] = n ? B(n) : [null, null, void 0];
+      if (m(n, "a") && m(n, "H"))
+        throw new H(
+          "Can't include meridiem when specifying 24-hour format"
+        );
+      return {
+        input: r,
+        tokens: this.tokens,
+        regex: this.regex,
+        rawMatches: t,
+        matches: n,
+        result: o,
+        zone: u,
+        specificOffset: a
+      };
+    } 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 ae(e, r, t) {
+  const { result: n, zone: o, specificOffset: u, invalidReason: a } = K(e, r, t);
+  return [n, o, u, a];
+}
+function Q(e, r) {
+  if (!e)
+    return null;
+  const n = g.create(r, e).dtFormatter(V()), o = n.formatToParts(), u = n.resolvedOptions();
+  return o.map((a) => W(a, e, u));
+}
+export {
+  J as T,
+  K as a,
+  _ as e,
+  Q as f,
+  ae as p
+};