https://www.wooniezie.nl/_assets/c25ace7dfe73fbb8c05f07ae9ca2a4bb/Vite/useQueryParams-B1rlhbJY.js

68    this.tags.forEach(function(i) {
69      var l;
70      return (l = i.parentNode) == null ? void 0 : l.removeChild(i);
71    }), this.tags = [], this.ctr = 0;
72  }, e;
73})(), un = "-ms-", qd = "-moz-", qe = "-webkit-", I9 = "comm", Ip = "rule", Pp = "decl", fw = "@import", P9 = "@keyframes", dw = "@layer", hw = Math.abs, Th = String.fromCharCode, mw = Object.assign;
74function gw(e, t) {
75  return Jt(e, 0) ^ 45 ? (((t << 2 ^ Jt(e, 0)) << 2 ^ Jt(e, 1)) << 2 ^ Jt(e, 2)) << 2 ^ Jt(e, 3) : 0;
76}
77function k9(e) {
78  return e.trim();
79}
80function pw(e, t) {
81  return (e = t.exec(e)) ? e[0] : e;
82}
83function Ge(e, t, r) {
84  return e.replace(t, r);
85}
86function Ng(e, t) {
87  return e.indexOf(t);
88}
89function Jt(e, t) {
90  return e.charCodeAt(t) | 0;
91}
92function Vs(e, t, r) {
93  return e.slice(t, r);
94}
95function Yr(e) {
96  return e.length;
97}
98function kp(e) {
99  return e.length;
100}
101function fd(e, t) {
102  return t.push(e), e;
103}
104function yw(e, t) {
105  return e.map(t).join("");
106}
107var Ch = 1, ql = 1, L9 = 0, _n = 0, xt = 0, tu = "";
108function wh(e, t, r, i, l, s, f) {
109  return { value: e, root: t, parent: r, type: i, props: l, children: s, line: Ch, column: ql, length: f, return: "" };
110}
111function us(e, t) {
112  return mw(wh("", null, null, "", null, null, 0), e, { length: -e.length }, t);
113}
114function vw() {
115  return xt;
116}
117function bw() {
118  return xt = _n > 0 ? Jt(tu, --_n) : 0, ql--, xt === 10 && (ql = 1, Ch--), xt;
119}
120function Gn() {
121  return xt = _n < L9 ? Jt(tu, _n++) : 0, ql++, xt === 10 && (ql = 1, Ch++), xt;
122}
123function Kr() {
124  return Jt(tu, _n);
125}
126function Id() {
127  return _n;
128}
129function gc(e, t) {
130  return Vs(tu, e, t);
131}
132function Bs(e) {
133  switch (e) {
134    // \0 \t \n \r \s whitespace token
135    case 0:
136    case 9:
137    case 10:
138    case 13:
139    case 32:
140      return 5;
141    // ! + , / > @ ~ isolate token
142    case 33:
143    case 43:
144    case 44:
145    case 47:
146    case 62:
147    case 64:
148    case 126:
149    // ; { } breakpoint token
150    case 59:
151    case 123:
152    case 125:
153      return 4;
154    // : accompanied token
155    case 58:
156      return 3;
157    // " ' ( [ opening delimit token
158    case 34:
159    case 39:
160    case 40:
161    case 91:
162      return 2;
163    // ) ] closing delimit token
164    case 41:
165    case 93:
166      return 1;
167  }
168  return 0;
169}
170function z9(e) {
171  return Ch = ql = 1, L9 = Yr(tu = e), _n = 0, [];
172}
173function U9(e) {
174  return tu = "", e;
175}
176function Pd(e) {
177  return k9(gc(_n - 1, Ag(e === 91 ? e + 2 : e === 40 ? e + 1 : e)));
178}
179function Sw(e) {
180  for (; (xt = Kr()) && xt < 33; )
181    Gn();
182  return Bs(e) > 2 || Bs(xt) > 3 ? "" : " ";
183}
184function $w(e, t) {
185  for (; --t && Gn() && !(xt < 48 || xt > 102 || xt > 57 && xt < 65 || xt > 70 && xt < 97); )
186    ;
187  return gc(e, Id() + (t < 6 && Kr() == 32 && Gn() == 32));
188}
189function Ag(e) {
190  for (; Gn(); )
191    switch (xt) {
192      // ] ) " '
193      case e:
194        return _n;
195      // " '
196      case 34:
197      case 39:
198        e !== 34 && e !== 39 && Ag(xt);
199        break;
200      // (
201      case 40:
202        e === 41 && Ag(e);
203        break;
204      // \
205      case 92:
206        Gn();
207        break;
208    }
209  return _n;
210}
211function Ew(e, t) {
212  for (; Gn() && e + xt !== 57; )
213    if (e + xt === 84 && Kr() === 47)
214      break;
215  return "/*" + gc(t, _n - 1) + "*" + Th(e === 47 ? e : Gn());
216}
217function Tw(e) {
218  for (; !Bs(Kr()); )
219    Gn();
220  return gc(e, _n);
221}
222function Cw(e) {
223  return U9(kd("", null, null, null, [""], e = z9(e), 0, [0], e));
224}
225function kd(e, t, r, i, l, s, f, h, m) {
226  for (var g = 0, p = 0, b = f, S = 0, w = 0, T = 0, N = 1, $ = 1, A = 1, D = 0, _ = "", x = l, v = s, E = i, C = _; $; )
227    switch (T = D, D = Gn()) {
228      // (
229      case 40:
230        if (T != 108 && Jt(C, b - 1) == 58) {
231          Ng(C += Ge(Pd(D), "&", "&\f"), "&\f") != -1 && (A = -1);
232          break;
233        }
234      // " ' [
235      case 34:
236      case 39:
237      case 91:
238        C += Pd(D);
239        break;
240      // \t \n \r \s
241      case 9:
242      case 10:
243      case 13:
244      case 32:
245        C += Sw(T);
246        break;
247      // \
248      case 92:
249        C += $w(Id() - 1, 7);
250        continue;
251      // /
252      case 47:
253        switch (Kr()) {
254          case 42:
255          case 47:
256            fd(ww(Ew(Gn(), Id()), t, r), m);
257            break;
258          default:
259            C += "/";
260        }
261        break;
262      // {
263      case 123 * N:
264        h[g++] = Yr(C) * A;
265      // } ; \0
266      case 125 * N:
267      case 59:
268      case 0:
269        switch (D) {
270          // \0 }
271          case 0:
272          case 125:
273            $ = 0;
274          // ;
275          case 59 + p:
276            A == -1 && (C = Ge(C, /\f/g, "")), w > 0 && Yr(C) - b && fd(w > 32 ? Ub(C + ";", i, r, b - 1) : Ub(Ge(C, " ", "") + ";", i, r, b - 2), m);
277            break;
278          // @ ;
279          case 59:
280            C += ";";
281          // { rule/at-rule
282          default:
283            if (fd(E = zb(C, t, r, g, p, l, h, _, x = [], v = [], b), s), D === 123)
284              if (p === 0)
285                kd(C, t, E, E, x, s, b, h, v);
286              else
287                switch (S === 99 && Jt(C, 3) === 110 ? 100 : S) {
288                  // d l m s
289                  case 100:
290                  case 108:
291                  case 109:
292                  case 115:
293                    kd(e, E, E, i && fd(zb(e, E, E, 0, 0, l, h, _, l, x = [], b), v), l, v, b, h, i ? x : v);
294                    break;
295                  default:
296                    kd(C, E, E, E, [""], v, 0, h, v);
297                }
298        }
299        g = p = w = 0, N = A = 1, _ = C = "", b = f;
300        break;
301      // :
302      case 58:
303        b = 1 + Yr(C), w = T;
304      default:
305        if (N < 1) {
306          if (D == 123)
307            --N;
308          else if (D == 125 && N++ == 0 && bw() == 125)
309            continue;
310        }
311        switch (C += Th(D), D * N) {
312          // &
313          case 38:
314            A = p > 0 ? 1 : (C += "\f", -1);
315            break;
316          // ,
317          case 44:
318            h[g++] = (Yr(C) - 1) * A, A = 1;
319            break;
320          // @
321          case 64:

322            Kr() === 45 && (C += Pd(Gn())), S = Kr(), p = b = Yr(_ = C += Tw(Id())), D++;
323            break;
324          // -
325          case 45:
326            T === 45 && Yr(C) == 2 && (N = 0);
327        }
328    }
329  return s;
330}
331function zb(e, t, r, i, l, s, f, h, m, g, p) {
332  for (var b = l - 1, S = l === 0 ? s : [""], w = kp(S), T = 0, N = 0, $ = 0; T < i; ++T)
333    for (var A = 0, D = Vs(e, b + 1, b = hw(N = f[T])), _ = e; A < w; ++A)
334      (_ = k9(N > 0 ? S[A] + " " + D : Ge(D, /&\f/g, S[A]))) && (m[$++] = _);
335  return wh(e, t, r, l === 0 ? Ip : h, m, g, p);
336}
337function ww(e, t, r) {
338  return wh(e, t, r, I9, Th(vw()), Vs(e, 2, -2), 0);
339}
340function Ub(e, t, r, i) {
341  return wh(e, t, r, Pp, Vs(e, 0, i), Vs(e, i + 1, -1), i);
342}
343function kl(e, t) {
344  for (var r = "", i = kp(e), l = 0; l < i; l++)
345    r += t(e[l], l, e, t) || "";
346  return r;
347}
348function Ow(e, t, r, i) {
349  switch (e.type) {
350    case dw:
351      if (e.children.length) break;
352    case fw:
353    case Pp:
354      return e.return = e.return || e.value;
355    case I9:
356      return "";
357    case P9:
358      return e.return = e.value + "{" + kl(e.children, i) + "}";
359    case Ip:
360      e.value = e.props.join(",");
361  }
362  return Yr(r = kl(e.children, i)) ? e.return = e.value + "{" + r + "}" : "";
363}
364function Nw(e) {
365  var t = kp(e);
366  return function(r, i, l, s) {
367    for (var f = "", h = 0; h < t; h++)
368      f += e[h](r, i, l, s) || "";
369    return f;
370  };
371}
372function Aw(e) {
373  return function(t) {
374    t.root || (t = t.return) && e(t);
375  };
376}
377function j9(e) {
378  var t = /* @__PURE__ */ Object.create(null);
379  return function(r) {
380    return t[r] === void 0 && (t[r] = e(r)), t[r];
381  };
382}
383var _w = function(t, r, i) {
384  for (var l = 0, s = 0; l = s, s = Kr(), l === 38 && s === 12 && (r[i] = 1), !Bs(s); )
385    Gn();
386  return gc(t, _n);
387}, xw = function(t, r) {
388  var i = -1, l = 44;
389  do
390    switch (Bs(l)) {
391      case 0:
392        l === 38 && Kr() === 12 && (r[i] = 1), t[i] += _w(_n - 1, r, i);
393        break;
394      case 2:
395        t[i] += Pd(l);
396        break;
397      case 4:
398        if (l === 44) {
399          t[++i] = Kr() === 58 ? "&\f" : "", r[i] = t[i].length;
400          break;
401        }
402      // fallthrough
403      default:
404        t[i] += Th(l);
405    }
406  while (l = Gn());
407  return t;
408}, Rw = function(t, r) {
409  return U9(xw(z9(t), r));
410}, jb = /* @__PURE__ */ new WeakMap(), Dw = function(t) {
411  if (!(t.type !== "rule" || !t.parent || // positive .length indicates that this rule contains pseudo
412  // negative .length indicates that this rule has been already prefixed
413  t.length < 1)) {
414    for (var r = t.value, i = t.parent, l = t.column === i.column && t.line === i.line; i.type !== "rule"; )
415      if (i = i.parent, !i) return;
416    if (!(t.props.length === 1 && r.charCodeAt(0) !== 58 && !jb.get(i)) && !l) {
417      jb.set(t, !0);
418      for (var s = [], f = Rw(r, s), h = i.props, m = 0, g = 0; m < f.length; m++)
419        for (var p = 0; p < h.length; p++, g++)
420          t.props[g] = s[m] ? f[m].replace(/&\f/g, h[p]) : h[p] + " " + f[m];
421    }
422  }
423}, Mw = function(t) {
424  if (t.type === "decl") {
425    var r = t.value;
426    // charcode for l
427    r.charCodeAt(0) === 108 && // charcode for b
428    r.charCodeAt(2) === 98 && (t.return = "", t.value = "");
429  }
430};
431function F9(e, t) {
432  switch (gw(e, t)) {
433    // color-adjust
434    case 5103:
435      return qe + "print-" + e + e;
436    // animation, animation-(delay|direction|duration|fill-mode|iteration-count|name|play-state|timing-function)
437    case 5737:
438    case 4201:
439    case 3177:
440    case 3433:
441    case 1641:
442    case 4457:
443    case 2921:
444    // text-decoration, filter, clip-path, backface-visibility, column, box-decoration-break
445    case 5572:
446    case 6356:
447    case 5844:
448    case 3191:
449    case 6645:
450    case 3005:
451    // mask, mask-image, mask-(mode|clip|size), mask-(repeat|origin), mask-position, mask-composite,
452    case 6391:
453    case 5879:
454    case 5623:
455    case 6135:
456    case 4599:
457    case 4855:
458    // background-clip, columns, column-(count|fill|gap|rule|rule-color|rule-style|rule-width|span|width)
459    case 4215:
460    case 6389:
461    case 5109:
462    case 5365:
463    case 5621:
464    case 3829:
465      return qe + e + e;
466    // appearance, user-select, transform, hyphens, text-size-adjust
467    case 5349:
468    case 4246:
469    case 4810:
470    case 6968:
471    case 2756:
472      return qe + e + qd + e + un + e + e;
473    // flex, flex-direction
474    case 6828:
475    case 4268:
476      return qe + e + un + e + e;
477    // order
478    case 6165:
479      return qe + e + un + "flex-" + e + e;
480    // align-items
481    case 5187:
482      return qe + e + Ge(e, /(\w+).+(:[^]+)/, qe + "box-$1$2" + un + "flex-$1$2") + e;
483    // align-self
484    case 5443:
485      return qe + e + un + "flex-item-" + Ge(e, /flex-|-self/, "") + e;
486    // align-content
487    case 4675:
488      return qe + e + un + "flex-line-pack" + Ge(e, /align-content|flex-|-self/, "") + e;
489    // flex-shrink
490    case 5548:
491      return qe + e + un + Ge(e, "shrink", "negative") + e;
492    // flex-basis
493    case 5292:
494      return qe + e + un + Ge(e, "basis", "preferred-size") + e;
495    // flex-grow
496    case 6060:
497      return qe + "box-" + Ge(e, "-grow", "") + qe + e + un + Ge(e, "grow", "positive") + e;
498    // transition
499    case 4554:
500      return qe + Ge(e, /([^-])(transform)/g, "$1" + qe + "$2") + e;
501    // cursor
502    case 6187:
503      return Ge(Ge(Ge(e, /(zoom-|grab)/, qe + "$1"), /(image-set)/, qe + "$1"), e, "") + e;
504    // background, background-image
505    case 5495:
506    case 3959:
507      return Ge(e, /(image-set\([^]*)/, qe + "$1$`$1");
508    // justify-content
509    case 4968:
510      return Ge(Ge(e, /(.+:)(flex-)?(.*)/, qe + "box-pack:$3" + un + "flex-pack:$3"), /s.+-b[^;]+/, "justify") + qe + e + e;
511    // (margin|padding)-inline-(start|end)
512    case 4095:
513    case 3583:
514    case 4068:
515    case 2532:
516      return Ge(e, /(.+)-inline(.+)/, qe + "$1$2") + e;
517    // (min|max)?(width|height|inline-size|block-size)
518    case 8116:
519    case 7059:
520    case 5753:
521    case 5535:
522    case 5445:
523    case 5701:
524    case 4933:
525    case 4677:
526    case 5533:
527    case 5789:
528    case 5021:
529    case 4765:
530      if (Yr(e) - 1 - t > 6) switch (Jt(e, t + 1)) {
531        // (m)ax-content, (m)in-content
532        case 109:
533          if (Jt(e, t + 4) !== 45) break;
534        // (f)ill-available, (f)it-content
535        case 102:
536          return Ge(e, /(.+:)(.+)-([^]+)/, "$1" + qe + "$2-$3$1" + qd + (Jt(e, t + 3) == 108 ? "$3" : "$2-$3")) + e;
537        // (s)tretch
538        case 115:
539          return ~Ng(e, "stretch") ? F9(Ge(e, "stretch", "fill-available"), t) + e : e;
540      }
541      break;
542    // position: sticky
543    case 4949:
544      if (Jt(e, t + 1) !== 115) break;
545    // display: (flex|inline-flex)
546    case 6444:
547      switch (Jt(e, Yr(e) - 3 - (~Ng(e, "!important") && 10))) {
548        // stic(k)y
549        case 107:
550          return Ge(e, ":", ":" + qe) + e;
551        // (inline-)?fl(e)x
552        case 101:
553          return Ge(e, /(.+:)([^;!]+)(;|!.+)?/, "$1" + qe + (Jt(e, 14) === 45 ? "inline-" : "") + "box$3$1" + qe + "$2$3$1" + un + "$2box$3") + e;
554      }
555      break;
556    // writing-mode
557    case 5936:
558      switch (Jt(e, t + 11)) {
559        // vertical-l(r)
560        case 114:
561          return qe + e + un + Ge(e, /[svh]\w+-[tblr]{2}/, "tb") + e;
562        // vertical-r(l)
563        case 108:
564          return qe + e + un + Ge(e, /[svh]\w+-[tblr]{2}/, "tb-rl") + e;
565        // horizontal(-)tb
566        case 45:
567          return qe + e + un + Ge(e, /[svh]\w+-[tblr]{2}/, "lr") + e;
568      }
569      return qe + e + un + e + e;
570  }
571  return e;
572}
573var Iw = function(t, r, i, l) {
574  if (t.length > -1 && !t.return) switch (t.type) {
575    case Pp:
576      t.return = F9(t.value, t.length);
577      break;
578    case P9:
579      return kl([us(t, {
580        value: Ge(t.value, "@", "@" + qe)
581      })], l);
582    case Ip:
583      if (t.length) return yw(t.props, function(s) {
584        switch (pw(s, /(::plac\w+|:read-\w+)/)) {
585          // :read-(only|write)
586          case ":read-only":
587          case ":read-write":
588            return kl([us(t, {
589              props: [Ge(s, /:(read-\w+)/, ":" + qd + "$1")]
590            })], l);
591          // :placeholder
592          case "::placeholder":
593            return kl([us(t, {
594              props: [Ge(s, /:(plac\w+)/, ":" + qe + "input-$1")]
595            }), us(t, {
596              props: [Ge(s, /:(plac\w+)/, ":" + qd + "$1")]
597            }), us(t, {
598              props: [Ge(s, /:(plac\w+)/, un + "input-$1")]
599            })], l);
600        }
601        return "";
602      });
603  }
604}

807  var l = t.key + "-" + r.name;
808  // we only need to add the styles to the registered cache if the
809  // class name could be used further down
810  // the tree but if it's a string tag, we know it won't
811  // so we don't have to add it to registered cache.
812  // this improves memory usage since we can avoid storing the whole style string
813  (i === !1 || // we need to always store it if we're in compat mode and
814  // in node since emotion-server relies on whether a style is in
815  // the registered cache to know whether a style is global or not
816  // also, note that this check will be dead code eliminated in the browser
817  jw === !1) && t.registered[l] === void 0 && (t.registered[l] = r.styles);
818}, V9 = function(t, r, i) {
819  Lp(t, r, i);
820  var l = t.key + "-" + r.name;
821  if (t.inserted[r.name] === void 0) {
822    var s = r;
823    do
824      t.insert(r === s ? "." + l : "", s, t.sheet, !0), s = s.next;
825    while (s !== void 0);
826  }
827};
828function Fw(e) {
829  for (var t = 0, r, i = 0, l = e.length; l >= 4; ++i, l -= 4)
830    r = e.charCodeAt(i) & 255 | (e.charCodeAt(++i) & 255) << 8 | (e.charCodeAt(++i) & 255) << 16 | (e.charCodeAt(++i) & 255) << 24, r = /* Math.imul(k, m): */
831    (r & 65535) * 1540483477 + ((r >>> 16) * 59797 << 16), r ^= /* k >>> r: */
832    r >>> 24, t = /* Math.imul(k, m): */
833    (r & 65535) * 1540483477 + ((r >>> 16) * 59797 << 16) ^ /* Math.imul(h, m): */
834    (t & 65535) * 1540483477 + ((t >>> 16) * 59797 << 16);
835  switch (l) {
836    case 3:
837      t ^= (e.charCodeAt(i + 2) & 255) << 16;
838    case 2:
839      t ^= (e.charCodeAt(i + 1) & 255) << 8;
840    case 1:
841      t ^= e.charCodeAt(i) & 255, t = /* Math.imul(h, m): */
842      (t & 65535) * 1540483477 + ((t >>> 16) * 59797 << 16);
843  }
844  return t ^= t >>> 13, t = /* Math.imul(h, m): */
845  (t & 65535) * 1540483477 + ((t >>> 16) * 59797 << 16), ((t ^ t >>> 15) >>> 0).toString(36);
846}
847var Hw = {
848  animationIterationCount: 1,
849  aspectRatio: 1,
850  borderImageOutset: 1,
851  borderImageSlice: 1,
852  borderImageWidth: 1,
853  boxFlex: 1,
854  boxFlexGroup: 1,
855  boxOrdinalGroup: 1,
856  columnCount: 1,
857  columns: 1,
858  flex: 1,
859  flexGrow: 1,
860  flexPositive: 1,
861  flexShrink: 1,
862  flexNegative: 1,
863  flexOrder: 1,
864  gridRow: 1,
865  gridRowEnd: 1,
866  gridRowSpan: 1,
867  gridRowStart: 1,
868  gridColumn: 1,
869  gridColumnEnd: 1,
870  gridColumnSpan: 1,
871  gridColumnStart: 1,
872  msGridRow: 1,
873  msGridRowSpan: 1,
874  msGridColumn: 1,
875  msGridColumnSpan: 1,
876  fontWeight: 1,
877  lineHeight: 1,
878  opacity: 1,
879  order: 1,
880  orphans: 1,
881  scale: 1,
882  tabSize: 1,
883  widows: 1,
884  zIndex: 1,
885  zoom: 1,
886  WebkitLineClamp: 1,
887  // SVG-related properties
888  fillOpacity: 1,
889  floodOpacity: 1,
890  stopOpacity: 1,
891  strokeDasharray: 1,
892  strokeDashoffset: 1,
893  strokeMiterlimit: 1,
894  strokeOpacity: 1,
895  strokeWidth: 1
896}, Vw = /[A-Z]|^ms/g, Bw = /_EMO_([^_]+?)_([^]*?)_EMO_/g, B9 = function(t) {
897  return t.charCodeAt(1) === 45;
898}, Bb = function(t) {
899  return t != null && typeof t != "boolean";
900}, N1 = /* @__PURE__ */ j9(function(e) {
901  return B9(e) ? e : e.replace(Vw, "-$&").toLowerCase();
902}), qb = function(t, r) {
903  switch (t) {
904    case "animation":
905    case "animationName":
906      if (typeof r == "string")
907        return r.replace(Bw, function(i, l, s) {
908          return Zr = {
909            name: l,
910            styles: s,
911            next: Zr
912          }, l;
913        });
914  }
915  return Hw[t] !== 1 && !B9(t) && typeof r == "number" && r !== 0 ? r + "px" : r;
916};
917function qs(e, t, r) {
918  if (r == null)
919    return "";
920  var i = r;
921  if (i.__emotion_styles !== void 0)
922    return i;
923  switch (typeof r) {
924    case "boolean":
925      return "";
926    case "object": {
927      var l = r;
928      if (l.anim === 1)
929        return Zr = {
930          name: l.name,
931          styles: l.styles,
932          next: Zr
933        }, l.name;
934      var s = r;
935      if (s.styles !== void 0) {
936        var f = s.next;
937        if (f !== void 0)
938          for (; f !== void 0; )
939            Zr = {
940              name: f.name,
941              styles: f.styles,
942              next: Zr
943            }, f = f.next;
944        var h = s.styles + ";";
945        return h;
946      }
947      return qw(e, t, r);
948    }
949    case "function": {
950      if (e !== void 0) {
951        var m = Zr, g = r(e);
952        return Zr = m, qs(e, t, g);
953      }
954      break;
955    }
956  }
957  var p = r;
958  if (t == null)
959    return p;
960  var b = t[p];
961  return b !== void 0 ? b : p;
962}
963function qw(e, t, r) {
964  var i = "";
965  if (Array.isArray(r))
966    for (var l = 0; l < r.length; l++)
967      i += qs(e, t, r[l]) + ";";
968  else
969    for (var s in r) {
970      var f = r[s];
971      if (typeof f != "object") {
972        var h = f;
973        t != null && t[h] !== void 0 ? i += s + "{" + t[h] + "}" : Bb(h) && (i += N1(s) + ":" + qb(s, h) + ";");
974      } else if (Array.isArray(f) && typeof f[0] == "string" && (t == null || t[f[0]] === void 0))
975        for (var m = 0; m < f.length; m++)
976          Bb(f[m]) && (i += N1(s) + ":" + qb(s, f[m]) + ";");
977      else {
978        var g = qs(e, t, f);
979        switch (s) {
980          case "animation":
981          case "animationName": {
982            i += N1(s) + ":" + g + ";";
983            break;
984          }
985          default:
986            i += s + "{" + g + "}";
987        }
988      }
989    }
990  return i;
991}
992var Gb = /label:\s*([^\s;{]+)\s*(;|$)/g, Zr;
993function zp(e, t, r) {
994  if (e.length === 1 && typeof e[0] == "object" && e[0] !== null && e[0].styles !== void 0)
995    return e[0];
996  var i = !0, l = "";
997  Zr = void 0;
998  var s = e[0];
999  if (s == null || s.raw === void 0)
1000    i = !1, l += qs(r, t, s);
1001  else {
1002    var f = s;
1003    l += f[0];
1004  }
1005  for (var h = 1; h < e.length; h++)
1006    if (l += qs(r, t, e[h]), i) {
1007      var m = s;
1008      l += m[h];
1009    }
1010  Gb.lastIndex = 0;
1011  for (var g = "", p;

1381] = i;
1382  return [f, l, s, h, m, g, p];
1383}
1384function o7(e, t) {
1385  const r = e.formatToParts(t), i = [];
1386  for (let l = 0; l < r.length; l++) {
1387    const { type: s, value: f } = r[l], h = a7[s];
1388    s === "era" ? i[h] = f : Te(h) || (i[h] = parseInt(f, 10));
1389  }
1390  return i;
1391}
1392const _1 = /* @__PURE__ */ new Map();
1393class Ea extends yc {
1394  /**
1395   * @param {string} name - Zone name
1396   * @return {IANAZone}
1397   */
1398  static create(t) {
1399    let r = _1.get(t);
1400    return r === void 0 && _1.set(t, r = new Ea(t)), r;
1401  }
1402  /**
1403   * Reset local caches. Should only be necessary in testing scenarios.
1404   * @return {void}
1405   */
1406  static resetCache() {
1407    _1.clear(), Dg.clear();
1408  }
1409  /**
1410   * Returns whether the provided string is a valid specifier. This only checks the string's format, not that the specifier identifies a known zone; see isValidZone for that.
1411   * @param {string} s - The string to check validity on
1412   * @example IANAZone.isValidSpecifier("America/New_York") //=> true
1413   * @example IANAZone.isValidSpecifier("Sport~~blorp") //=> false
1414   * @deprecated For backward compatibility, this forwards to isValidZone, better use `isValidZone()` directly instead.
1415   * @return {boolean}
1416   */
1417  static isValidSpecifier(t) {
1418    return this.isValidZone(t);
1419  }
1420  /**
1421   * Returns whether the provided string identifies a real zone
1422   * @param {string} zone - The string to check
1423   * @example IANAZone.isValidZone("America/New_York") //=> true
1424   * @example IANAZone.isValidZone("Fantasia/Castle") //=> false
1425   * @example IANAZone.isValidZone("Sport~~blorp") //=> false
1426   * @return {boolean}
1427   */
1428  static isValidZone(t) {
1429    if (!t)
1430      return !1;
1431    try {
1432      return new Intl.DateTimeFormat("en-US", { timeZone: t }).format(), !0;
1433    } catch {
1434      return !1;
1435    }
1436  }
1437  constructor(t) {
1438    super(), this.zoneName = t, this.valid = Ea.isValidZone(t);
1439  }
1440  /**
1441   * The type of zone. `iana` for all instances of `IANAZone`.
1442   * @override
1443   * @type {string}
1444   */
1445  get type() {
1446    return "iana";
1447  }
1448  /**
1449   * The name of this zone (i.e. the IANA zone name).
1450   * @override
1451   * @type {string}
1452   */
1453  get name() {
1454    return this.zoneName;
1455  }
1456  /**
1457   * Returns whether the offset is known to be fixed for the whole year:
1458   * Always returns false for all IANA zones.
1459   * @override
1460   * @type {boolean}
1461   */
1462  get isUniversal() {
1463    return !1;
1464  }
1465  /**
1466   * Returns the offset's common name (such as EST) at the specified timestamp
1467   * @override
1468   * @param {number} ts - Epoch milliseconds for which to get the name
1469   * @param {Object} opts - Options to affect the format
1470   * @param {string} opts.format - What style of offset to return. Accepts 'long' or 'short'.
1471   * @param {string} opts.locale - What locale to return the offset name in.
1472   * @return {string}
1473   */
1474  offsetName(t, { format: r, locale: i }) {
1475    return N8(t, r, i, this.name);
1476  }
1477  /**
1478   * Returns the offset's value as a string
1479   * @override
1480   * @param {number} ts - Epoch milliseconds for which to get the offset
1481   * @param {string} format - What style of offset to return.
1482   *                          Accepts 'narrow', 'short', or 'techie'. Returning '+6', '+06:00', or '+0600' respectively
1483   * @return {string}
1484   */
1485  formatOffset(t, r) {
1486    return Ls(this.offset(t), r);
1487  }
1488  /**
1489   * Return the offset in minutes for this zone at the specified timestamp.
1490   * @override
1491   * @param {number} ts - Epoch milliseconds for which to compute the offset
1492   * @return {number}
1493   */
1494  offset(t) {
1495    if (!this.valid) return NaN;
1496    const r = new Date(t);
1497    if (isNaN(r)) return NaN;
1498    const i = r7(this.name);
1499    let [l, s, f, h, m, g, p] = i.formatToParts ? o7(i, r) : i7(i, r);
1500    h === "BC" && (l = -Math.abs(l) + 1);
1501    const S = Ah({
1502      year: l,
1503      month: s,
1504      day: f,
1505      hour: m === 24 ? 0 : m,
1506      minute: g,
1507      second: p,
1508      millisecond: 0
1509    });
1510    let w = +r;
1511    const T = w % 1e3;
1512    return w -= T >= 0 ? T : 1e3 + T, (S - w) / (60 * 1e3);
1513  }
1514  /**
1515   * Return whether this Zone is equal to another zone
1516   * @override
1517   * @param {Zone} otherZone - the zone to compare
1518   * @return {boolean}
1519   */
1520  equals(t) {
1521    return t.type === "iana" && t.name === this.name;
1522  }
1523  /**
1524   * Return whether this Zone is valid.
1525   * @override
1526   * @type {boolean}
1527   */
1528  get isValid() {
1529    return this.valid;
1530  }
1531}
1532let Yb = {};
1533function l7(e, t = {}) {
1534  const r = JSON.stringify([e, t]);
1535  let i = Yb[r];
1536  return i || (i = new Intl.ListFormat(e, t), Yb[r] = i), i;
1537}
1538const Mg = /* @__PURE__ */ new Map();
1539function Ig(e, t = {}) {
1540  const r = JSON.stringify([e, t]);
1541  let i = Mg.get(r);
1542  return i === void 0 && (i = new Intl.DateTimeFormat(e, t), Mg.set(r, i)), i;
1543}
1544const Pg = /* @__PURE__ */ new Map();
1545function u7(e, t = {}) {
1546  const r = JSON.stringify([e, t]);
1547  let i = Pg.get(r);
1548  return i === void 0 && (i = new Intl.NumberFormat(e, t), Pg.set(r, i)), i;
1549}
1550const kg = /* @__PURE__ */ new Map();
1551function s7(e, t = {}) {
1552  const { base: r, ...i } = t, l = JSON.stringify([e, i]);
1553  let s = kg.get(l);
1554  return s === void 0 && (s = new Intl.RelativeTimeFormat(e, t), kg.set(l, s)), s;
1555}
1556let _s = null;
1557function c7() {
1558  return _s || (_s = new Intl.DateTimeFormat().resolvedOptions().locale, _s);
1559}
1560const Lg = /* @__PURE__ */ new Map();
1561function y8(e) {
1562  let t = Lg.get(e);
1563  return t === void 0 && (t = new Intl.DateTimeFormat(e).resolvedOptions(), Lg.set(e, t)), t;
1564}
1565const zg = /* @__PURE__ */ new Map();
1566function f7(e) {
1567  let t = zg.get(e);
1568  if (!t) {
1569    const r = new Intl.Locale(e);
1570    t = "getWeekInfo" in r ? r.getWeekInfo() : r.weekInfo, "minimalDays" in t || (t = { ...v8, ...t }), zg.set(e, t);
1571  }
1572  return t;
1573}
1574function d7(e) {
1575  const t = e.indexOf("-x-");
1576  t !== -1 && (e = e.substring(0, t));
1577  const r = e.indexOf("-u-");
1578  if (r === -1)
1579    return [e];
1580  {
1581    let i, l;
1582    try {
1583      i = Ig(e).resolvedOptions(), l = e;
1584    } catch {
1585      const m = e.substring(0, r);
1586      i = Ig(m).resolvedOptions(), l = m;
1587    }
1588    const { numberingSystem: s, calendar: f } = i;
1589    return [l, s, f];
1590  }
1591}
1592function h7(e, t, r) {
1593  return (r || t) && (e.includes("-u-") || (e += "-u"), r && (e += `-ca-${r}`), t && (e += `-nu-${t}`)), e;
1594}
1595function m7(e) {
1596  const t = [];
1597  for (let r = 1; r <= 12; r++) {
1598    const i = ye.utc(2009, r, 1);
1599    t.push(e(i));
1600  }
1601  return t;
1602}
1603function g7(e) {
1604  const t = [];
1605  for (let r = 1; r <= 7; r++) {
1606    const i = ye.utc(2016, 11, 13 + r);
1607    t.push(e(i));
1608  }
1609  return t;
1610}
1611function dd(e, t, r, i) {
1612  const l = e.listingMode();
1613  return l === "error" ? null : l === "en" ? r(t) : i(t);
1614}
1615function p7(e) {
1616  return e.numberingSystem && e.numberingSystem !== "latn" ? !1 : e.numberingSystem === "latn" || !e.locale || e.locale.startsWith("en") || y8(e.locale).numberingSystem === "latn";
1617}
1618class y7 {
1619  constructor(t, r, i) {
1620    this.padTo = i.padTo || 0, this.floor = i.floor || !1;
1621    const { padTo: l, floor: s, ...f } = i;
1622    if (!r || Object.keys(f).length > 0) {
1623      const h = { useGrouping: !1, ...i };
1624      i.padTo > 0 && (h.minimumIntegerDigits = i.padTo), this.inf = u7(t, h);
1625    }
1626  }
1627  format(t) {
1628    if (this.inf) {
1629      const r = this.floor ? Math.floor(t) : t;
1630      return this.inf.format(r);
1631    } else {
1632      const r = this.floor ? Math.floor(t) : qp(t, 3);
1633      return _t(r, this.padTo);
1634    }
1635  }
1636}
1637class v7 {
1638  constructor(t, r, i) {
1639    this.opts = i, this.originalZone = void 0;
1640    let l;
1641    if (this.opts.timeZone)
1642      this.dt = t;
1643    else if (t.zone.type === "fixed") {
1644      const f = -1 * (t.offset / 60), h = f >= 0 ? `Etc/GMT+${f}` : `Etc/GMT${f}`;
1645      t.offset !== 0 && Ea.create(h).valid ? (l = h, this.dt = t) : (l = "UTC", this.dt = t.offset === 0 ? t : t.setZone("UTC").plus({ minutes: t.offset }), this.originalZone = t.zone);
1646    } else t.zone.type === "system" ? this.dt = t : t.zone.type === "iana" ? (this.dt = t, l = t.zone.name) : (l = "UTC", this.dt = t.setZone("UTC").plus({ minutes: t.offset }), this.originalZone = t.zone);
1647    const s = { ...this.opts };
1648    s.timeZone = s.timeZone || l, this.dtf = Ig(r, s);
1649  }
1650  format() {
1651    return this.originalZone ? this.formatToParts().map(({ value: t }) => t).join("") : this.dtf.format(this.dt.toJSDate());
1652  }
1653  formatToParts() {
1654    const t = this.dtf.formatToParts(this.dt.toJSDate());
1655    return this.originalZone ? t.map((r) => {
1656      if (r.type === "timeZoneName") {
1657        const i = this.originalZone.offsetName(this.dt.ts, {
1658          locale: this.dt.locale,
1659          format: this.opts.timeZoneName
1660        });
1661        return {
1662          ...r,
1663          value: i
1664        };
1665      } else
1666        return r;
1667    }) : t;
1668  }
1669  resolvedOptions() {
1670    return this.dtf.resolvedOptions();
1671  }
1672}
1673class b7 {
1674  constructor(t, r, i) {
1675    this.opts = { style: "long", ...i }, !r && w8() && (this.rtf = s7(t, i));
1676  }
1677  format(t, r) {
1678    return this.rtf ? this.rtf.format(t, r) : F7(r, t, this.opts.numeric, this.opts.style !== "long");
1679  }
1680  formatToParts(t, r) {
1681    return this.rtf ? this.rtf.formatToParts(t, r) : [];
1682  }
1683}
1684const v8 = {
1685  firstDay: 1,
1686  minimalDays: 4,
1687  weekend: [6, 7]
1688};
1689class Ke {
1690  static fromOpts(t) {
1691    return Ke.create(
1692      t.locale,
1693      t.numberingSystem,
1694      t.outputCalendar,
1695      t.weekSettings,
1696      t.defaultToEN
1697    );
1698  }
1699  static create(t, r, i, l, s = !1) {
1700    const f = t || $t.defaultLocale, h = f || (s ? "en-US" : c7()), m = r || $t.defaultNumberingSystem, g = i || $t.defaultOutputCalendar, p = jg(l) || $t.defaultWeekSettings;
1701    return new Ke(h, m, g, p, f);
1702  }
1703  static resetCache() {
1704    _s = null, Mg.clear(), Pg.clear(), kg.clear(), Lg.clear(), zg.clear();
1705  }
1706  static fromObject({ locale: t, numberingSystem: r, outputCalendar: i, weekSettings: l } = {}) {
1707    return Ke.create(t, r, i, l);
1708  }
1709  constructor(t, r, i, l, s) {
1710    const [f, h, m] = d7(t);
1711    this.locale = f, this.numberingSystem = r || h || null, this.outputCalendar = i || m || null, this.weekSettings = l, this.intl = h7(this.locale, this.numberingSystem, this.outputCalendar), this.weekdaysCache = { format: {}, standalone: {} }, this.monthsCache = { format: {}, standalone: {} }, this.meridiemCache = null, this.eraCache = {}, this.specifiedLocale = s, this.fastNumbersCached = null;
1712  }
1713  get fastNumbers() {
1714    return this.fastNumbersCached == null && (this.fastNumbersCached = p7(this)), this.fastNumbersCached;
1715  }
1716  listingMode() {
1717    const t = this.isEnglish(), r = (this.numberingSystem === null || this.numberingSystem === "latn") && (this.outputCalendar === null || this.outputCalendar === "gregory");
1718    return t && r ? "en" : "intl";
1719  }
1720  clone(t) {
1721    return !t || Object.getOwnPropertyNames(t).length === 0 ? this : Ke.create(
1722      t.locale || this.specifiedLocale,
1723      t.numberingSystem || this.numberingSystem,
1724      t.outputCalendar || this.outputCalendar,
1725      jg(t.weekSettings) || this.weekSettings,
1726      t.defaultToEN || !1
1727    );
1728  }
1729  redefaultToEN(t = {}) {
1730    return this.clone({ ...t, defaultToEN: !0 });
1731  }
1732  redefaultToSystem(t = {}) {
1733    return this.clone({ ...t, defaultToEN: !1 });
1734  }
1735  months(t, r = !1) {
1736    return dd(this, t, x8, () => {
1737      const i = this.intl === "ja" || this.intl.startsWith("ja-");
1738      r &= !i;
1739      const l = r ? { month: t, day: "numeric" } : { month: t }, s = r ? "format" : "standalone";
1740      if (!this.monthsCache[s][t]) {
1741        const f = i ? (h) => this.dtFormatter(h, l).format() : (h) => this.extract(h, l, "month");
1742        this.monthsCache[s][t] = m7(f);
1743      }
1744      return this.monthsCache[s][t];
1745    });
1746  }
1747  weekdays(t, r = !1) {
1748    return dd(this, t, M8, () => {
1749      const i = r ? { weekday: t, year: "numeric", month: "long", day: "numeric" } : { weekday: t }, l = r ? "format" : "standalone";
1750      return this.weekdaysCache[l][t] || (this.weekdaysCache[l][t] = g7(
1751        (s) => this.extract(s, i, "weekday")
1752      )), this.weekdaysCache[l][t];
1753    });
1754  }
1755  meridiems() {
1756    return dd(
1757      this,
1758      void 0,
1759      () => I8,
1760      () => {
1761        if (!this.meridiemCache) {
1762          const t = { hour: "numeric", hourCycle: "h12" };
1763          this.meridiemCache = [ye.utc(2016, 11, 13, 9), ye.utc(2016, 11, 13, 19)].map(
1764            (r) => this.extract(r, t, "dayperiod")
1765          );
1766        }
1767        return this.meridiemCache;
1768      }
1769    );
1770  }
1771  eras(t) {
1772    return dd(this, t, P8, () => {
1773      const r = { era: t };
1774      return this.eraCache[t] || (this.eraCache[t] = [ye.utc(-40, 1, 1), ye.utc(2017, 1, 1)].map(
1775        (i) => this.extract(i, r, "era")
1776      )), this.eraCache[t];
1777    });
1778  }
1779  extract(t, r, i) {
1780    const l = this.dtFormatter(t, r), s = l.formatToParts(), f = s.find((h) => h.type.toLowerCase() === i);
1781    return f ? f.value : null;
1782  }
1783  numberFormatter(t = {}) {
1784    return new y7(this.intl, t.forceSimple || this.fastNumbers, t);
1785  }
1786  dtFormatter(t, r = {}) {
1787    return new v7(t, this.intl, r);
1788  }
1789  relFormatter(t = {}) {
1790    return new b7(this.intl, this.isEnglish(), t);
1791  }
1792  listFormatter(t = {}) {
1793    return l7(this.intl, t);
1794  }
1795  isEnglish() {
1796    return this.locale === "en" || this.locale.toLowerCase() === "en-us" || y8(this.intl).locale.startsWith("en-us");
1797  }
1798  getWeekSettings() {
1799    return this.weekSettings ? this.weekSettings : O8() ? f7(this.locale) : v8;
1800  }
1801  getStartOfWeek() {
1802    return this.getWeekSettings().firstDay;
1803  }
1804  getMinDaysInFirstWeek() {
1805    return this.getWeekSettings().minimalDays;
1806  }
1807  getWeekendDays() {
1808    return this.getWeekSettings().weekend;
1809  }
1810  equals(t) {
1811    return this.locale === t.locale && this.numberingSystem === t.numberingSystem && this.outputCalendar === t.outputCalendar;
1812  }
1813  toString() {
1814    return `Locale(${this.locale}, ${this.numberingSystem}, ${this.outputCalendar})`;
1815  }
1816}
1817let x1 = null;
1818class vn extends yc {
1819  /**
1820   * Get a singleton instance of UTC
1821   * @return {FixedOffsetZone}
1822   */
1823  static get utcInstance() {
1824    return x1 === null && (x1 = new vn(0)), x1;
1825  }
1826  /**
1827   * Get an instance with a specified offset
1828   * @param {number} offset - The offset in minutes
1829   * @return {FixedOffsetZone}
1830   */
1831  static instance(t) {
1832    return t === 0 ? vn.utcInstance : new vn(t);
1833  }
1834  /**
1835   * Get an instance of FixedOffsetZone from a UTC offset string, like "UTC+6"
1836   * @param {string} s - The offset string to parse
1837   * @example FixedOffsetZone.parseSpecifier("UTC+6")
1838   * @example FixedOffsetZone.parseSpecifier("UTC+06")
1839   * @example FixedOffsetZone.parseSpecifier("UTC-6:00")
1840   * @return {FixedOffsetZone}
1841   */
1842  static parseSpecifier(t) {
1843    if (t) {
1844      const r = t.match(/^utc(?:([+-]\d{1,2})(?::(\d{2}))?)?$/i);
1845      if (r)
1846        return new vn(_h(r[1], r[2]));
1847    }
1848    return null;
1849  }
1850  constructor(t) {
1851    super(), this.fixed = t;
1852  }
1853  /**
1854   * The type of zone. `fixed` for all instances of `FixedOffsetZone`.
1855   * @override
1856   * @type {string}
1857   */
1858  get type() {
1859    return "fixed";
1860  }
1861  /**
1862   * The name of this zone.
1863   * All fixed zones' names always start with "UTC" (plus optional offset)
1864   * @override
1865   * @type {string}
1866   */
1867  get name() {
1868    return this.fixed === 0 ? "UTC" : `UTC${Ls(this.fixed, "narrow")}`;
1869  }
1870  /**
1871   * The IANA name of this zone, i.e. `Etc/UTC` or `Etc/GMT+/-nn`
1872   *
1873   * @override
1874   * @type {string}
1875   */
1876  get ianaName() {
1877    return this.fixed === 0 ? "Etc/UTC" : `Etc/GMT${Ls(-this.fixed, "narrow")}`;
1878  }
1879  /**
1880   * Returns the offset's common name at the specified timestamp.
1881   *
1882   * For fixed offset zones this equals to the zone name.
1883   * @override
1884   */
1885  offsetName() {
1886    return this.name;
1887  }
1888  /**
1889   * Returns the offset's value as a string
1890   * @override
1891   * @param {number} ts - Epoch milliseconds for which to get the offset
1892   * @param {string} format - What style of offset to return.
1893   *                          Accepts 'narrow', 'short', or 'techie'. Returning '+6', '+06:00', or '+0600' respectively
1894   * @return {string}
1895   */
1896  formatOffset(t, r) {
1897    return Ls(this.fixed, r);
1898  }
1899  /**
1900   * Returns whether the offset is known to be fixed for the whole year:
1901   * Always returns true for all fixed offset zones.
1902   * @override
1903   * @type {boolean}
1904   */
1905  get isUniversal() {
1906    return !0;
1907  }
1908  /**
1909   * Return the offset in minutes for this zone at the specified timestamp.
1910   *
1911   * For fixed offset zones, this is constant and does not depend on a timestamp.
1912   * @override
1913   * @return {number}
1914   */
1915  offset() {
1916    return this.fixed;
1917  }
1918  /**
1919   * Return whether this Zone is equal to another zone (i.e. also fixed and same offset)
1920   * @override
1921   * @param {Zone} otherZone - the zone to compare
1922   * @return {boolean}
1923   */
1924  equals(t) {
1925    return t.type === "fixed" && t.fixed === this.fixed;
1926  }
1927  /**
1928   * Return whether this Zone is valid:
1929   * All fixed offset zones are valid.
1930   * @override
1931   * @type {boolean}
1932   */
1933  get isValid() {
1934    return !0;
1935  }
1936}
1937class S7 extends yc {
1938  constructor(t) {
1939    super(), this.zoneName = t;
1940  }
1941  /** @override **/
1942  get type() {
1943    return "invalid";
1944  }
1945  /** @override **/
1946  get name() {
1947    return this.zoneName;
1948  }
1949  /** @override **/
1950  get isUniversal() {
1951    return !1;
1952  }
1953  /** @override **/
1954  offsetName() {
1955    return null;
1956  }
1957  /** @override **/
1958  formatOffset() {
1959    return "";
1960  }
1961  /** @override **/
1962  offset() {
1963    return NaN;
1964  }
1965  /** @override **/
1966  equals() {
1967    return !1;
1968  }
1969  /** @override **/
1970  get isValid() {
1971    return !1;
1972  }
1973}
1974function hi(e, t) {
1975  if (Te(e) || e === null)
1976    return t;
1977  if (e instanceof yc)
1978    return e;
1979  if (O7(e)) {
1980    const r = e.toLowerCase();
1981    return r === "default" ? t : r === "local" || r === "system" ? Oh.instance : r === "utc" || r === "gmt" ? vn.utcInstance : vn.parseSpecifier(r) || Ea.create(e);
1982  } else return pi(e) ? vn.instance(e) : typeof e == "object" && "offset" in e && typeof e.offset == "function" ? e : new S7(e);
1983}
1984const Fp = {
1985  arab: "[Ù -Ù©]",
1986  arabext: "[Û°-Û¹]",
1987  bali: "[᭐-᭙]",
1988  beng: "[০-৯]",
1989  deva: "[०-९]",
1990  fullwide: "[０-９]",
1991  gujr: "[૦-૯]",
1992  hanidec: "[〇|一|二|三|四|五|六|七|八|九]",
1993  khmr: "[០-៩]",
1994  knda: "[೦-೯]",
1995  laoo: "[໐-໙]",
1996  limb: "[᥆-᥏]",
1997  mlym: "[൦-൯]",
1998  mong: "[᠐-᠙]",
1999  mymr: "[၀-၉]",
2000  orya: "[à­¦-à­¯]",
2001  tamldec: "[௦-௯]",
2002  telu: "[౦-౯]",
2003  thai: "[๐-๙]",
2004  tibt: "[༠-༩]",
2005  latn: "\\d"
2006}, Zb = {
2007  arab: [1632, 1641],
2008  arabext: [1776, 1785],
2009  bali: [6992, 7001],
2010  beng: [2534, 2543],
2011  deva: [2406, 2415],
2012  fullwide: [65296, 65303],
2013  gujr: [2790, 2799],
2014  khmr: [6112, 6121],
2015  knda: [3302, 3311],
2016  laoo: [3792, 3801],
2017  limb: [6470, 6479],
2018  mlym: [3430, 3439],
2019  mong: [6160, 6169],
2020  mymr: [4160, 4169],
2021  orya: [2918, 2927],
2022  tamldec: [3046, 3055],
2023  telu: [3174, 3183],
2024  thai: [3664, 3673],
2025  tibt: [3872, 3881]
2026}, $7 = Fp.hanidec.replace(/[\[|\]]/g, "").split("");
2027function E7(e) {
2028  let t = parseInt(e, 10);
2029  if (isNaN(t)) {
2030    t = "";
2031    for (let r = 0; r < e.length; r++) {
2032      const i = e.charCodeAt(r);
2033      if (e[r].search(Fp.hanidec) !== -1)
2034        t += $7.indexOf(e[r]);
2035      else
2036        for (const l in Zb) {
2037          const [s, f] = Zb[l];
2038          i >= s && i <= f && (t += i - s);
2039        }
2040    }
2041    return parseInt(t, 10);
2042  } else
2043    return t;
2044}
2045const Ug = /* @__PURE__ */ new Map();
2046function T7() {
2047  Ug.clear();
2048}
2049function $r({ numberingSystem: e }, t = "") {
2050  const r = e || "latn";
2051  let i = Ug.get(r);
2052  i === void 0 && (i = /* @__PURE__ */ new Map(), Ug.set(r, i));
2053  let l = i.get(t);
2054  return l === void 0 && (l = new RegExp(`${Fp[r]}${t}`), i.set(t, l)), l;
2055}
2056let Qb = () => Date.now(), Kb = "system", Xb = null, Wb = null, Jb = null, eS = 60, tS, nS = null;
2057class $t {
2058  /**
2059   * Get the callback for returning the current timestamp.
2060   * @type {function}
2061   */
2062  static get now() {
2063    return Qb;
2064  }
2065  /**
2066   * Set the callback for returning the current timestamp.
2067   * The function should return a number, which will be interpreted as an Epoch millisecond count
2068   * @type {function}
2069   * @example Settings.now = () => Date.now() + 3000 // pretend it is 3 seconds in the future
2070   * @example Settings.now = () => 0 // always pretend it's Jan 1, 1970 at midnight in UTC time
2071   */
2072  static set now(t) {
2073    Qb = t;
2074  }
2075  /**
2076   * Set the default time zone to create DateTimes in. Does not affect existing instances.
2077   * Use the value "system" to reset this value to the system's time zone.
2078   * @type {string}
2079   */
2080  static set defaultZone(t) {
2081    Kb = t;
2082  }
2083  /**
2084   * Get the default time zone object currently used to create DateTimes. Does not affect existing instances.
2085   * The default value is the system's time zone (the one set on the machine that runs this code).
2086   * @type {Zone}
2087   */
2088  static get defaultZone() {
2089    return hi(Kb, Oh.instance);
2090  }
2091  /**
2092   * Get the default locale to create DateTimes with. Does not affect existing instances.
2093   * @type {string}
2094   */
2095  static get defaultLocale() {
2096    return Xb;
2097  }
2098  /**
2099   * Set the default locale to create DateTimes with. Does not affect existing instances.
2100   * @type {string}
2101   */
2102  static set defaultLocale(t) {
2103    Xb = t;
2104  }
2105  /**
2106   * Get the default numbering system to create DateTimes with. Does not affect existing instances.
2107   * @type {string}
2108   */
2109  static get defaultNumberingSystem() {
2110    return Wb;
2111  }
2112  /**
2113   * Set the default numbering system to create DateTimes with. Does not affect existing instances.
2114   * @type {string}
2115   */
2116  static set defaultNumberingSystem(t) {
2117    Wb = t;
2118  }
2119  /**
2120   * Get the default output calendar to create DateTimes with. Does not affect existing instances.
2121   * @type {string}
2122   */
2123  static get defaultOutputCalendar() {
2124    return Jb;
2125  }
2126  /**
2127   * Set the default output calendar to create DateTimes with. Does not affect existing instances.
2128   * @type {string}
2129   */
2130  static set defaultOutputCalendar(t) {
2131    Jb = t;
2132  }
2133  /**
2134   * @typedef {Object} WeekSettings
2135   * @property {number} firstDay
2136   * @property {number} minimalDays
2137   * @property {number[]} weekend
2138   */
2139  /**
2140   * @return {WeekSettings|null}
2141   */
2142  static get defaultWeekSettings() {
2143    return nS;
2144  }
2145  /**
2146   * Allows overriding the default locale week settings, i.e. the start of the week, the weekend and
2147   * how many days are required in the first week of a year.
2148   * Does not affect existing instances.
2149   *
2150   * @param {WeekSettings|null} weekSettings
2151   */
2152  static set defaultWeekSettings(t) {
2153    nS = jg(t);
2154  }
2155  /**
2156   * Get the cutoff year for whether a 2-digit year string is interpreted in the current or previous century. Numbers higher than the cutoff will be considered to mean 19xx and numbers lower or equal to the cutoff will be considered 20xx.
2157   * @type {number}
2158   */
2159  static get twoDigitCutoffYear() {
2160    return eS;
2161  }
2162  /**
2163   * Set the cutoff year for whether a 2-digit year string is interpreted in the current or previous century. Numbers higher than the cutoff will be considered to mean 19xx and numbers lower or equal to the cutoff will be considered 20xx.
2164   * @type {number}
2165   * @example Settings.twoDigitCutoffYear = 0 // all 'yy' are interpreted as 20th century
2166   * @example Settings.twoDigitCutoffYear = 99 // all 'yy' are interpreted as 21st century
2167   * @example Settings.twoDigitCutoffYear = 50 // '49' -> 2049; '50' -> 1950
2168   * @example Settings.twoDigitCutoffYear = 1950 // interpreted as 50
2169   * @example Settings.twoDigitCutoffYear = 2050 // ALSO interpreted as 50
2170   */
2171  static set twoDigitCutoffYear(t) {
2172    eS = t % 100;
2173  }
2174  /**
2175   * Get whether Luxon will throw when it encounters invalid DateTimes, Durations, or Intervals
2176   * @type {boolean}
2177   */
2178  static get throwOnInvalid() {
2179    return tS;
2180  }
2181  /**
2182   * Set whether Luxon will throw when it encounters invalid DateTimes, Durations, or Intervals
2183   * @type {boolean}
2184   */
2185  static set throwOnInvalid(t) {
2186    tS = t;
2187  }
2188  /**
2189   * Reset Luxon's global caches. Should only be necessary in testing scenarios.
2190   * @return {void}
2191   */
2192  static resetCaches() {
2193    Ke.resetCache(), Ea.resetCache(), ye.resetCache(), T7();
2194  }
2195}
2196class Or {
2197  constructor(t, r) {
2198    this.reason = t, this.explanation = r;
2199  }
2200  toMessage() {
2201    return this.explanation ? `${this.reason}: ${this.explanation}` : this.reason;
2202  }
2203}
2204const b8 = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334], S8 = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335];
2205function cr(e, t) {
2206  return new Or(
2207    "unit out of range",
2208    `you specified ${t} (of type ${typeof t}) as a ${e}, which is invalid`
2209  );
2210}
2211function Hp(e, t, r) {
2212  const i = new Date(Date.UTC(e, t - 1, r));
2213  e < 100 && e >= 0 && i.setUTCFullYear(i.getUTCFullYear() - 1900);
2214  const l = i.getUTCDay();
2215  return l === 0 ? 7 : l;
2216}
2217function $8(e, t, r) {
2218  return r + (vc(e) ? S8 : b8)[t - 1];
2219}
2220function E8(e, t) {
2221  const r = vc(e) ? S8 : b8, i = r.findIndex((s) => s < t), l = t - r[i];
2222  return { month: i + 1, day: l };
2223}
2224function Vp(e, t) {
2225  return (e - t + 7) % 7 + 1;
2226}
2227function Yd(e, t = 4, r = 1) {
2228  const { year: i, month: l, day: s } = e, f = $8(i, l, s), h = Vp(Hp(i, l, s), r);
2229  let m = Math.floor((f - h + 14 - t) / 7), g;
2230  return m < 1 ? (g = i - 1, m = Gs(g, t, r)) : m > Gs(i, t, r) ? (g = i + 1, m = 1) : g = i, { weekYear: g, weekNumber: m, weekday: h, ...xh(e) };
2231}
2232function rS(e, t = 4, r = 1) {
2233  const { weekYear: i, weekNumber: l, weekday: s } = e, f = Vp(Hp(i, 1, t), r), h = Ll(i);
2234  let m = l * 7 + s - f - 7 + t, g;
2235  m < 1 ? (g = i - 1, m += Ll(g)) : m > h ? (g = i + 1, m -= Ll(i)) : g = i;
2236  const { month: p, day: b } = E8(g, m);
2237  return { year: g, month: p, day: b, ...xh(e) };
2238}
2239function R1(e) {
2240  const { year: t, month: r, day: i } = e, l = $8(t, r, i);
2241  return { year: t, ordinal: l, ...xh(e) };
2242}
2243function aS(e) {
2244  const { year: t, ordinal: r } = e, { month: i, day: l } = E8(t, r);
2245  return { year: t, month: i, day: l, ...xh(e) };
2246}
2247function iS(e, t) {
2248  if (!Te(e.localWeekday) || !Te(e.localWeekNumber) || !Te(e.localWeekYear)) {
2249    if (!Te(e.weekday) || !Te(e.weekNumber) || !Te(e.weekYear))
2250      throw new Dl(
2251        "Cannot mix locale-based week fields with ISO-based week fields"
2252      );
2253    return Te(e.localWeekday) || (e.weekday = e.localWeekday), Te(e.localWeekNumber) || (e.weekNumber = e.localWeekNumber), Te(e.localWeekYear) || (e.weekYear = e.localWeekYear), delete e.localWeekday, delete e.localWeekNumber, delete e.localWeekYear, {
2254      minDaysInFirstWeek: t.getMinDaysInFirstWeek(),
2255      startOfWeek: t.getStartOfWeek()
2256    };
2257  } else
2258    return { minDaysInFirstWeek: 4, startOfWeek: 1 };
2259}
2260function C7(e, t = 4, r = 1) {
2261  const i = Nh(e.weekYear), l = fr(
2262    e.weekNumber,
2263    1,
2264    Gs(e.weekYear, t, r)
2265  ), s = fr(e.weekday, 1, 7);
2266  return i ? l ? s ? !1 : cr("weekday", e.weekday) : cr("week", e.weekNumber) : cr("weekYear", e.weekYear);
2267}
2268function w7(e) {
2269  const t = Nh(e.year), r = fr(e.ordinal, 1, Ll(e.year));
2270  return t ? r ? !1 : cr("ordinal", e.ordinal) : cr("year", e.year);
2271}
2272function T8(e) {
2273  const t = Nh(e.year), r = fr(e.month, 1, 12), i = fr(e.day, 1, Zd(e.year, e.month));
2274  return t ? r ? i ? !1 : cr("day", e.day) : cr("month", e.month) : cr("year", e.year);
2275}
2276function C8(e) {
2277  const { hour: t, minute: r, second: i, millisecond: l } = e, s = fr(t, 0, 23) || t === 24 && r === 0 && i === 0 && l === 0, f = fr(r, 0, 59), h = fr(i, 0, 59), m = fr(l, 0, 999);
2278  return s ? f ? h ? m ? !1 : cr("millisecond", l) : cr("second", i) : cr("minute", r) : cr("hour", t);
2279}
2280function Te(e) {
2281  return typeof e > "u";
2282}
2283function pi(e) {
2284  return typeof e == "number";
2285}
2286function Nh(e) {
2287  return typeof e == "number" && e % 1 === 0;
2288}
2289function O7(e) {
2290  return typeof e == "string";
2291}
2292function N7(e) {
2293  return Object.prototype.toString.call(e) === "[object Date]";
2294}
2295function w8() {
2296  try {
2297    return typeof Intl < "u" && !!Intl.RelativeTimeFormat;
2298  } catch {
2299    return !1;
2300  }
2301}
2302function O8() {
2303  try {
2304    return typeof Intl < "u" && !!Intl.Locale && ("weekInfo" in Intl.Locale.prototype || "getWeekInfo" in Intl.Locale.prototype);
2305  } catch {
2306    return !1;
2307  }
2308}
2309function A7(e) {
2310  return Array.isArray(e) ? e : [e];
2311}
2312function oS(e, t, r) {
2313  if (e.length !== 0)
2314    return e.reduce((i, l) => {
2315      const s = [t(l), l];
2316      return i && r(i[0], s[0]) === i[0] ? i : s;
2317    }, null)[1];
2318}
2319function _7(e, t) {
2320  return t.reduce((r, i) => (r[i] = e[i], r), {});
2321}
2322function Gl(e, t) {
2323  return Object.prototype.hasOwnProperty.call(e, t);
2324}
2325function jg(e) {
2326  if (e == null)
2327    return null;
2328  if (typeof e != "object")
2329    throw new cn("Week settings must be an object");
2330  if (!fr(e.firstDay, 1, 7) || !fr(e.minimalDays, 1, 7) || !Array.isArray(e.weekend) || e.weekend.some((t) => !fr(t, 1, 7)))
2331    throw new cn("Invalid week settings");
2332  return {
2333    firstDay: e.firstDay,
2334    minimalDays: e.minimalDays,
2335    weekend: Array.from(e.weekend)
2336  };
2337}
2338function fr(e, t, r) {
2339  return Nh(e) && e >= t && e <= r;
2340}
2341function x7(e, t) {
2342  return e - t * Math.floor(e / t);
2343}
2344function _t(e, t = 2) {
2345  const r = e < 0;
2346  let i;
2347  return r ? i = "-" + ("" + -e).padStart(t, "0") : i = ("" + e).padStart(t, "0"), i;
2348}
2349function fi(e) {
2350  if (!(Te(e) || e === null || e === ""))
2351    return parseInt(e, 10);
2352}
2353function Ki(e) {
2354  if (!(Te(e) || e === null || e === ""))
2355    return parseFloat(e);
2356}
2357function Bp(e) {
2358  if (!(Te(e) || e === null || e === "")) {
2359    const t = parseFloat("0." + e) * 1e3;
2360    return Math.floor(t);
2361  }
2362}
2363function qp(e, t, r = "round") {
2364  const i = 10 ** t;
2365  switch (r) {
2366    case "expand":
2367      return e > 0 ? Math.ceil(e * i) / i : Math.floor(e * i) / i;
2368    case "trunc":
2369      return Math.trunc(e * i) / i;
2370    case "round":
2371      return Math.round(e * i) / i;
2372    case "floor":
2373      return Math.floor(e * i) / i;
2374    case "ceil":
2375      return Math.ceil(e * i) / i;
2376    default:
2377      throw new RangeError(`Value rounding ${r} is out of range`);
2378  }
2379}
2380function vc(e) {
2381  return e % 4 === 0 && (e % 100 !== 0 || e % 400 === 0);
2382}
2383function Ll(e) {
2384  return vc(e) ? 366 : 365;
2385}
2386function Zd(e, t) {
2387  const r = x7(t - 1, 12) + 1, i = e + (t - r) / 12;
2388  return r === 2 ? vc(i) ? 29 : 28 : [31, null, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][r - 1];
2389}
2390function Ah(e) {
2391  let t = Date.UTC(
2392    e.year,
2393    e.month - 1,
2394    e.day,
2395    e.hour,
2396    e.minute,
2397    e.second,
2398    e.millisecond
2399  );
2400  return e.year < 100 && e.year >= 0 && (t = new Date(t), t.setUTCFullYear(e.year, e.month - 1, e.day)), +t;
2401}
2402function lS(e, t, r) {
2403  return -Vp(Hp(e, 1, t), r) + t - 1;
2404}
2405function Gs(e, t = 4, r = 1) {
2406  const i = lS(e, t, r), l = lS(e + 1, t, r);
2407  return (Ll(e) - i + l) / 7;
2408}
2409function Fg(e) {
2410  return e > 99 ? e : e > $t.twoDigitCutoffYear ? 1900 + e : 2e3 + e;
2411}
2412function N8(e, t, r, i = null) {
2413  const l = new Date(e), s = {
2414    hourCycle: "h23",
2415    year: "numeric",
2416    month: "2-digit",
2417    day: "2-digit",
2418    hour: "2-digit",
2419    minute: "2-digit"
2420  };
2421  i && (s.timeZone = i);
2422  const f = { timeZoneName: t, ...s }, h = new Intl.DateTimeFormat(r, f).formatToParts(l).find((m) => m.type.toLowerCase() === "timezonename");
2423  return h ? h.value : null;
2424}
2425function _h(e, t) {
2426  let r = parseInt(e, 10);
2427  Number.isNaN(r) && (r = 0);
2428  const i = parseInt(t, 10) || 0, l = r < 0 || Object.is(r, -0) ? -i : i;
2429  return r * 60 + l;
2430}
2431function A8(e) {
2432  const t = Number(e);
2433  if (typeof e == "boolean" || e === "" || !Number.isFinite(t))
2434    throw new cn(`Invalid unit value ${e}`);
2435  return t;
2436}
2437function Qd(e, t) {
2438  const r = {};
2439  for (const i in e)
2440    if (Gl(e, i)) {
2441      const l = e[i];
2442      if (l == null) continue;
2443      r[t(i)] = A8(l);
2444    }
2445  return r;
2446}
2447function Ls(e, t) {
2448  const r = Math.trunc(Math.abs(e / 60)), i = Math.trunc(Math.abs(e % 60)), l = e >= 0 ? "+" : "-";
2449  switch (t) {
2450    case "short":
2451      return `${l}${_t(r, 2)}:${_t(i, 2)}`;
2452    case "narrow":
2453      return `${l}${r}${i > 0 ? `:${i}` : ""}`;
2454    case "techie":
2455      return `${l}${_t(r, 2)}${_t(i, 2)}`;
2456    default:
2457      throw new RangeError(`Value format ${t} is out of range for property format`);
2458  }
2459}
2460function xh(e) {
2461  return _7(e, ["hour", "minute", "second", "millisecond"]);
2462}
2463const R7 = [
2464  "January",
2465  "February",
2466  "March",
2467  "April",
2468  "May",
2469  "June",
2470  "July",
2471  "August",
2472  "September",
2473  "October",
2474  "November",
2475  "December"
2476], _8 = [
2477  "Jan",
2478  "Feb",
2479  "Mar",
2480  "Apr",
2481  "May",
2482  "Jun",
2483  "Jul",
2484  "Aug",
2485  "Sep",
2486  "Oct",
2487  "Nov",
2488  "Dec"
2489], D7 = ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"];
2490function x8(e) {
2491  switch (e) {
2492    case "narrow":
2493      return [...D7];
2494    case "short":
2495      return [..._8];
2496    case "long":
2497      return [...R7];
2498    case "numeric":
2499      return ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"];
2500    case "2-digit":
2501      return ["01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12"];
2502    default:
2503      return null;
2504  }
2505}
2506const R8 = [
2507  "Monday",
2508  "Tuesday",
2509  "Wednesday",
2510  "Thursday",
2511  "Friday",
2512  "Saturday",
2513  "Sunday"
2514], D8 = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"], M7 = ["M", "T", "W", "T", "F", "S", "S"];
2515function M8(e) {
2516  switch (e) {
2517    case "narrow":
2518      return [...M7];
2519    case "short":
2520      return [...D8];
2521    case "long":
2522      return [...R8];
2523    case "numeric":
2524      return ["1", "2", "3", "4", "5", "6", "7"];
2525    default:
2526      return null;
2527  }
2528}
2529const I8 = ["AM", "PM"], I7 = ["Before Christ", "Anno Domini"], P7 = ["BC", "AD"], k7 = ["B", "A"];
2530function P8(e) {
2531  switch (e) {
2532    case "narrow":
2533      return [...k7];
2534    case "short":
2535      return [...P7];
2536    case "long":
2537      return [...I7];
2538    default:
2539      return null;
2540  }
2541}
2542function L7(e) {
2543  return I8[e.hour < 12 ? 0 : 1];
2544}
2545function z7(e, t) {
2546  return M8(t)[e.weekday - 1];
2547}
2548function U7(e, t) {
2549  return x8(t)[e.month - 1];
2550}
2551function j7(e, t) {
2552  return P8(t)[e.year < 0 ? 0 : 1];
2553}
2554function F7(e, t, r = "always", i = !1) {
2555  const l = {
2556    years: ["year", "yr."],
2557    quarters: ["quarter", "qtr."],
2558    months: ["month", "mo."],
2559    weeks: ["week", "wk."],
2560    days: ["day", "day", "days"],
2561    hours: ["hour", "hr."],
2562    minutes: ["minute", "min."],
2563    seconds: ["second", "sec."]
2564  }, s = ["hours", "minutes", "seconds"].indexOf(e) === -1;
2565  if (r === "auto" && s) {
2566    const b = e === "days";
2567    switch (t) {
2568      case 1:
2569        return b ? "tomorrow" : `next ${l[e][0]}`;
2570      case -1:
2571        return b ? "yesterday" : `last ${l[e][0]}`;
2572      case 0:
2573        return b ? "today" : `this ${l[e][0]}`;
2574    }
2575  }
2576  const f = Object.is(t, -0) || t < 0, h = Math.abs(t), m = h === 1, g = l[e], p = i ? m ? g[1] : g[2] || g[1] : m ? l[e][0] : e;
2577  return f ? `${h} ${p} ago` : `in ${h} ${p}`;
2578}
2579function uS(e, t) {
2580  let r = "";
2581  for (const i of e)
2582    i.literal ? r += i.val : r += t(i.val);
2583  return r;
2584}
2585const H7 = {
2586  D: Gd,
2587  DD: W9,
2588  DDD: J9,
2589  DDDD: e8,
2590  t: t8,
2591  tt: n8,
2592  ttt: r8,
2593  tttt: a8,
2594  T: i8,
2595  TT: o8,
2596  TTT: l8,
2597  TTTT: u8,
2598  f: s8,
2599  ff: f8,
2600  fff: h8,
2601  ffff: g8,
2602  F: c8,
2603  FF: d8,
2604  FFF: m8,
2605  FFFF: p8
2606};
2607let wr = class xs {
2608  static create(t, r = {}) {
2609    return new xs(t, r);
2610  }
2611  static parseFormat(t) {
2612    let r = null, i = "", l = !1;
2613    const s = [];
2614    for (let f = 0; f < t.length; f++) {
2615      const h = t.charAt(f);
2616      h === "'" ? ((i.length > 0 || l) && s.push({
2617        literal: l || /^\s+$/.test(i),
2618        val: i === "" ? "'" : i
2619      }), r = null, i = "", l = !l) : l || h === r ? i += h : (i.length > 0 && s.push({ literal: /^\s+$/.test(i), val: i }), i = h, r = h);
2620    }
2621    return i.length > 0 && s.push({ literal: l || /^\s+$/.test(i), val: i }), s;
2622  }
2623  static macroTokenToFormatOpts(t) {
2624    return H7[t];
2625  }
2626  constructor(t, r) {
2627    this.opts = r, this.loc = t, this.systemLoc = null;
2628  }
2629  formatWithSystemDefault(t, r) {
2630    return this.systemLoc === null && (this.systemLoc = this.loc.redefaultToSystem()), this.systemLoc.dtFormatter(t, { ...this.opts, ...r }).format();
2631  }
2632  dtFormatter(t, r = {}) {
2633    return this.loc.dtFormatter(t, { ...this.opts, ...r });
2634  }
2635  formatDateTime(t, r) {
2636    return this.dtFormatter(t, r).format();
2637  }
2638  formatDateTimeParts(t, r) {
2639    return this.dtFormatter(t, r).formatToParts();
2640  }
2641  formatInterval(t, r) {
2642    return this.dtFormatter(t.start, r).dtf.formatRange(t.start.toJSDate(), t.end.toJSDate());
2643  }
2644  resolvedOptions(t, r) {
2645    return this.dtFormatter(t, r).resolvedOptions();
2646  }
2647  num(t, r = 0, i = void 0) {
2648    if (this.opts.forceSimple)
2649      return _t(t, r);
2650    const l = { ...this.opts };
2651    return r > 0 && (l.padTo = r), i && (l.signDisplay = i), this.loc.numberFormatter(l).format(t);
2652  }
2653  formatDateTimeFromString(t, r) {
2654    const i = this.loc.listingMode() === "en", l = this.loc.outputCalendar && this.loc.outputCalendar !== "gregory", s = (w, T) => this.loc.extract(t, w, T), f = (w) => t.isOffsetFixed && t.offset === 0 && w.allowZ ? "Z" : t.isValid ? t.zone.formatOffset(t.ts, w.format) : "", h = () => i ? L7(t) : s({ hour: "numeric", hourCycle: "h12" }, "dayperiod"), m = (w, T) => i ? U7(t, w) : s(T ? { month: w } : { month: w, day: "numeric" }, "month"), g = (w, T) => i ? z7(t, w) : s(
2655      T ? { weekday: w } : { weekday: w, month: "long", day: "numeric" },
2656      "weekday"
2657    ), p = (w) => {
2658      const T = xs.macroTokenToFormatOpts(w);
2659      return T ? this.formatWithSystemDefault(t, T) : w;
2660    }, b = (w) => i ? j7(t, w) : s({ era: w }, "era"), S = (w) => {
2661      switch (w) {
2662        // ms
2663        case "S":
2664          return this.num(t.millisecond);
2665        case "u":
2666        // falls through
2667        case "SSS":
2668          return this.num(t.millisecond, 3);
2669        // seconds
2670        case "s":
2671          return this.num(t.second);
2672        case "ss":
2673          return this.num(t.second, 2);
2674        // fractional seconds
2675        case "uu":
2676          return this.num(Math.floor(t.millisecond / 10), 2);
2677        case "uuu":
2678          return this.num(Math.floor(t.millisecond / 100));
2679        // minutes
2680        case "m":
2681          return this.num(t.minute);
2682        case "mm":
2683          return this.num(t.minute, 2);
2684        // hours
2685        case "h":
2686          return this.num(t.hour % 12 === 0 ? 12 : t.hour % 12);
2687        case "hh":
2688          return this.num(t.hour % 12 === 0 ? 12 : t.hour % 12, 2);
2689        case "H":
2690          return this.num(t.hour);
2691        case "HH":
2692          return this.num(t.hour, 2);
2693        // offset
2694        case "Z":
2695          return f({ format: "narrow", allowZ: this.opts.allowZ });
2696        case "ZZ":
2697          return f({ format: "short", allowZ: this.opts.allowZ });
2698        case "ZZZ":
2699          return f({ format: "techie", allowZ: this.opts.allowZ });
2700        case "ZZZZ":
2701          return t.zone.offsetName(t.ts, { format: "short", locale: this.loc.locale });
2702        case "ZZZZZ":
2703          return t.zone.offsetName(t.ts, { format: "long", locale: this.loc.locale });
2704        // zone
2705        case "z":
2706          return t.zoneName;
2707        // meridiems
2708        case "a":
2709          return h();
2710        // dates
2711        case "d":
2712          return l ? s({ day: "numeric" }, "day") : this.num(t.day);
2713        case "dd":
2714          return l ? s({ day: "2-digit" }, "day") : this.num(t.day, 2);
2715        // weekdays - standalone
2716        case "c":
2717          return this.num(t.weekday);
2718        case "ccc":
2719          return g("short", !0);
2720        case "cccc":
2721          return g("long", !0);
2722        case "ccccc":
2723          return g("narrow", !0);
2724        // weekdays - format
2725        case "E":
2726          return this.num(t.weekday);
2727        case "EEE":
2728          return g("short", !1);
2729        case "EEEE":
2730          return g("long", !1);
2731        case "EEEEE":
2732          return g("narrow", !1);
2733        // months - standalone
2734        case "L":
2735          return l ? s({ month: "numeric", day: "numeric" }, "month") : this.num(t.month);
2736        case "LL":
2737          return l ? s({ month: "2-digit", day: "numeric" }, "month") : this.num(t.month, 2);
2738        case "LLL":
2739          return m("short", !0);
2740        case "LLLL":
2741          return m("long", !0);
2742        case "LLLLL":
2743          return m("narrow", !0);
2744        // months - format
2745        case "M":
2746          return l ? s({ month: "numeric" }, "month") : this.num(t.month);
2747        case "MM":
2748          return l ? s({ month: "2-digit" }, "month") : this.num(t.month, 2);
2749        case "MMM":
2750          return m("short", !1);
2751        case "MMMM":
2752          return m("long", !1);
2753        case "MMMMM":
2754          return m("narrow", !1);
2755        // years
2756        case "y":
2757          return l ? s({ year: "numeric" }, "year") : this.num(t.year);
2758        case "yy":
2759          return l ? s({ year: "2-digit" }, "year") : this.num(t.year.toString().slice(-2), 2);
2760        case "yyyy":
2761          return l ? s({ year: "numeric" }, "year") : this.num(t.year, 4);
2762        case "yyyyyy":
2763          return l ? s({ year: "numeric" }, "year") : this.num(t.year, 6);
2764        // eras
2765        case "G":
2766          return b("short");
2767        case "GG":
2768          return b("long");
2769        case "GGGGG":
2770          return b("narrow");
2771        case "kk":
2772          return this.num(t.weekYear.toString().slice(-2), 2);
2773        case "kkkk":
2774          return this.num(t.weekYear, 4);
2775        case "W":
2776          return this.num(t.weekNumber);
2777        case "WW":
2778          return this.num(t.weekNumber, 2);
2779        case "n":
2780          return this.num(t.localWeekNumber);
2781        case "nn":
2782          return this.num(t.localWeekNumber, 2);
2783        case "ii":
2784          return this.num(t.localWeekYear.toString().slice(-2), 2);
2785        case "iiii":
2786          return this.num(t.localWeekYear, 4);
2787        case "o":
2788          return this.num(t.ordinal);
2789        case "ooo":
2790          return this.num(t.ordinal, 3);
2791        case "q":
2792          return this.num(t.quarter);
2793        case "qq":
2794          return this.num(t.quarter, 2);
2795        case "X":
2796          return this.num(Math.floor(t.ts / 1e3));
2797        case "x":
2798          return this.num(t.ts);
2799        default:
2800          return p(w);
2801      }
2802    };
2803    return uS(xs.parseFormat(r), S);
2804  }
2805  formatDurationFromString(t, r) {
2806    const i = this.opts.signMode === "negativeLargestOnly" ? -1 : 1, l = (p) => {
2807      switch (p[0]) {
2808        case "S":
2809          return "milliseconds";
2810        case "s":
2811          return "seconds";
2812        case "m":
2813          return "minutes";
2814        case "h":
2815          return "hours";
2816        case "d":
2817          return "days";
2818        case "w":
2819          return "weeks";
2820        case "M":
2821          return "months";
2822        case "y":
2823          return "years";
2824        default:
2825          return null;
2826      }
2827    }, s = (p, b) => (S) => {
2828      const w = l(S);
2829      if (w) {
2830        const T = b.isNegativeDuration && w !== b.largestUnit ? i : 1;
2831        let N;
2832        return this.opts.signMode === "negativeLargestOnly" && w !== b.largestUnit ? N = "never" : this.opts.signMode === "all" ? N = "always" : N = "auto", this.num(p.get(w) * T, S.length, N);
2833      } else
2834        return S;
2835    }, f = xs.parseFormat(r), h = f.reduce(
2836      (p, { literal: b, val: S }) => b ? p : p.concat(S),
2837      []
2838    ), m = t.shiftTo(...h.map(l).filter((p) => p)), g = {
2839      isNegativeDuration: m < 0,
2840      // this relies on "collapsed" being based on "shiftTo", which builds up the object
2841      // in order
2842      largestUnit: Object.keys(m.values)[0]
2843    };
2844    return uS(f, s(m, g));
2845  }
2846};
2847const k8 = /[A-Za-z_+-]{1,256}(?::?\/[A-Za-z0-9_+-]{1,256}(?:\/[A-Za-z0-9_+-]{1,256})?)?/;
2848function nu(...e) {
2849  const t = e.reduce((r, i) => r + i.source, "");
2850  return RegExp(`^${t}$`);
2851}
2852function ru(...e) {
2853  return (t) => e.reduce(
2854    ([r, i, l], s) => {
2855      const [f, h, m] = s(t, l);
2856      return [{ ...r, ...f }, h || i, m];
2857    },
2858    [{}, null, 1]
2859  ).slice(0, 2);
2860}
2861function au(e, ...t) {
2862  if (e == null)
2863    return [null, null];
2864  for (const [r, i] of t) {
2865    const l = r.exec(e);
2866    if (l)
2867      return i(l);
2868  }
2869  return [null, null];
2870}
2871function L8(...e) {
2872  return (t, r) => {
2873    const i = {};
2874    let l;
2875    for (l = 0; l < e.length; l++)
2876      i[e[l]] = fi(t[r + l]);
2877    return [i, null, r + l];
2878  };
2879}
2880const z8 = /(?:([Zz])|([+-]\d\d)(?::?(\d\d))?)/, V7 = `(?:${z8.source}?(?:\\[(${k8.source})\\])?)?`, Gp = /(\d\d)(?::?(\d\d)(?::?(\d\d)(?:[.,](\d{1,30}))?)?)?/, U8 = RegExp(`${Gp.source}${V7}`), Yp = RegExp(`(?:[Tt]${U8.source})?`), B7 = /([+-]\d{6}|\d{4})(?:-?(\d\d)(?:-?(\d\d))?)?/, q7 = /(\d{4})-?W(\d\d)(?:-?(\d))?/, G7 = /(\d{4})-?(\d{3})/, Y7 = L8("weekYear", "weekNumber", "weekDay"), Z7 = L8("year", "ordinal"), Q7 = /(\d{4})-(\d\d)-(\d\d)/, j8 = RegExp(
2881  `${Gp.source} ?(?:${z8.source}|(${k8.source}))?`
2882), K7 = RegExp(`(?: ${j8.source})?`);
2883function zl(e, t, r) {
2884  const i = e[t];
2885  return Te(i) ? r : fi(i);
2886}
2887function X7(e, t) {
2888  return [{
2889    year: zl(e, t),
2890    month: zl(e, t + 1, 1),
2891    day: zl(e, t + 2, 1)
2892  }, null, t + 3];
2893}
2894function iu(e, t) {
2895  return [{
2896    hours: zl(e, t, 0),
2897    minutes: zl(e, t + 1, 0),
2898    seconds: zl(e, t + 2, 0),
2899    milliseconds: Bp(e[t + 3])
2900  }, null, t + 4];
2901}
2902function bc(e, t) {
2903  const r = !e[t] && !e[t + 1], i = _h(e[t + 1], e[t + 2]), l = r ? null : vn.instance(i);
2904  return [{}, l, t + 3];
2905}
2906function Sc(e, t) {
2907  const r = e[t] ? Ea.create(e[t]) : null;
2908  return [{}, r, t + 1];
2909}
2910const W7 = RegExp(`^T?${Gp.source}$`), J7 = /^-?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)?)?)$/;
2911function eO(e) {
2912  const [t, r, i, l, s, f, h, m, g] = e, p = t[0] === "-", b = m && m[0] === "-", S = (w, T = !1) => w !== void 0 && (T || w && p) ? -w : w;
2913  return [
2914    {
2915      years: S(Ki(r)),
2916      months: S(Ki(i)),
2917      weeks: S(Ki(l)),
2918      days: S(Ki(s)),
2919      hours: S(Ki(f)),
2920      minutes: S(Ki(h)),
2921      seconds: S(Ki(m), m === "-0"),
2922      milliseconds: S(Bp(g), b)
2923    }
2924  ];
2925}
2926const tO = {
2927  GMT: 0,
2928  EDT: -240,
2929  EST: -300,
2930  CDT: -300,
2931  CST: -360,
2932  MDT: -360,
2933  MST: -420,
2934  PDT: -420,
2935  PST: -480
2936};
2937function Zp(e, t, r, i, l, s, f) {
2938  const h = {
2939    year: t.length === 2 ? Fg(fi(t)) : fi(t),
2940    month: _8.indexOf(r) + 1,
2941    day: fi(i),
2942    hour: fi(l),
2943    minute: fi(s)
2944  };
2945  return f && (h.second = fi(f)), e && (h.weekday = e.length > 3 ? R8.indexOf(e) + 1 : D8.indexOf(e) + 1), h;
2946}
2947const nO = /^(?:(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)))$/;
2948function rO(e) {
2949  const [
2950    ,
2951    t,
2952    r,
2953    i,
2954    l,
2955    s,
2956    f,
2957    h,
2958    m,
2959    g,
2960    p,
2961    b
2962  ] = e, S = Zp(t, l, i, r, s, f, h);
2963  let w;
2964  return m ? w = tO[m] : g ? w = 0 : w = _h(p, b), [S, new vn(w)];
2965}
2966function aO(e) {
2967  return e.replace(/\([^()]*\)|[\n\t]/g, " ").replace(/(\s\s+)/g, " ").trim();
2968}
2969const iO = /^(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$/, oO = /^(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$/, lO = /^(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})$/;
2970function sS(e) {
2971  const [, t, r, i, l, s, f, h] = e;
2972  return [Zp(t, l, i, r, s, f, h), vn.utcInstance];
2973}
2974function uO(e) {
2975  const [, t, r, i, l, s, f, h] = e;
2976  return [Zp(t, h, r, i, l, s, f), vn.utcInstance];
2977}
2978const sO = nu(B7, Yp), cO = nu(q7, Yp), fO = nu(G7, Yp), dO = nu(U8), F8 = ru(
2979  X7,
2980  iu,
2981  bc,
2982  Sc
2983), hO = ru(
2984  Y7,
2985  iu,
2986  bc,
2987  Sc
2988), mO = ru(
2989  Z7,
2990  iu,
2991  bc,
2992  Sc
2993), gO = ru(
2994  iu,
2995  bc,
2996  Sc
2997);
2998function pO(e) {
2999  return au(
3000    e,
3001    [sO, F8],
3002    [cO, hO],
3003    [fO, mO],
3004    [dO, gO]
3005  );
3006}
3007function yO(e) {
3008  return au(aO(e), [nO, rO]);
3009}
3010function vO(e) {
3011  return au(
3012    e,
3013    [iO, sS],
3014    [oO, sS],
3015    [lO, uO]
3016  );
3017}
3018function bO(e) {
3019  return au(e, [J7, eO]);
3020}
3021const SO = ru(iu);
3022function $O(e) {
3023  return au(e, [W7, SO]);
3024}
3025const EO = nu(Q7, K7), TO = nu(j8), CO = ru(
3026  iu,
3027  bc,
3028  Sc
3029);
3030function wO(e) {
3031  return au(
3032    e,
3033    [EO, F8],
3034    [TO, CO]
3035  );
3036}
3037const cS = "Invalid Duration", H8 = {
3038  weeks: {
3039    days: 7,
3040    hours: 168,
3041    minutes: 10080,
3042    seconds: 10080 * 60,
3043    milliseconds: 10080 * 60 * 1e3
3044  },
3045  days: {
3046    hours: 24,
3047    minutes: 1440,
3048    seconds: 1440 * 60,
3049    milliseconds: 1440 * 60 * 1e3
3050  },
3051  hours: { minutes: 60, seconds: 3600, milliseconds: 3600 * 1e3 },
3052  minutes: { seconds: 60, milliseconds: 60 * 1e3 },
3053  seconds: { milliseconds: 1e3 }
3054}, OO = {
3055  years: {
3056    quarters: 4,
3057    months: 12,
3058    weeks: 52,
3059    days: 365,
3060    hours: 365 * 24,
3061    minutes: 365 * 24 * 60,
3062    seconds: 365 * 24 * 60 * 60,
3063    milliseconds: 365 * 24 * 60 * 60 * 1e3
3064  },
3065  quarters: {
3066    months: 3,
3067    weeks: 13,
3068    days: 91,
3069    hours: 2184,
3070    minutes: 2184 * 60,
3071    seconds: 2184 * 60 * 60,
3072    milliseconds: 2184 * 60 * 60 * 1e3
3073  },
3074  months: {
3075    weeks: 4,
3076    days: 30,
3077    hours: 720,
3078    minutes: 720 * 60,
3079    seconds: 720 * 60 * 60,
3080    milliseconds: 720 * 60 * 60 * 1e3
3081  },
3082  ...H8
3083}, lr = 146097 / 400, pl = 146097 / 4800, NO = {
3084  years: {
3085    quarters: 4,
3086    months: 12,
3087    weeks: lr / 7,
3088    days: lr,
3089    hours: lr * 24,
3090    minutes: lr * 24 * 60,
3091    seconds: lr * 24 * 60 * 60,
3092    milliseconds: lr * 24 * 60 * 60 * 1e3
3093  },
3094  quarters: {
3095    months: 3,
3096    weeks: lr / 28,
3097    days: lr / 4,
3098    hours: lr * 24 / 4,
3099    minutes: lr * 24 * 60 / 4,
3100    seconds: lr * 24 * 60 * 60 / 4,
3101    milliseconds: lr * 24 * 60 * 60 * 1e3 / 4
3102  },
3103  months: {
3104    weeks: pl / 7,
3105    days: pl,
3106    hours: pl * 24,
3107    minutes: pl * 24 * 60,
3108    seconds: pl * 24 * 60 * 60,
3109    milliseconds: pl * 24 * 60 * 60 * 1e3
3110  },
3111  ...H8
3112}, so = [
3113  "years",
3114  "quarters",
3115  "months",
3116  "weeks",
3117  "days",
3118  "hours",
3119  "minutes",
3120  "seconds",
3121  "milliseconds"
3122], AO = so.slice(0).reverse();
3123function ma(e, t, r = !1) {
3124  const i = {
3125    values: r ? t.values : { ...e.values, ...t.values || {} },
3126    loc: e.loc.clone(t.loc),
3127    conversionAccuracy: t.conversionAccuracy || e.conversionAccuracy,
3128    matrix: t.matrix || e.matrix
3129  };
3130  return new Fe(i);
3131}
3132function V8(e, t) {
3133  let r = t.milliseconds ?? 0;
3134  for (const i of AO.slice(1))
3135    t[i] && (r += t[i] * e[i].milliseconds);
3136  return r;
3137}
3138function fS(e, t) {
3139  const r = V8(e, t) < 0 ? -1 : 1;
3140  so.reduceRight((i, l) => {
3141    if (Te(t[l]))
3142      return i;
3143    if (i) {
3144      const s = t[i] * r, f = e[l][i], h = Math.floor(s / f);
3145      t[l] += h * r, t[i] -= h * f * r;
3146    }
3147    return l;
3148  }, null), so.reduce((i, l) => {
3149    if (Te(t[l]))
3150      return i;
3151    if (i) {
3152      const s = t[i] % 1;
3153      t[i] -= s, t[l] += s * e[i][l];
3154    }
3155    return l;
3156  }, null);
3157}
3158function dS(e) {
3159  const t = {};
3160  for (const [r, i] of Object.entries(e))
3161    i !== 0 && (t[r] = i);
3162  return t;
3163}
3164class Fe {
3165  /**
3166   * @private
3167   */
3168  constructor(t) {
3169    const r = t.conversionAccuracy === "longterm" || !1;
3170    let i = r ? NO : OO;
3171    t.matrix && (i = t.matrix), this.values = t.values, this.loc = t.loc || Ke.create(), this.conversionAccuracy = r ? "longterm" : "casual", this.invalid = t.invalid || null, this.matrix = i, this.isLuxonDuration = !0;
3172  }
3173  /**
3174   * Create Duration from a number of milliseconds.
3175   * @param {number} count of milliseconds
3176   * @param {Object} opts - options for parsing
3177   * @param {string} [opts.locale='en-US'] - the locale to use
3178   * @param {string} opts.numberingSystem - the numbering system to use
3179   * @param {string} [opts.conversionAccuracy='casual'] - the conversion system to use
3180   * @return {Duration}
3181   */
3182  static fromMillis(t, r) {
3183    return Fe.fromObject({ milliseconds: t }, r);
3184  }
3185  /**
3186   * Create a Duration from a JavaScript object with keys like 'years' and 'hours'.
3187   * If this object is empty then a zero milliseconds duration is returned.
3188   * @param {Object} obj - the object to create the DateTime from
3189   * @param {number} obj.years
3190   * @param {number} obj.quarters
3191   * @param {number} obj.months
3192   * @param {number} obj.weeks
3193   * @param {number} obj.days
3194   * @param {number} obj.hours
3195   * @param {number} obj.minutes
3196   * @param {number} obj.seconds
3197   * @param {number} obj.milliseconds
3198   * @param {Object} [opts=[]] - options for creating this Duration
3199   * @param {string} [opts.locale='en-US'] - the locale to use
3200   * @param {string} opts.numberingSystem - the numbering system to use
3201   * @param {string} [opts.conversionAccuracy='casual'] - the preset conversion system to use
3202   * @param {string} [opts.matrix=Object] - the custom conversion system to use
3203   * @return {Duration}
3204   */
3205  static fromObject(t, r = {}) {
3206    if (t == null || typeof t != "object")
3207      throw new cn(
3208        `Duration.fromObject: argument expected to be an object, got ${t === null ? "null" : typeof t}`
3209      );
3210    return new Fe({
3211      values: Qd(t, Fe.normalizeUnit),
3212      loc: Ke.fromObject(r),
3213      conversionAccuracy: r.conversionAccuracy,
3214      matrix: r.matrix
3215    });
3216  }
3217  /**
3218   * Create a Duration from DurationLike.
3219   *
3220   * @param {Object | number | Duration} durationLike
3221   * One of:
3222   * - object with keys like 'years' and 'hours'.
3223   * - number representing milliseconds
3224   * - Duration instance
3225   * @return {Duration}
3226   */
3227  static fromDurationLike(t) {
3228    if (pi(t))
3229      return Fe.fromMillis(t);
3230    if (Fe.isDuration(t))
3231      return t;
3232    if (typeof t == "object")
3233      return Fe.fromObject(t);
3234    throw new cn(
3235      `Unknown duration argument ${t} of type ${typeof t}`
3236    );
3237  }
3238  /**
3239   * Create a Duration from an ISO 8601 duration string.
3240   * @param {string} text - text to parse
3241   * @param {Object} opts - options for parsing
3242   * @param {string} [opts.locale='en-US'] - the locale to use
3243   * @param {string} opts.numberingSystem - the numbering system to use
3244   * @param {string} [opts.conversionAccuracy='casual'] - the preset conversion system to use
3245   * @param {string} [opts.matrix=Object] - the preset conversion system to use
3246   * @see https://en.wikipedia.org/wiki/ISO_8601#Durations
3247   * @example Duration.fromISO('P3Y6M1W4DT12H30M5S').toObject() //=> { years: 3, months: 6, weeks: 1, days: 4, hours: 12, minutes: 30, seconds: 5 }
3248   * @example Duration.fromISO('PT23H').toObject() //=> { hours: 23 }
3249   * @example Duration.fromISO('P5Y3M').toObject() //=> { years: 5, months: 3 }
3250   * @return {Duration}
3251   */
3252  static fromISO(t, r) {
3253    const [i] = bO(t);
3254    return i ? Fe.fromObject(i, r) : Fe.invalid("unparsable", `the input "${t}" can't be parsed as ISO 8601`);
3255  }
3256  /**
3257   * Create a Duration from an ISO 8601 time string.
3258   * @param {string} text - text to parse
3259   * @param {Object} opts - options for parsing
3260   * @param {string} [opts.locale='en-US'] - the locale to use
3261   * @param {string} opts.numberingSystem - the numbering system to use
3262   * @param {string} [opts.conversionAccuracy='casual'] - the preset conversion system to use
3263   * @param {string} [opts.matrix=Object] - the conversion system to use
3264   * @see https://en.wikipedia.org/wiki/ISO_8601#Times
3265   * @example Duration.fromISOTime('11:22:33.444').toObject() //=> { hours: 11, minutes: 22, seconds: 33, milliseconds: 444 }
3266   * @example Duration.fromISOTime('11:00').toObject() //=> { hours: 11, minutes: 0, seconds: 0 }
3267   * @example Duration.fromISOTime('T11:00').toObject() //=> { hours: 11, minutes: 0, seconds: 0 }
3268   * @example Duration.fromISOTime('1100').toObject() //=> { hours: 11, minutes: 0, seconds: 0 }
3269   * @example Duration.fromISOTime('T1100').toObject() //=> { hours: 11, minutes: 0, seconds: 0 }
3270   * @return {Duration}
3271   */
3272  static fromISOTime(t, r) {
3273    const [i] = $O(t);
3274    return i ? Fe.fromObject(i, r) : Fe.invalid("unparsable", `the input "${t}" can't be parsed as ISO 8601`);
3275  }
3276  /**
3277   * Create an invalid Duration.
3278   * @param {string} reason - simple string of why this datetime is invalid. Should not contain parameters or anything else data-dependent
3279   * @param {string} [explanation=null] - longer explanation, may include parameters and other useful debugging information
3280   * @return {Duration}
3281   */
3282  static invalid(t, r = null) {
3283    if (!t)
3284      throw new cn("need to specify a reason the Duration is invalid");
3285    const i = t instanceof Or ? t : new Or(t, r);
3286    if ($t.throwOnInvalid)
3287      throw new e7(i);
3288    return new Fe({ invalid: i });
3289  }
3290  /**
3291   * @private
3292   */
3293  static normalizeUnit(t) {
3294    const r = {
3295      year: "years",
3296      years: "years",
3297      quarter: "quarters",
3298      quarters: "quarters",
3299      month: "months",
3300      months: "months",
3301      week: "weeks",
3302      weeks: "weeks",
3303      day: "days",
3304      days: "days",
3305      hour: "hours",
3306      hours: "hours",
3307      minute: "minutes",
3308      minutes: "minutes",
3309      second: "seconds",
3310      seconds: "seconds",
3311      millisecond: "milliseconds",
3312      milliseconds: "milliseconds"
3313    }[t && t.toLowerCase()];
3314    if (!r) throw new X9(t);
3315    return r;
3316  }
3317  /**
3318   * Check if an object is a Duration. Works across context boundaries
3319   * @param {object} o
3320   * @return {boolean}
3321   */
3322  static isDuration(t) {
3323    return t && t.isLuxonDuration || !1;
3324  }
3325  /**
3326   * Get  the locale of a Duration, such 'en-GB'
3327   * @type {string}
3328   */
3329  get locale() {
3330    return this.isValid ? this.loc.locale : null;
3331  }
3332  /**
3333   * Get the numbering system of a Duration, such 'beng'. The numbering system is used when formatting the Duration
3334   *
3335   * @type {string}
3336   */
3337  get numberingSystem() {
3338    return this.isValid ? this.loc.numberingSystem : null;
3339  }
3340  /**
3341   * Returns a string representation of this Duration formatted according to the specified format str