@dmsi/wedgekit-react 1.0.1 → 2.0.1

package/dist/node_modules/@js-temporal/polyfill/dist/index.esm.js

@@ -0,0 +1,3913 @@
+import y from "../../../jsbi/dist/jsbi.js";
+const ke = y.BigInt(0), $n = y.BigInt(1), Xr = y.BigInt(2), ai = y.BigInt(10), ii = y.BigInt(24), si = y.BigInt(60), ci = y.BigInt(1e3), Un = y.BigInt(1e6), En = y.BigInt(1e9), Xo = y.multiply(y.BigInt(3600), En), di = y.multiply(si, En), bt = y.multiply(Xo, ii);
+function nt(t) {
+  return typeof t == "bigint" ? y.BigInt(t.toString(10)) : t;
+}
+function Qo(t) {
+  return y.equal(y.remainder(t, Xr), ke);
+}
+function It(t) {
+  return y.lessThan(t, ke) ? y.unaryMinus(t) : t;
+}
+function tr(t, e) {
+  return y.lessThan(t, e) ? -1 : y.greaterThan(t, e) ? 1 : 0;
+}
+function mn(t, e) {
+  return { quotient: y.divide(t, e), remainder: y.remainder(t, e) };
+}
+var wo, vo;
+const I = "slot-epochNanoSeconds", C = "slot-iso-date", P = "slot-iso-date-time", z = "slot-time", b = "slot-calendar", ea = "slot-date-brand", ta = "slot-year-month-brand", na = "slot-month-day-brand", x = "slot-time-zone", de = "slot-years", he = "slot-months", Te = "slot-weeks", ue = "slot-days", le = "slot-hours", me = "slot-minutes", fe = "slot-seconds", ye = "slot-milliseconds", ge = "slot-microseconds", Ie = "slot-nanoseconds", ra = "date", oa = "ym", aa = "md", ia = "time", sa = "datetime", ca = "instant", xt = "original", At = "timezone-canonical", kr = "timezone-original", fn = "calendar-id", da = "locale", Nr = "options", ha = /* @__PURE__ */ new WeakMap(), jr = /* @__PURE__ */ Symbol.for("@@Temporal__GetSlots");
+(wo = globalThis)[jr] || (wo[jr] = function(t) {
+  return ha.get(t);
+});
+const mr = globalThis[jr], xr = /* @__PURE__ */ Symbol.for("@@Temporal__CreateSlots");
+(vo = globalThis)[xr] || (vo[xr] = function(t) {
+  ha.set(t, /* @__PURE__ */ Object.create(null));
+});
+const lt = globalThis[xr];
+function Ee(t, ...e) {
+  if (!t || typeof t != "object") return !1;
+  const n = mr(t);
+  return !!n && e.every(((r) => r in n));
+}
+function c(t, e) {
+  const n = mr(t)?.[e];
+  if (n === void 0) throw new TypeError(`Missing internal slot ${e}`);
+  return n;
+}
+function R(t, e, n) {
+  const r = mr(t);
+  if (r === void 0) throw new TypeError("Missing slots for the given container");
+  if (r[e]) throw new TypeError(`${e} already has set`);
+  r[e] = n;
+}
+const Lr = {};
+function mt(t, e) {
+  Object.defineProperty(t.prototype, Symbol.toStringTag, { value: e, writable: !1, enumerable: !1, configurable: !0 });
+  const n = Object.getOwnPropertyNames(t);
+  for (let o = 0; o < n.length; o++) {
+    const a = n[o], i = Object.getOwnPropertyDescriptor(t, a);
+    i.configurable && i.enumerable && (i.enumerable = !1, Object.defineProperty(t, a, i));
+  }
+  const r = Object.getOwnPropertyNames(t.prototype);
+  for (let o = 0; o < r.length; o++) {
+    const a = r[o], i = Object.getOwnPropertyDescriptor(t.prototype, a);
+    i.configurable && i.enumerable && (i.enumerable = !1, Object.defineProperty(t.prototype, a, i));
+  }
+  Ur(e, t), Ur(`${e}.prototype`, t.prototype);
+}
+function Ur(t, e) {
+  const n = `%${t}%`;
+  if (Lr[n] !== void 0) throw new Error(`intrinsic ${t} already exists`);
+  Lr[n] = e;
+}
+function te(t) {
+  return Lr[t];
+}
+function Wt(t, e) {
+  let n = t;
+  if (n === 0) return { div: n, mod: n };
+  const r = Math.sign(n);
+  n = Math.abs(n);
+  const o = Math.trunc(1 + Math.log10(n));
+  if (e >= o) return { div: 0 * r, mod: r * n };
+  if (e === 0) return { div: r * n, mod: 0 * r };
+  const a = n.toPrecision(o);
+  return { div: r * Number.parseInt(a.slice(0, o - e), 10), mod: r * Number.parseInt(a.slice(o - e), 10) };
+}
+function $r(t, e, n) {
+  let r = t, o = n;
+  if (r === 0) return o;
+  const a = Math.sign(r) || Math.sign(o);
+  r = Math.abs(r), o = Math.abs(o);
+  const i = r.toPrecision(Math.trunc(1 + Math.log10(r)));
+  if (o === 0) return a * Number.parseInt(i + "0".repeat(e), 10);
+  const s = i + o.toPrecision(Math.trunc(1 + Math.log10(o))).padStart(e, "0");
+  return a * Number.parseInt(s, 10);
+}
+function fr(t, e) {
+  const n = e === "negative";
+  switch (t) {
+    case "ceil":
+      return n ? "zero" : "infinity";
+    case "floor":
+      return n ? "infinity" : "zero";
+    case "expand":
+      return "infinity";
+    case "trunc":
+      return "zero";
+    case "halfCeil":
+      return n ? "half-zero" : "half-infinity";
+    case "halfFloor":
+      return n ? "half-infinity" : "half-zero";
+    case "halfExpand":
+      return "half-infinity";
+    case "halfTrunc":
+      return "half-zero";
+    case "halfEven":
+      return "half-even";
+  }
+}
+function yr(t, e, n, r, o) {
+  return o === "zero" ? t : o === "infinity" ? e : n < 0 ? t : n > 0 ? e : o === "half-zero" ? t : o === "half-infinity" ? e : r ? t : e;
+}
+class k {
+  constructor(e) {
+    this.totalNs = nt(e), this.sec = y.toNumber(y.divide(this.totalNs, En)), this.subsec = y.toNumber(y.remainder(this.totalNs, En));
+  }
+  static validateNew(e, n) {
+    if (y.greaterThan(It(e), k.MAX)) throw new RangeError(`${n} of duration time units cannot exceed ${k.MAX} s`);
+    return new k(e);
+  }
+  static fromEpochNsDiff(e, n) {
+    const r = y.subtract(nt(e), nt(n));
+    return new k(r);
+  }
+  static fromComponents(e, n, r, o, a, i) {
+    const s = y.add(y.add(y.add(y.add(y.add(y.BigInt(i), y.multiply(y.BigInt(a), ci)), y.multiply(y.BigInt(o), Un)), y.multiply(y.BigInt(r), En)), y.multiply(y.BigInt(n), di)), y.multiply(y.BigInt(e), Xo));
+    return k.validateNew(s, "total");
+  }
+  abs() {
+    return new k(It(this.totalNs));
+  }
+  add(e) {
+    return k.validateNew(y.add(this.totalNs, e.totalNs), "sum");
+  }
+  add24HourDays(e) {
+    return k.validateNew(y.add(this.totalNs, y.multiply(y.BigInt(e), bt)), "sum");
+  }
+  addToEpochNs(e) {
+    return y.add(nt(e), this.totalNs);
+  }
+  cmp(e) {
+    return tr(this.totalNs, e.totalNs);
+  }
+  divmod(e) {
+    const { quotient: n, remainder: r } = mn(this.totalNs, y.BigInt(e));
+    return { quotient: y.toNumber(n), remainder: new k(r) };
+  }
+  fdiv(e) {
+    const n = nt(e), r = y.BigInt(n);
+    let { quotient: o, remainder: a } = mn(this.totalNs, r);
+    const i = [];
+    let s;
+    const h = (y.lessThan(this.totalNs, ke) ? -1 : 1) * Math.sign(y.toNumber(n));
+    for (; !y.equal(a, ke) && i.length < 50; ) a = y.multiply(a, ai), { quotient: s, remainder: a } = mn(a, r), i.push(Math.abs(y.toNumber(s)));
+    return h * +(It(o).toString() + "." + i.join(""));
+  }
+  isZero() {
+    return y.equal(this.totalNs, ke);
+  }
+  round(e, n) {
+    const r = nt(e);
+    if (y.equal(r, $n)) return this;
+    const { quotient: o, remainder: a } = mn(this.totalNs, r), i = y.lessThan(this.totalNs, ke) ? "negative" : "positive", s = y.multiply(It(o), r), h = y.add(s, r), d = tr(It(y.multiply(a, Xr)), r), u = fr(n, i), l = y.equal(It(this.totalNs), s) ? s : yr(s, h, d, Qo(o), u), m = i === "positive" ? l : y.unaryMinus(l);
+    return k.validateNew(m, "rounding");
+  }
+  sign() {
+    return this.cmp(new k(ke));
+  }
+  subtract(e) {
+    return k.validateNew(y.subtract(this.totalNs, e.totalNs), "difference");
+  }
+}
+k.MAX = y.BigInt("9007199254740991999999999"), k.ZERO = new k(ke);
+const bo = /[A-Za-z._][A-Za-z._0-9+-]*/, Pn = new RegExp(`(?:${/(?:[+-](?:[01][0-9]|2[0-3])(?::?[0-5][0-9])?)/.source}|(?:${bo.source})(?:\\/(?:${bo.source}))*)`), ua = /(?:[+-]\d{6}|\d{4})/, nr = /(?:0[1-9]|1[0-2])/, Pr = /(?:0[1-9]|[12]\d|3[01])/, hi = new RegExp(`(${ua.source})(?:-(${nr.source})-(${Pr.source})|(${nr.source})(${Pr.source}))`), la = /(\d{2})(?::(\d{2})(?::(\d{2})(?:[.,](\d{1,9}))?)?|(\d{2})(?:(\d{2})(?:[.,](\d{1,9}))?)?)?/, ma = /((?:[+-])(?:[01][0-9]|2[0-3])(?::?(?:[0-5][0-9])(?::?(?:[0-5][0-9])(?:[.,](?:\d{1,9}))?)?)?)/, fa = new RegExp(`([zZ])|${ma.source}?`), Gt = /\[(!)?([a-z_][a-z0-9_-]*)=([A-Za-z0-9]+(?:-[A-Za-z0-9]+)*)\]/g, ui = new RegExp([`^${hi.source}`, `(?:(?:[tT]|\\s+)${la.source}(?:${fa.source})?)?`, `(?:\\[!?(${Pn.source})\\])?`, `((?:${Gt.source})*)$`].join("")), li = new RegExp([`^[tT]?${la.source}`, `(?:${fa.source})?`, `(?:\\[!?${Pn.source}\\])?`, `((?:${Gt.source})*)$`].join("")), mi = new RegExp(`^(${ua.source})-?(${nr.source})(?:\\[!?${Pn.source}\\])?((?:${Gt.source})*)$`), fi = new RegExp(`^(?:--)?(${nr.source})-?(${Pr.source})(?:\\[!?${Pn.source}\\])?((?:${Gt.source})*)$`), Or = /(\d+)(?:[.,](\d{1,9}))?/, yi = new RegExp(`(?:${Or.source}H)?(?:${Or.source}M)?(?:${Or.source}S)?`), gi = new RegExp(`^([+-])?P${/(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)W)?(?:(\d+)D)?/.source}(?:T(?!$)${yi.source})?$`, "i"), Et = 864e5, rr = 1e6 * Et, pi = 6e10, ya = 1e8 * Et, Kt = Ge(ya), On = y.unaryMinus(Kt), wi = y.add(y.subtract(On, bt), $n), vi = y.subtract(y.add(Kt, bt), $n), bi = 146097 * Et, Eo = -271821, Mo = 275760, Mn = Date.UTC(1847, 0, 1), Ei = ["iso8601", "hebrew", "islamic", "islamic-umalqura", "islamic-tbla", "islamic-civil", "islamic-rgsa", "islamicc", "persian", "ethiopic", "ethioaa", "ethiopic-amete-alem", "coptic", "chinese", "dangi", "roc", "indian", "buddhist", "japanese", "gregory"], Mi = /* @__PURE__ */ new Set(["ACT", "AET", "AGT", "ART", "AST", "BET", "BST", "CAT", "CNT", "CST", "CTT", "EAT", "ECT", "IET", "IST", "JST", "MIT", "NET", "NST", "PLT", "PNT", "PRT", "PST", "SST", "VST"]);
+function A(t) {
+  return typeof t == "object" && t !== null || typeof t == "function";
+}
+function gr(t) {
+  if (typeof t == "bigint") throw new TypeError("Cannot convert BigInt to number");
+  return Number(t);
+}
+function pr(t) {
+  if (typeof t == "symbol") throw new TypeError("Cannot convert a Symbol value to a String");
+  return String(t);
+}
+function $(t) {
+  const e = gr(t);
+  if (e === 0) return 0;
+  if (Number.isNaN(e) || e === 1 / 0 || e === -1 / 0) throw new RangeError("invalid number value");
+  const n = Math.trunc(e);
+  return n === 0 ? 0 : n;
+}
+function Do(t, e) {
+  const n = $(t);
+  if (n <= 0)
+    throw e !== void 0 ? new RangeError(`property '${e}' cannot be a a number less than one`) : new RangeError("Cannot convert a number less than one to a positive integer");
+  return n;
+}
+function ze(t) {
+  const e = gr(t);
+  if (Number.isNaN(e)) throw new RangeError("not a number");
+  if (e === 1 / 0 || e === -1 / 0) throw new RangeError("infinity is out of range");
+  if (!(function(n) {
+    if (typeof n != "number" || Number.isNaN(n) || n === 1 / 0 || n === -1 / 0) return !1;
+    const r = Math.abs(n);
+    return Math.floor(r) === r;
+  })(e)) throw new RangeError(`unsupported fractional value ${t}`);
+  return e === 0 ? 0 : e;
+}
+function Yn(t, e) {
+  return String(t).padStart(e, "0");
+}
+function _(t) {
+  if (typeof t != "string") throw new TypeError(`expected a string, not ${String(t)}`);
+  return t;
+}
+function Zr(t, e) {
+  if (A(t)) {
+    const n = t?.toString();
+    if (typeof n == "string" || typeof n == "number") return n;
+    throw new TypeError("Cannot convert object to primitive value");
+  }
+  return t;
+}
+const Fr = ["era", "eraYear", "year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond", "offset", "timeZone"], Di = { era: pr, eraYear: $, year: $, month: Do, monthCode: function(t) {
+  const e = _(Zr(t));
+  if (e.length < 3 || e.length > 4 || e[0] !== "M" || "0123456789".indexOf(e[1]) === -1 || "0123456789".indexOf(e[2]) === -1 || e[1] + e[2] === "00" && e[3] !== "L" || e[3] !== "L" && e[3] !== void 0) throw new RangeError(`bad month code ${e}; must match M01-M99 or M00L-M99L`);
+  return e;
+}, day: Do, hour: $, minute: $, second: $, millisecond: $, microsecond: $, nanosecond: $, offset: function(t) {
+  const e = _(Zr(t));
+  return sn(e), e;
+}, timeZone: ve }, Ti = { hour: 0, minute: 0, second: 0, millisecond: 0, microsecond: 0, nanosecond: 0 }, Vt = [["years", "year", "date"], ["months", "month", "date"], ["weeks", "week", "date"], ["days", "day", "date"], ["hours", "hour", "time"], ["minutes", "minute", "time"], ["seconds", "second", "time"], ["milliseconds", "millisecond", "time"], ["microseconds", "microsecond", "time"], ["nanoseconds", "nanosecond", "time"]], To = Object.fromEntries(Vt.map(((t) => [t[0], t[1]]))), Ii = Object.fromEntries(Vt.map((([t, e]) => [e, t]))), Dn = Vt.map((([, t]) => t)), Xt = { day: rr, hour: 36e11, minute: 6e10, second: 1e9, millisecond: 1e6, microsecond: 1e3, nanosecond: 1 }, or = ["days", "hours", "microseconds", "milliseconds", "minutes", "months", "nanoseconds", "seconds", "weeks", "years"], Ci = Intl.DateTimeFormat, Io = /* @__PURE__ */ new Map();
+function ga(t) {
+  const e = jn(t);
+  let n = Io.get(e);
+  return n === void 0 && (n = new Ci("en-us", { timeZone: e, hour12: !1, era: "short", year: "numeric", month: "numeric", day: "numeric", hour: "numeric", minute: "numeric", second: "numeric" }), Io.set(e, n)), n;
+}
+function X(t) {
+  return Ee(t, I) && !Ee(t, x, b);
+}
+function F(t) {
+  return Ee(t, de, he, ue, le, me, fe, ye, ge, Ie);
+}
+function B(t) {
+  return Ee(t, ea);
+}
+function q(t) {
+  return Ee(t, z);
+}
+function L(t) {
+  return Ee(t, P);
+}
+function Q(t) {
+  return Ee(t, ta);
+}
+function Se(t) {
+  return Ee(t, na);
+}
+function S(t) {
+  return Ee(t, I, x, b);
+}
+function g(t, e) {
+  if (!e(t)) throw new TypeError("invalid receiver: method called with the wrong type of this-object");
+}
+function rn(t) {
+  if (Ee(t, b) || Ee(t, x)) throw new TypeError("with() does not support a calendar or timeZone property");
+  if (q(t)) throw new TypeError("with() does not accept Temporal.PlainTime, use withPlainTime() instead");
+  if (t.calendar !== void 0) throw new TypeError("with() does not support a calendar property");
+  if (t.timeZone !== void 0) throw new TypeError("with() does not support a timeZone property");
+}
+function Zn(t, e) {
+  return e === "never" || e === "auto" && t === "iso8601" ? "" : `[${e === "critical" ? "!" : ""}u-ca=${t}]`;
+}
+function wr(t) {
+  let e, n, r = !1;
+  for (Gt.lastIndex = 0; n = Gt.exec(t); ) {
+    const { 1: o, 2: a, 3: i } = n;
+    if (a === "u-ca") {
+      if (e === void 0) e = i, r = o === "!";
+      else if (o === "!" || r) throw new RangeError(`Invalid annotations in ${t}: more than one u-ca present with critical flag`);
+    } else if (o === "!") throw new RangeError(`Unrecognized annotation: !${a}=${i}`);
+  }
+  return e;
+}
+function et(t) {
+  const e = ui.exec(t);
+  if (!e) throw new RangeError(`invalid RFC 9557 string: ${t}`);
+  const n = wr(e[16]);
+  let r = e[1];
+  if (r === "-000000") throw new RangeError(`invalid RFC 9557 string: ${t}`);
+  const o = +r, a = +(e[2] ?? e[4] ?? 1), i = +(e[3] ?? e[5] ?? 1), s = e[6] !== void 0, h = +(e[6] ?? 0), d = +(e[7] ?? e[10] ?? 0);
+  let u = +(e[8] ?? e[11] ?? 0);
+  u === 60 && (u = 59);
+  const l = (e[9] ?? e[12] ?? "") + "000000000", m = +l.slice(0, 3), f = +l.slice(3, 6), p = +l.slice(6, 9);
+  let v, w = !1;
+  e[13] ? (v = void 0, w = !0) : e[14] && (v = e[14]);
+  const E = e[15];
+  return oo(o, a, i, h, d, u, m, f, p), { year: o, month: a, day: i, time: s ? { hour: h, minute: d, second: u, millisecond: m, microsecond: f, nanosecond: p } : "start-of-day", tzAnnotation: E, offset: v, z: w, calendar: n };
+}
+function pa(t) {
+  const e = li.exec(t);
+  let n, r, o, a, i, s, h;
+  if (e) {
+    h = wr(e[10]), n = +(e[1] ?? 0), r = +(e[2] ?? e[5] ?? 0), o = +(e[3] ?? e[6] ?? 0), o === 60 && (o = 59);
+    const d = (e[4] ?? e[7] ?? "") + "000000000";
+    if (a = +d.slice(0, 3), i = +d.slice(3, 6), s = +d.slice(6, 9), e[8]) throw new RangeError("Z designator not supported for PlainTime");
+  } else {
+    let d, u;
+    if ({ time: d, z: u, calendar: h } = et(t), d === "start-of-day") throw new RangeError(`time is missing in string: ${t}`);
+    if (u) throw new RangeError("Z designator not supported for PlainTime");
+    ({ hour: n, minute: r, second: o, millisecond: a, microsecond: i, nanosecond: s } = d);
+  }
+  if (Mr(n, r, o, a, i, s), /[tT ][0-9][0-9]/.test(t)) return { hour: n, minute: r, second: o, millisecond: a, microsecond: i, nanosecond: s, calendar: h };
+  try {
+    const { month: d, day: u } = eo(t);
+    Rt(1972, d, u);
+  } catch {
+    try {
+      const { year: d, month: u } = Qr(t);
+      Rt(d, u, 1);
+    } catch {
+      return { hour: n, minute: r, second: o, millisecond: a, microsecond: i, nanosecond: s, calendar: h };
+    }
+  }
+  throw new RangeError(`invalid RFC 9557 time-only string ${t}; may need a T prefix`);
+}
+function Qr(t) {
+  const e = mi.exec(t);
+  let n, r, o, a;
+  if (e) {
+    o = wr(e[3]);
+    let i = e[1];
+    if (i === "-000000") throw new RangeError(`invalid RFC 9557 string: ${t}`);
+    if (n = +i, r = +e[2], a = 1, o !== void 0 && o !== "iso8601") throw new RangeError("YYYY-MM format is only valid with iso8601 calendar");
+  } else {
+    let i;
+    if ({ year: n, month: r, calendar: o, day: a, z: i } = et(t), i) throw new RangeError("Z designator not supported for PlainYearMonth");
+  }
+  return { year: n, month: r, calendar: o, referenceISODay: a };
+}
+function eo(t) {
+  const e = fi.exec(t);
+  let n, r, o, a;
+  if (e) {
+    if (o = wr(e[3]), n = +e[1], r = +e[2], o !== void 0 && o !== "iso8601") throw new RangeError("MM-DD format is only valid with iso8601 calendar");
+  } else {
+    let i;
+    if ({ month: n, day: r, calendar: o, year: a, z: i } = et(t), i) throw new RangeError("Z designator not supported for PlainMonthDay");
+  }
+  return { month: n, day: r, calendar: o, referenceISOYear: a };
+}
+const wa = new RegExp(`^${Pn.source}$`, "i"), va = new RegExp(`^${/([+-])([01][0-9]|2[0-3])(?::?([0-5][0-9])?)?/.source}$`);
+function ba(t) {
+  const e = Oi.test(t) ? "Seconds not allowed in offset time zone" : "Invalid time zone";
+  throw new RangeError(`${e}: ${t}`);
+}
+function vt(t) {
+  return wa.test(t) || ba(t), va.test(t) ? { offsetMinutes: sn(t) / 6e10 } : { tzName: t };
+}
+function Tn(t, e, n, r) {
+  let o = t, a = e, i = n;
+  switch (r) {
+    case "reject":
+      Rt(o, a, i);
+      break;
+    case "constrain":
+      ({ year: o, month: a, day: i } = Ua(o, a, i));
+  }
+  return { year: o, month: a, day: i };
+}
+function vr(t, e, n, r, o, a, i) {
+  let s = t, h = e, d = n, u = r, l = o, m = a;
+  switch (i) {
+    case "reject":
+      Mr(s, h, d, u, l, m);
+      break;
+    case "constrain":
+      s = pe(s, 0, 23), h = pe(h, 0, 59), d = pe(d, 0, 59), u = pe(u, 0, 999), l = pe(l, 0, 999), m = pe(m, 0, 999);
+  }
+  return { hour: s, minute: h, second: d, millisecond: u, microsecond: l, nanosecond: m };
+}
+function Ea(t) {
+  if (!A(t)) throw new TypeError("invalid duration-like");
+  const e = { years: void 0, months: void 0, weeks: void 0, days: void 0, hours: void 0, minutes: void 0, seconds: void 0, milliseconds: void 0, microseconds: void 0, nanoseconds: void 0 };
+  let n = !1;
+  for (let r = 0; r < or.length; r++) {
+    const o = or[r], a = t[o];
+    a !== void 0 && (n = !0, e[o] = ze(a));
+  }
+  if (!n) throw new TypeError("invalid duration-like");
+  return e;
+}
+function re({ years: t, months: e, weeks: n, days: r }, o, a, i) {
+  return { years: t, months: i ?? e, weeks: a ?? n, days: o ?? r };
+}
+function j(t, e) {
+  return { isoDate: t, time: e };
+}
+function N(t) {
+  return dt(t, "overflow", ["constrain", "reject"], "constrain");
+}
+function In(t) {
+  return dt(t, "disambiguation", ["compatible", "earlier", "later", "reject"], "compatible");
+}
+function Ae(t, e) {
+  return dt(t, "roundingMode", ["ceil", "floor", "expand", "trunc", "halfCeil", "halfFloor", "halfExpand", "halfTrunc", "halfEven"], e);
+}
+function er(t, e) {
+  return dt(t, "offset", ["prefer", "use", "ignore", "reject"], e);
+}
+function Fn(t) {
+  return dt(t, "calendarName", ["auto", "always", "never", "critical"], "auto");
+}
+function on(t) {
+  let e = t.roundingIncrement;
+  if (e === void 0) return 1;
+  const n = $(e);
+  if (n < 1 || n > 1e9) throw new RangeError(`roundingIncrement must be at least 1 and at most 1e9, not ${e}`);
+  return n;
+}
+function an(t, e, n) {
+  const r = n ? e : e - 1;
+  if (t > r) throw new RangeError(`roundingIncrement must be at least 1 and less than ${r}, not ${t}`);
+  if (e % t != 0) throw new RangeError(`Rounding increment must divide evenly into ${e}`);
+}
+function Bn(t) {
+  const e = t.fractionalSecondDigits;
+  if (e === void 0) return "auto";
+  if (typeof e != "number") {
+    if (pr(e) !== "auto") throw new RangeError(`fractionalSecondDigits must be 'auto' or 0 through 9, not ${e}`);
+    return "auto";
+  }
+  const n = Math.floor(e);
+  if (!Number.isFinite(n) || n < 0 || n > 9) throw new RangeError(`fractionalSecondDigits must be 'auto' or 0 through 9, not ${e}`);
+  return n;
+}
+function zn(t, e) {
+  switch (t) {
+    case "minute":
+      return { precision: "minute", unit: "minute", increment: 1 };
+    case "second":
+      return { precision: 0, unit: "second", increment: 1 };
+    case "millisecond":
+      return { precision: 3, unit: "millisecond", increment: 1 };
+    case "microsecond":
+      return { precision: 6, unit: "microsecond", increment: 1 };
+    case "nanosecond":
+      return { precision: 9, unit: "nanosecond", increment: 1 };
+  }
+  switch (e) {
+    case "auto":
+      return { precision: e, unit: "nanosecond", increment: 1 };
+    case 0:
+      return { precision: e, unit: "second", increment: 1 };
+    case 1:
+    case 2:
+    case 3:
+      return { precision: e, unit: "millisecond", increment: 10 ** (3 - e) };
+    case 4:
+    case 5:
+    case 6:
+      return { precision: e, unit: "microsecond", increment: 10 ** (6 - e) };
+    case 7:
+    case 8:
+    case 9:
+      return { precision: e, unit: "nanosecond", increment: 10 ** (9 - e) };
+    default:
+      throw new RangeError(`fractionalSecondDigits must be 'auto' or 0 through 9, not ${e}`);
+  }
+}
+const ut = /* @__PURE__ */ Symbol("~required~");
+function $e(t, e, n, r, o = []) {
+  let a = [];
+  for (let d = 0; d < Vt.length; d++) {
+    const u = Vt[d], l = u[1], m = u[2];
+    n !== "datetime" && n !== m || a.push(l);
+  }
+  a = a.concat(o);
+  let i = r;
+  i === ut ? i = void 0 : i !== void 0 && a.push(i);
+  let s = [];
+  s = s.concat(a);
+  for (let d = 0; d < a.length; d++) {
+    const u = a[d], l = Ii[u];
+    l !== void 0 && s.push(l);
+  }
+  let h = dt(t, e, s, i);
+  if (h === void 0 && r === ut) throw new RangeError(`${e} is required`);
+  return h && h in To ? To[h] : h;
+}
+function Yr(t) {
+  const e = t.relativeTo;
+  if (e === void 0) return {};
+  let n, r, o, a, i, s = "option", h = !1;
+  if (A(e)) {
+    if (S(e)) return { zonedRelativeTo: e };
+    if (B(e)) return { plainRelativeTo: e };
+    if (L(e)) return { plainRelativeTo: we(c(e, P).isoDate, c(e, b)) };
+    o = _n(e);
+    const d = xe(o, e, ["year", "month", "monthCode", "day"], ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond", "offset", "timeZone"], []);
+    ({ isoDate: n, time: r } = qn(o, d, "constrain")), { offset: i, timeZone: a } = d, i === void 0 && (s = "wall");
+  } else {
+    let d, u, l, m, f;
+    if ({ year: l, month: m, day: f, time: r, calendar: o, tzAnnotation: d, offset: i, z: u } = et(_(e)), d) a = ve(d), u ? s = "exact" : i || (s = "wall"), h = !0;
+    else if (u) throw new RangeError("Z designator not supported for PlainDate relativeTo; either remove the Z or add a bracketed time zone");
+    o || (o = "iso8601"), o = Me(o), n = { year: l, month: m, day: f };
+  }
+  return a === void 0 ? { plainRelativeTo: we(n, o) } : { zonedRelativeTo: ne(ar(n, r, s, s === "option" ? sn(i) : 0, a, "compatible", "reject", h), a, o) };
+}
+function rt(t) {
+  return c(t, de) !== 0 ? "year" : c(t, he) !== 0 ? "month" : c(t, Te) !== 0 ? "week" : c(t, ue) !== 0 ? "day" : c(t, le) !== 0 ? "hour" : c(t, me) !== 0 ? "minute" : c(t, fe) !== 0 ? "second" : c(t, ye) !== 0 ? "millisecond" : c(t, ge) !== 0 ? "microsecond" : "nanosecond";
+}
+function st(t, e) {
+  return Dn.indexOf(t) > Dn.indexOf(e) ? e : t;
+}
+function We(t) {
+  return t === "year" || t === "month" || t === "week";
+}
+function ot(t) {
+  return We(t) || t === "day" ? "date" : "time";
+}
+function Dt(t) {
+  return te("%calendarImpl%")(t);
+}
+function An(t) {
+  return te("%calendarImpl%")(c(t, b));
+}
+function be(t, e, n = "date") {
+  const r = /* @__PURE__ */ Object.create(null), o = Dt(t).isoToDate(e, { year: !0, monthCode: !0, day: !0 });
+  return r.monthCode = o.monthCode, n !== "month-day" && n !== "date" || (r.day = o.day), n !== "year-month" && n !== "date" || (r.year = o.year), r;
+}
+function xe(t, e, n, r, o) {
+  const a = Dt(t).extraFields(n), i = n.concat(r, a), s = /* @__PURE__ */ Object.create(null);
+  let h = !1;
+  i.sort();
+  for (let d = 0; d < i.length; d++) {
+    const u = i[d], l = e[u];
+    if (l !== void 0) h = !0, s[u] = (0, Di[u])(l);
+    else if (o !== "partial") {
+      if (o.includes(u)) throw new TypeError(`required property '${u}' missing or undefined`);
+      s[u] = Ti[u];
+    }
+  }
+  if (o === "partial" && !h) throw new TypeError("no supported properties found");
+  return s;
+}
+function Br(t, e = "complete") {
+  const n = ["hour", "microsecond", "millisecond", "minute", "nanosecond", "second"];
+  let r = !1;
+  const o = /* @__PURE__ */ Object.create(null);
+  for (let a = 0; a < n.length; a++) {
+    const i = n[a], s = t[i];
+    s !== void 0 ? (o[i] = $(s), r = !0) : e === "complete" && (o[i] = 0);
+  }
+  if (!r) throw new TypeError("invalid time-like");
+  return o;
+}
+function yn(t, e) {
+  if (A(t)) {
+    if (B(t)) return N(M(e)), we(c(t, C), c(t, b));
+    if (S(t)) {
+      const h = Fe(c(t, x), c(t, I));
+      return N(M(e)), we(h.isoDate, c(t, b));
+    }
+    if (L(t)) return N(M(e)), we(c(t, P).isoDate, c(t, b));
+    const s = _n(t);
+    return we(Mt(s, xe(s, t, ["year", "month", "monthCode", "day"], [], []), N(M(e))), s);
+  }
+  let { year: n, month: r, day: o, calendar: a, z: i } = et(_(t));
+  if (i) throw new RangeError("Z designator not supported for PlainDate");
+  return a || (a = "iso8601"), a = Me(a), N(M(e)), we({ year: n, month: r, day: o }, a);
+}
+function qn(t, e, n) {
+  return j(Mt(t, e, n), vr(e.hour, e.minute, e.second, e.millisecond, e.microsecond, e.nanosecond, n));
+}
+function gn(t, e) {
+  let n, r, o;
+  if (A(t)) {
+    if (L(t)) return N(M(e)), Le(c(t, P), c(t, b));
+    if (S(t)) {
+      const s = Fe(c(t, x), c(t, I));
+      return N(M(e)), Le(s, c(t, b));
+    }
+    if (B(t)) return N(M(e)), Le(j(c(t, C), { deltaDays: 0, hour: 0, minute: 0, second: 0, millisecond: 0, microsecond: 0, nanosecond: 0 }), c(t, b));
+    o = _n(t);
+    const a = xe(o, t, ["year", "month", "monthCode", "day"], ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"], []), i = N(M(e));
+    ({ isoDate: n, time: r } = qn(o, a, i));
+  } else {
+    let a, i, s, h;
+    if ({ year: i, month: s, day: h, time: r, calendar: o, z: a } = et(_(t)), a) throw new RangeError("Z designator not supported for PlainDateTime");
+    r === "start-of-day" && (r = { deltaDays: 0, hour: 0, minute: 0, second: 0, millisecond: 0, microsecond: 0, nanosecond: 0 }), oo(i, s, h, r.hour, r.minute, r.second, r.millisecond, r.microsecond, r.nanosecond), o || (o = "iso8601"), o = Me(o), N(M(e)), n = { year: i, month: s, day: h };
+  }
+  return Le(j(n, r), o);
+}
+function Ze(t) {
+  const e = te("%Temporal.Duration%");
+  if (F(t)) return new e(c(t, de), c(t, he), c(t, Te), c(t, ue), c(t, le), c(t, me), c(t, fe), c(t, ye), c(t, ge), c(t, Ie));
+  if (!A(t)) return (function(o) {
+    const { years: a, months: i, weeks: s, days: h, hours: d, minutes: u, seconds: l, milliseconds: m, microseconds: f, nanoseconds: p } = (function(v) {
+      const w = gi.exec(v);
+      if (!w) throw new RangeError(`invalid duration: ${v}`);
+      if (w.every(((ri, oi) => oi < 2 || ri === void 0))) throw new RangeError(`invalid duration: ${v}`);
+      const E = w[1] === "-" ? -1 : 1, T = w[2] === void 0 ? 0 : $(w[2]) * E, D = w[3] === void 0 ? 0 : $(w[3]) * E, Y = w[4] === void 0 ? 0 : $(w[4]) * E, O = w[5] === void 0 ? 0 : $(w[5]) * E, W = w[6] === void 0 ? 0 : $(w[6]) * E, K = w[7], H = w[8], Z = w[9], De = w[10], V = w[11];
+      let U = 0, ae = 0, Re = 0;
+      if (K !== void 0) {
+        if (H ?? Z ?? De ?? V) throw new RangeError("only the smallest unit can be fractional");
+        Re = 3600 * $((K + "000000000").slice(0, 9)) * E;
+      } else if (U = H === void 0 ? 0 : $(H) * E, Z !== void 0) {
+        if (De ?? V) throw new RangeError("only the smallest unit can be fractional");
+        Re = 60 * $((Z + "000000000").slice(0, 9)) * E;
+      } else ae = De === void 0 ? 0 : $(De) * E, V !== void 0 && (Re = $((V + "000000000").slice(0, 9)) * E);
+      const ft = Re % 1e3, Pt = Math.trunc(Re / 1e3) % 1e3, Zt = Math.trunc(Re / 1e6) % 1e3;
+      return ae += Math.trunc(Re / 1e9) % 60, U += Math.trunc(Re / 6e10), Dr(T, D, Y, O, W, U, ae, Zt, Pt, ft), { years: T, months: D, weeks: Y, days: O, hours: W, minutes: U, seconds: ae, milliseconds: Zt, microseconds: Pt, nanoseconds: ft };
+    })(o);
+    return new (te("%Temporal.Duration%"))(a, i, s, h, d, u, l, m, f, p);
+  })(_(t));
+  const n = { years: 0, months: 0, weeks: 0, days: 0, hours: 0, minutes: 0, seconds: 0, milliseconds: 0, microseconds: 0, nanoseconds: 0 };
+  let r = Ea(t);
+  for (let o = 0; o < or.length; o++) {
+    const a = or[o], i = r[a];
+    i !== void 0 && (n[a] = i);
+  }
+  return new e(n.years, n.months, n.weeks, n.days, n.hours, n.minutes, n.seconds, n.milliseconds, n.microseconds, n.nanoseconds);
+}
+function pn(t) {
+  let e;
+  if (A(t)) {
+    if (X(t) || S(t)) return _e(c(t, I));
+    e = Zr(t);
+  } else e = t;
+  const { year: n, month: r, day: o, time: a, offset: i, z: s } = (function(v) {
+    const w = et(v);
+    if (!w.z && !w.offset) throw new RangeError("Temporal.Instant requires a time zone offset");
+    return w;
+  })(_(e)), { hour: h = 0, minute: d = 0, second: u = 0, millisecond: l = 0, microsecond: m = 0, nanosecond: f = 0 } = a === "start-of-day" ? {} : a, p = Nn(n, r, o, h, d, u, l, m, f - (s ? 0 : sn(i)));
+  return Jt(p.isoDate), _e(ee(p));
+}
+function Co(t, e) {
+  if (A(t)) {
+    if (Se(t)) return N(M(e)), Ht(c(t, C), c(t, b));
+    let s;
+    return Ee(t, b) ? s = c(t, b) : (s = t.calendar, s === void 0 && (s = "iso8601"), s = Hn(s)), Ht(ir(s, xe(s, t, ["year", "month", "monthCode", "day"], [], []), N(M(e))), s);
+  }
+  let { month: n, day: r, referenceISOYear: o, calendar: a } = eo(_(t));
+  if (a === void 0 && (a = "iso8601"), a = Me(a), N(M(e)), a === "iso8601") return Ht({ year: 1972, month: n, day: r }, a);
+  let i = { year: o, month: n, day: r };
+  return Lt(i), i = ir(a, be(a, i, "month-day"), "constrain"), Ht(i, a);
+}
+function pt(t, e) {
+  let n;
+  if (A(t)) {
+    if (q(t)) return N(M(e)), at(c(t, z));
+    if (L(t)) return N(M(e)), at(c(t, P).time);
+    if (S(t)) {
+      const d = Fe(c(t, x), c(t, I));
+      return N(M(e)), at(d.time);
+    }
+    const { hour: r, minute: o, second: a, millisecond: i, microsecond: s, nanosecond: h } = Br(t);
+    n = vr(r, o, a, i, s, h, N(M(e)));
+  } else n = pa(_(t)), N(M(e));
+  return at(n);
+}
+function Ma(t) {
+  return t === void 0 ? { deltaDays: 0, hour: 0, minute: 0, second: 0, millisecond: 0, microsecond: 0, nanosecond: 0 } : c(pt(t), z);
+}
+function wn(t, e) {
+  if (A(t)) {
+    if (Q(t)) return N(M(e)), _t(c(t, C), c(t, b));
+    const s = _n(t);
+    return _t(Rn(s, xe(s, t, ["year", "month", "monthCode"], [], []), N(M(e))), s);
+  }
+  let { year: n, month: r, referenceISODay: o, calendar: a } = Qr(_(t));
+  a === void 0 && (a = "iso8601"), a = Me(a), N(M(e));
+  let i = { year: n, month: r, day: o };
+  return ao(i), i = Rn(a, be(a, i, "year-month"), "constrain"), _t(i, a);
+}
+function ar(t, e, n, r, o, a, i, s) {
+  if (e === "start-of-day") return yt(o, t);
+  const h = j(t, e);
+  if (n === "wall" || i === "ignore") return oe(o, h, a);
+  if (n === "exact" || i === "use") {
+    const l = Nn(t.year, t.month, t.day, e.hour, e.minute, e.second, e.millisecond, e.microsecond, e.nanosecond - r);
+    Jt(l.isoDate);
+    const m = ee(l);
+    return Xe(m), m;
+  }
+  Jt(t);
+  const d = ee(h), u = Sn(o, h);
+  for (let l = 0; l < u.length; l++) {
+    const m = u[l], f = y.toNumber(y.subtract(d, m)), p = wt(f, 6e10, "halfExpand");
+    if (f === r || s && p === r) return m;
+  }
+  if (i === "reject") {
+    const l = zr(r), m = kn(h, "iso8601", "auto");
+    throw new RangeError(`Offset ${l} is invalid for ${m} in ${o}`);
+  }
+  return Sa(u, o, h, a);
+}
+function vn(t, e) {
+  let n, r, o, a, i, s, h, d = !1, u = "option";
+  if (A(t)) {
+    if (S(t)) {
+      const v = M(e);
+      return In(v), er(v, "reject"), N(v), ne(c(t, I), c(t, x), c(t, b));
+    }
+    i = _n(t);
+    const m = xe(i, t, ["year", "month", "monthCode", "day"], ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond", "offset", "timeZone"], ["timeZone"]);
+    ({ offset: a, timeZone: o } = m), a === void 0 && (u = "wall");
+    const f = M(e);
+    s = In(f), h = er(f, "reject");
+    const p = N(f);
+    ({ isoDate: n, time: r } = qn(i, m, p));
+  } else {
+    let m, f, p, v, w;
+    ({ year: p, month: v, day: w, time: r, tzAnnotation: m, offset: a, z: f, calendar: i } = (function(T) {
+      const D = et(T);
+      if (!D.tzAnnotation) throw new RangeError("Temporal.ZonedDateTime requires a time zone ID in brackets");
+      return D;
+    })(_(t))), o = ve(m), f ? u = "exact" : a || (u = "wall"), i || (i = "iso8601"), i = Me(i), d = !0;
+    const E = M(e);
+    s = In(E), h = er(E, "reject"), N(E), n = { year: p, month: v, day: w };
+  }
+  let l = 0;
+  return u === "option" && (l = sn(a)), ne(ar(n, r, u, l, o, s, h, d), o, i);
+}
+function Da(t, e, n) {
+  Lt(e), lt(t), R(t, C, e), R(t, b, n), R(t, ea, !0);
+}
+function we(t, e) {
+  const n = te("%Temporal.PlainDate%"), r = Object.create(n.prototype);
+  return Da(r, t, e), r;
+}
+function Ta(t, e, n) {
+  St(e), lt(t), R(t, P, e), R(t, b, n);
+}
+function Le(t, e) {
+  const n = te("%Temporal.PlainDateTime%"), r = Object.create(n.prototype);
+  return Ta(r, t, e), r;
+}
+function Ia(t, e, n) {
+  Lt(e), lt(t), R(t, C, e), R(t, b, n), R(t, na, !0);
+}
+function Ht(t, e) {
+  const n = te("%Temporal.PlainMonthDay%"), r = Object.create(n.prototype);
+  return Ia(r, t, e), r;
+}
+function Ca(t, e) {
+  lt(t), R(t, z, e);
+}
+function at(t) {
+  const e = te("%Temporal.PlainTime%"), n = Object.create(e.prototype);
+  return Ca(n, t), n;
+}
+function $a(t, e, n) {
+  ao(e), lt(t), R(t, C, e), R(t, b, n), R(t, ta, !0);
+}
+function _t(t, e) {
+  const n = te("%Temporal.PlainYearMonth%"), r = Object.create(n.prototype);
+  return $a(r, t, e), r;
+}
+function Oa(t, e) {
+  Xe(e), lt(t), R(t, I, e);
+}
+function _e(t) {
+  const e = te("%Temporal.Instant%"), n = Object.create(e.prototype);
+  return Oa(n, t), n;
+}
+function Ya(t, e, n, r) {
+  Xe(e), lt(t), R(t, I, e), R(t, x, n), R(t, b, r);
+}
+function ne(t, e, n = "iso8601") {
+  const r = te("%Temporal.ZonedDateTime%"), o = Object.create(r.prototype);
+  return Ya(o, t, e, n), o;
+}
+function $o(t) {
+  return Fr.filter(((e) => t[e] !== void 0));
+}
+function Yt(t, e, n) {
+  const r = $o(n), o = Dt(t).fieldKeysToIgnore(r), a = /* @__PURE__ */ Object.create(null), i = $o(e);
+  for (let s = 0; s < Fr.length; s++) {
+    let h;
+    const d = Fr[s];
+    i.includes(d) && !o.includes(d) && (h = e[d]), r.includes(d) && (h = n[d]), h !== void 0 && (a[d] = h);
+  }
+  return a;
+}
+function Ne(t, e, n, r) {
+  const o = Dt(t).dateAdd(e, n, r);
+  return Lt(o), o;
+}
+function Wn(t, e, n, r) {
+  return Dt(t).dateUntil(e, n, r);
+}
+function Hn(t) {
+  if (A(t) && Ee(t, b)) return c(t, b);
+  const e = _(t);
+  try {
+    return Me(e);
+  } catch {
+  }
+  let n;
+  try {
+    ({ calendar: n } = et(e));
+  } catch {
+    try {
+      ({ calendar: n } = pa(e));
+    } catch {
+      try {
+        ({ calendar: n } = Qr(e));
+      } catch {
+        ({ calendar: n } = eo(e));
+      }
+    }
+  }
+  return n || (n = "iso8601"), Me(n);
+}
+function _n(t) {
+  if (Ee(t, b)) return c(t, b);
+  const { calendar: e } = t;
+  return e === void 0 ? "iso8601" : Hn(e);
+}
+function Ve(t, e) {
+  return Me(t) === Me(e);
+}
+function Mt(t, e, n) {
+  const r = Dt(t);
+  r.resolveFields(e, "date");
+  const o = r.dateToISO(e, n);
+  return Lt(o), o;
+}
+function Rn(t, e, n) {
+  const r = Dt(t);
+  r.resolveFields(e, "year-month"), e.day = 1;
+  const o = r.dateToISO(e, n);
+  return ao(o), o;
+}
+function ir(t, e, n) {
+  const r = Dt(t);
+  r.resolveFields(e, "month-day");
+  const o = r.monthDayToISOReferenceDate(e, n);
+  return Lt(o), o;
+}
+function ve(t) {
+  if (A(t) && S(t)) return c(t, x);
+  const e = _(t);
+  if (e === "UTC") return "UTC";
+  const { tzName: n, offsetMinutes: r } = (function(a) {
+    const { tzAnnotation: i, offset: s, z: h } = (function(d) {
+      if (wa.test(d)) return { tzAnnotation: d, offset: void 0, z: !1 };
+      try {
+        const { tzAnnotation: u, offset: l, z: m } = et(d);
+        if (m || u || l) return { tzAnnotation: u, offset: l, z: m };
+      } catch {
+      }
+      ba(d);
+    })(a);
+    return i ? vt(i) : h ? vt("UTC") : s ? vt(s) : void 0;
+  })(e);
+  if (r !== void 0) return to(r);
+  const o = sr(n);
+  if (!o) throw new RangeError(`Unrecognized time zone ${n}`);
+  return o.identifier;
+}
+function Ra(t, e) {
+  if (t === e) return !0;
+  const n = vt(t).offsetMinutes, r = vt(e).offsetMinutes;
+  if (n === void 0 && r === void 0) {
+    const o = sr(e);
+    if (!o) return !1;
+    const a = sr(t);
+    return !!a && a.primaryIdentifier === o.primaryIdentifier;
+  }
+  return n === r;
+}
+function it(t, e) {
+  const n = vt(t).offsetMinutes;
+  return n !== void 0 ? 6e10 * n : Ar(t, e);
+}
+function zr(t) {
+  const e = t < 0 ? "-" : "+", n = Math.abs(t), r = Math.floor(n / 36e11), o = Math.floor(n / 6e10) % 60, a = Math.floor(n / 1e9) % 60, i = n % 1e9;
+  return `${e}${br(r, o, a, i, a === 0 && i === 0 ? "minute" : "auto")}`;
+}
+function Fe(t, e) {
+  const n = it(t, e);
+  let { isoDate: { year: r, month: o, day: a }, time: { hour: i, minute: s, second: h, millisecond: d, microsecond: u, nanosecond: l } } = ja(e);
+  return Nn(r, o, a, i, s, h, d, u, l + n);
+}
+function oe(t, e, n) {
+  return Sa(Sn(t, e), t, e, n);
+}
+function Sa(t, e, n, r) {
+  const o = t.length;
+  if (o === 1) return t[0];
+  if (o) switch (r) {
+    case "compatible":
+    case "earlier":
+      return t[0];
+    case "later":
+      return t[o - 1];
+    case "reject":
+      throw new RangeError("multiple instants found");
+  }
+  if (r === "reject") throw new RangeError("multiple instants found");
+  const a = ee(n), i = y.subtract(a, bt);
+  Xe(i);
+  const s = it(e, i), h = y.add(a, bt);
+  Xe(h);
+  const d = it(e, h) - s;
+  switch (r) {
+    case "earlier": {
+      const u = k.fromComponents(0, 0, 0, 0, 0, -d), l = Qt(n.time, u);
+      return Sn(e, j(Oe(n.isoDate.year, n.isoDate.month, n.isoDate.day + l.deltaDays), l))[0];
+    }
+    case "compatible":
+    case "later": {
+      const u = k.fromComponents(0, 0, 0, 0, 0, d), l = Qt(n.time, u), m = Sn(e, j(Oe(n.isoDate.year, n.isoDate.month, n.isoDate.day + l.deltaDays), l));
+      return m[m.length - 1];
+    }
+  }
+}
+function Sn(t, e) {
+  if (t === "UTC") return Jt(e.isoDate), [ee(e)];
+  const n = vt(t).offsetMinutes;
+  if (n !== void 0) {
+    const r = Nn(e.isoDate.year, e.isoDate.month, e.isoDate.day, e.time.hour, e.time.minute - n, e.time.second, e.time.millisecond, e.time.microsecond, e.time.nanosecond);
+    Jt(r.isoDate);
+    const o = ee(r);
+    return Xe(o), [o];
+  }
+  return Jt(e.isoDate), (function(r, o) {
+    let a = ee(o), i = y.subtract(a, bt);
+    y.lessThan(i, On) && (i = a);
+    let s = y.add(a, bt);
+    y.greaterThan(s, Kt) && (s = a);
+    const h = Ar(r, i), d = Ar(r, s);
+    return (h === d ? [h] : [h, d]).map(((l) => {
+      const m = y.subtract(a, y.BigInt(l)), f = (function(p, v) {
+        const { epochMilliseconds: w, time: { millisecond: E, microsecond: T, nanosecond: D } } = ja(v), { year: Y, month: O, day: W, hour: K, minute: H, second: Z } = xa(p, w);
+        return Nn(Y, O, W, K, H, Z, E, T, D);
+      })(r, m);
+      if (en(o, f) === 0) return Xe(m), m;
+    })).filter(((l) => l !== void 0));
+  })(t, e);
+}
+function yt(t, e) {
+  const n = j(e, { deltaDays: 0, hour: 0, minute: 0, second: 0, millisecond: 0, microsecond: 0, nanosecond: 0 }), r = Sn(t, n);
+  if (r.length) return r[0];
+  const o = ee(n), a = y.subtract(o, bt);
+  return Xe(a), ro(t, a);
+}
+function Jn(t) {
+  let e;
+  return e = t < 0 || t > 9999 ? (t < 0 ? "-" : "+") + Yn(Math.abs(t), 6) : Yn(t, 4), e;
+}
+function je(t) {
+  return Yn(t, 2);
+}
+function ka(t, e) {
+  let n;
+  if (e === "auto") {
+    if (t === 0) return "";
+    n = Yn(t, 9).replace(/0+$/, "");
+  } else {
+    if (e === 0) return "";
+    n = Yn(t, 9).slice(0, e);
+  }
+  return `.${n}`;
+}
+function br(t, e, n, r, o) {
+  let a = `${je(t)}:${je(e)}`;
+  return o === "minute" || (a += `:${je(n)}`, a += ka(r, o)), a;
+}
+function Oo(t, e, n) {
+  let r = e;
+  r === void 0 && (r = "UTC");
+  const o = c(t, I), a = kn(Fe(r, o), "iso8601", n, "never");
+  let i = "Z";
+  return e !== void 0 && (i = Na(it(r, o))), `${a}${i}`;
+}
+function Qn(t, e) {
+  const n = c(t, de), r = c(t, he), o = c(t, Te), a = c(t, ue), i = c(t, le), s = c(t, me), h = dr(t);
+  let d = "";
+  n !== 0 && (d += `${Math.abs(n)}Y`), r !== 0 && (d += `${Math.abs(r)}M`), o !== 0 && (d += `${Math.abs(o)}W`), a !== 0 && (d += `${Math.abs(a)}D`);
+  let u = "";
+  i !== 0 && (u += `${Math.abs(i)}H`), s !== 0 && (u += `${Math.abs(s)}M`);
+  const l = k.fromComponents(0, 0, c(t, fe), c(t, ye), c(t, ge), c(t, Ie));
+  l.isZero() && !["second", "millisecond", "microsecond", "nanosecond"].includes(rt(t)) && e === "auto" || (u += `${Math.abs(l.sec)}${ka(Math.abs(l.subsec), e)}S`);
+  let m = `${h < 0 ? "-" : ""}P${d}`;
+  return u && (m = `${m}T${u}`), m;
+}
+function Yo(t, e = "auto") {
+  const { year: n, month: r, day: o } = c(t, C);
+  return `${Jn(n)}-${je(r)}-${je(o)}${Zn(c(t, b), e)}`;
+}
+function Ro({ hour: t, minute: e, second: n, millisecond: r, microsecond: o, nanosecond: a }, i) {
+  return br(t, e, n, 1e6 * r + 1e3 * o + a, i);
+}
+function kn(t, e, n, r = "auto") {
+  const { isoDate: { year: o, month: a, day: i }, time: { hour: s, minute: h, second: d, millisecond: u, microsecond: l, nanosecond: m } } = t;
+  return `${Jn(o)}-${je(a)}-${je(i)}T${br(s, h, d, 1e6 * u + 1e3 * l + m, n)}${Zn(e, r)}`;
+}
+function So(t, e = "auto") {
+  const { year: n, month: r, day: o } = c(t, C);
+  let a = `${je(r)}-${je(o)}`;
+  const i = c(t, b);
+  e !== "always" && e !== "critical" && i === "iso8601" || (a = `${Jn(n)}-${a}`);
+  const s = Zn(i, e);
+  return s && (a += s), a;
+}
+function ko(t, e = "auto") {
+  const { year: n, month: r, day: o } = c(t, C);
+  let a = `${Jn(n)}-${je(r)}`;
+  const i = c(t, b);
+  e !== "always" && e !== "critical" && i === "iso8601" || (a += `-${je(o)}`);
+  const s = Zn(i, e);
+  return s && (a += s), a;
+}
+function No(t, e, n = "auto", r = "auto", o = "auto", a = void 0) {
+  let i = c(t, I);
+  if (a) {
+    const { unit: u, increment: l, roundingMode: m } = a;
+    i = _r(i, l, u, m);
+  }
+  const s = c(t, x), h = it(s, i);
+  let d = kn(Fe(s, i), "iso8601", e, "never");
+  return o !== "never" && (d += Na(h)), r !== "never" && (d += `[${r === "critical" ? "!" : ""}${s}]`), d += Zn(c(t, b), n), d;
+}
+function jo(t) {
+  return va.test(t);
+}
+function sn(t) {
+  const e = Yi.exec(t);
+  if (!e) throw new RangeError(`invalid time zone offset: ${t}; must match ±HH:MM[:SS.SSSSSSSSS]`);
+  return (e[1] === "-" ? -1 : 1) * (1e9 * (60 * (60 * +e[2] + +(e[3] || 0)) + +(e[4] || 0)) + +((e[5] || 0) + "000000000").slice(0, 9));
+}
+let hn;
+const $i = Object.assign(/* @__PURE__ */ Object.create(null), { "/": !0, "-": !0, _: !0 });
+function sr(t) {
+  if (hn === void 0) {
+    const a = Intl.supportedValuesOf?.("timeZone");
+    if (a) {
+      hn = /* @__PURE__ */ new Map();
+      for (let i = 0; i < a.length; i++) {
+        const s = a[i];
+        hn.set(jn(s), s);
+      }
+    } else hn = null;
+  }
+  const e = jn(t);
+  let n = hn?.get(e);
+  if (n) return { identifier: n, primaryIdentifier: n };
+  try {
+    n = ga(t).resolvedOptions().timeZone;
+  } catch {
+    return;
+  }
+  if (e === "antarctica/south_pole" && (n = "Antarctica/McMurdo"), Mi.has(t)) throw new RangeError(`${t} is a legacy time zone identifier from ICU. Use ${n} instead`);
+  const r = [...e].map(((a, i) => i === 0 || $i[e[i - 1]] ? a.toUpperCase() : a)).join("").split("/");
+  if (r.length === 1) return e === "gb-eire" ? { identifier: "GB-Eire", primaryIdentifier: n } : { identifier: e.length <= 3 || /[-0-9]/.test(e) ? e.toUpperCase() : r[0], primaryIdentifier: n };
+  if (r[0] === "Etc") return { identifier: `Etc/${["Zulu", "Greenwich", "Universal"].includes(r[1]) ? r[1] : r[1].toUpperCase()}`, primaryIdentifier: n };
+  if (r[0] === "Us") return { identifier: `US/${r[1]}`, primaryIdentifier: n };
+  const o = /* @__PURE__ */ new Map([["Act", "ACT"], ["Lhi", "LHI"], ["Nsw", "NSW"], ["Dar_Es_Salaam", "Dar_es_Salaam"], ["Port_Of_Spain", "Port_of_Spain"], ["Port-Au-Prince", "Port-au-Prince"], ["Isle_Of_Man", "Isle_of_Man"], ["Comodrivadavia", "ComodRivadavia"], ["Knox_In", "Knox_IN"], ["Dumontdurville", "DumontDUrville"], ["Mcmurdo", "McMurdo"], ["Denoronha", "DeNoronha"], ["Easterisland", "EasterIsland"], ["Bajanorte", "BajaNorte"], ["Bajasur", "BajaSur"]]);
+  return r[1] = o.get(r[1]) ?? r[1], r.length > 2 && (r[2] = o.get(r[2]) ?? r[2]), { identifier: r.join("/"), primaryIdentifier: n };
+}
+function $t(t, e) {
+  const { year: n, month: r, day: o, hour: a, minute: i, second: s } = xa(t, e);
+  let h = e % 1e3;
+  return h < 0 && (h += 1e3), 1e6 * (no({ isoDate: { year: n, month: r, day: o }, time: { hour: a, minute: i, second: s, millisecond: h } }) - e);
+}
+function Ar(t, e) {
+  return $t(t, Be(e, "floor"));
+}
+function to(t) {
+  const e = t < 0 ? "-" : "+", n = Math.abs(t);
+  return `${e}${br(Math.floor(n / 60), n % 60, 0, 0, "minute")}`;
+}
+function Na(t) {
+  return to(wt(t, pi, "halfExpand") / 6e10);
+}
+function no({ isoDate: { year: t, month: e, day: n }, time: { hour: r, minute: o, second: a, millisecond: i } }) {
+  const s = t % 400, h = (t - s) / 400, d = /* @__PURE__ */ new Date();
+  return d.setUTCHours(r, o, a, i), d.setUTCFullYear(s, e - 1, n), d.getTime() + bi * h;
+}
+function ee(t) {
+  const e = no(t), n = 1e3 * t.time.microsecond + t.time.nanosecond;
+  return y.add(Ge(e), y.BigInt(n));
+}
+function ja(t) {
+  let e = Be(t, "trunc"), n = y.toNumber(y.remainder(t, Un));
+  n < 0 && (n += 1e6, e -= 1);
+  const r = Math.floor(n / 1e3) % 1e3, o = n % 1e3, a = new Date(e);
+  return { epochMilliseconds: e, isoDate: { year: a.getUTCFullYear(), month: a.getUTCMonth() + 1, day: a.getUTCDate() }, time: { hour: a.getUTCHours(), minute: a.getUTCMinutes(), second: a.getUTCSeconds(), millisecond: a.getUTCMilliseconds(), microsecond: r, nanosecond: o } };
+}
+function ro(t, e) {
+  if (t === "UTC") return null;
+  const n = Be(e, "floor");
+  if (n < Mn) return ro(t, Ge(Mn));
+  const r = Date.now(), o = Math.max(n, r) + 366 * Et * 3;
+  let a = n, i = $t(t, a), s = a, h = i;
+  for (; i === h && a < o; ) {
+    if (s = a + 2 * Et * 7, s > ya) return null;
+    h = $t(t, s), i === h && (a = s);
+  }
+  return i === h ? null : Ge(Wa(((d) => $t(t, d)), a, s, i, h));
+}
+function qr(t, e) {
+  if (t === "UTC") return null;
+  const n = Be(e, "ceil"), r = Date.now(), o = r + 366 * Et * 3;
+  if (n > o) {
+    const d = qr(t, Ge(o));
+    if (d === null || y.lessThan(d, Ge(r))) return d;
+  }
+  if (t === "Africa/Casablanca" || t === "Africa/El_Aaiun") {
+    const d = Date.UTC(2088, 0, 1);
+    if (d < n) return qr(t, Ge(d));
+  }
+  let a = n - 1;
+  if (a < Mn) return null;
+  let i = $t(t, a), s = a, h = i;
+  for (; i === h && a > Mn; ) {
+    if (s = a - 2 * Et * 7, s < Mn) return null;
+    h = $t(t, s), i === h && (a = s);
+  }
+  return i === h ? null : Ge(Wa(((d) => $t(t, d)), s, a, h, i));
+}
+function xa(t, e) {
+  return (function(n) {
+    const r = n.split(/[^\w]+/);
+    if (r.length !== 7) throw new RangeError(`expected 7 parts in "${n}`);
+    const o = +r[0], a = +r[1];
+    let i = +r[2];
+    const s = r[3];
+    if (s[0] === "b" || s[0] === "B") i = 1 - i;
+    else if (s[0] !== "a" && s[0] !== "A") throw new RangeError(`Unknown era ${s} in "${n}`);
+    const h = r[4] === "24" ? 0 : +r[4], d = +r[5], u = +r[6];
+    if (!(Number.isFinite(i) && Number.isFinite(o) && Number.isFinite(a) && Number.isFinite(h) && Number.isFinite(d) && Number.isFinite(u))) throw new RangeError(`Invalid number in "${n}`);
+    return { year: i, month: o, day: a, hour: h, minute: d, second: u };
+  })(ga(t).format(e));
+}
+function cr(t) {
+  return t !== void 0 && !(t % 4 != 0 || t % 100 == 0 && t % 400 != 0);
+}
+function Ot(t, e) {
+  return { standard: [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], leapyear: [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] }[cr(t) ? "leapyear" : "standard"][e - 1];
+}
+function dr(t) {
+  const e = [c(t, de), c(t, he), c(t, Te), c(t, ue), c(t, le), c(t, me), c(t, fe), c(t, ye), c(t, ge), c(t, Ie)];
+  for (let n = 0; n < e.length; n++) {
+    const r = e[n];
+    if (r !== 0) return r < 0 ? -1 : 1;
+  }
+  return 0;
+}
+function Er(t) {
+  const e = ["years", "months", "weeks", "days"];
+  for (let n = 0; n < e.length; n++) {
+    const r = t[e[n]];
+    if (r !== 0) return r < 0 ? -1 : 1;
+  }
+  return 0;
+}
+function La(t) {
+  const e = Er(t.date);
+  return e !== 0 ? e : t.time.sign();
+}
+function Ct(t, e) {
+  let n = t, r = e;
+  if (!Number.isFinite(n) || !Number.isFinite(r)) throw new RangeError("infinity is out of range");
+  return r -= 1, n += Math.floor(r / 12), r %= 12, r < 0 && (r += 12), r += 1, { year: n, month: r };
+}
+function Oe(t, e, n) {
+  let r = t, o = e, a = n;
+  if (!Number.isFinite(a)) throw new RangeError("infinity is out of range");
+  ({ year: r, month: o } = Ct(r, o));
+  const i = 146097;
+  if (Math.abs(a) > i) {
+    const d = Math.trunc(a / i);
+    r += 400 * d, a -= d * i;
+  }
+  let s = 0, h = o > 2 ? r : r - 1;
+  for (; s = cr(h) ? 366 : 365, a < -s; ) r -= 1, h -= 1, a += s;
+  for (h += 1; s = cr(h) ? 366 : 365, a > s; ) r += 1, h += 1, a -= s;
+  for (; a < 1; ) ({ year: r, month: o } = Ct(r, o - 1)), a += Ot(r, o);
+  for (; a > Ot(r, o); ) a -= Ot(r, o), { year: r, month: o } = Ct(r, o + 1);
+  return { year: r, month: o, day: a };
+}
+function Nn(t, e, n, r, o, a, i, s, h) {
+  const d = gt(r, o, a, i, s, h);
+  return j(Oe(t, e, n + d.deltaDays), d);
+}
+function gt(t, e, n, r, o, a) {
+  let i, s = t, h = e, d = n, u = r, l = o, m = a;
+  ({ div: i, mod: m } = Wt(m, 3)), l += i, m < 0 && (l -= 1, m += 1e3), { div: i, mod: l } = Wt(l, 3), u += i, l < 0 && (u -= 1, l += 1e3), d += Math.trunc(u / 1e3), u %= 1e3, u < 0 && (d -= 1, u += 1e3), h += Math.trunc(d / 60), d %= 60, d < 0 && (h -= 1, d += 60), s += Math.trunc(h / 60), h %= 60, h < 0 && (s -= 1, h += 60);
+  let f = Math.trunc(s / 24);
+  return s %= 24, s < 0 && (f -= 1, s += 24), f += 0, s += 0, h += 0, d += 0, u += 0, l += 0, m += 0, { deltaDays: f, hour: s, minute: h, second: d, millisecond: u, microsecond: l, nanosecond: m };
+}
+function xo(t, e) {
+  const n = re(t, 0);
+  if (Er(n) === 0) return t.days;
+  const r = c(e, C), o = Ne(c(e, b), r, n, "constrain"), a = kt(r.year, r.month - 1, r.day), i = kt(o.year, o.month - 1, o.day) - a;
+  return t.days + i;
+}
+function Ye(t) {
+  return new (te("%Temporal.Duration%"))(-c(t, de), -c(t, he), -c(t, Te), -c(t, ue), -c(t, le), -c(t, me), -c(t, fe), -c(t, ye), -c(t, ge), -c(t, Ie));
+}
+function pe(t, e, n) {
+  return Math.min(n, Math.max(e, t));
+}
+function Ua(t, e, n) {
+  const r = pe(e, 1, 12);
+  return { year: t, month: r, day: pe(n, 1, Ot(t, r)) };
+}
+function G(t, e, n) {
+  if (t < e || t > n) throw new RangeError(`value out of range: ${e} <= ${t} <= ${n}`);
+}
+function Rt(t, e, n) {
+  G(e, 1, 12), G(n, 1, Ot(t, e));
+}
+function Lt(t) {
+  St(j(t, { deltaDays: 0, hour: 12, minute: 0, second: 0, millisecond: 0, microsecond: 0, nanosecond: 0 }));
+}
+function Mr(t, e, n, r, o, a) {
+  G(t, 0, 23), G(e, 0, 59), G(n, 0, 59), G(r, 0, 999), G(o, 0, 999), G(a, 0, 999);
+}
+function oo(t, e, n, r, o, a, i, s, h) {
+  Rt(t, e, n), Mr(r, o, a, i, s, h);
+}
+function St(t) {
+  const e = ee(t);
+  (y.lessThan(e, wi) || y.greaterThan(e, vi)) && Xe(e);
+}
+function Wr(t) {
+  ee(t);
+}
+function Xe(t) {
+  if (y.lessThan(t, On) || y.greaterThan(t, Kt)) throw new RangeError("date/time value is outside of supported range");
+}
+function ao({ year: t, month: e }) {
+  G(t, Eo, Mo), t === Eo ? G(e, 4, 12) : t === Mo && G(e, 1, 9);
+}
+function Dr(t, e, n, r, o, a, i, s, h, d) {
+  let u = 0;
+  const l = [t, e, n, r, o, a, i, s, h, d];
+  for (let E = 0; E < l.length; E++) {
+    const T = l[E];
+    if (T === 1 / 0 || T === -1 / 0) throw new RangeError("infinite values not allowed as duration fields");
+    if (T !== 0) {
+      const D = T < 0 ? -1 : 1;
+      if (u !== 0 && D !== u) throw new RangeError("mixed-sign values not allowed as duration fields");
+      u = D;
+    }
+  }
+  if (Math.abs(t) >= 2 ** 32 || Math.abs(e) >= 2 ** 32 || Math.abs(n) >= 2 ** 32) throw new RangeError("years, months, and weeks must be < 2³²");
+  const m = Wt(s, 3), f = Wt(h, 6), p = Wt(d, 9), v = Wt(1e6 * m.mod + 1e3 * f.mod + p.mod, 9).div, w = 86400 * r + 3600 * o + 60 * a + i + m.div + f.div + p.div + v;
+  if (!Number.isSafeInteger(w)) throw new RangeError("total of duration time units cannot exceed 9007199254740991.999999999 s");
+}
+function qt(t) {
+  return { date: { years: c(t, de), months: c(t, he), weeks: c(t, Te), days: c(t, ue) }, time: k.fromComponents(c(t, le), c(t, me), c(t, fe), c(t, ye), c(t, ge), c(t, Ie)) };
+}
+function Je(t) {
+  const e = k.fromComponents(c(t, le), c(t, me), c(t, fe), c(t, ye), c(t, ge), c(t, Ie)).add24HourDays(c(t, ue));
+  return { date: { years: c(t, de), months: c(t, he), weeks: c(t, Te), days: 0 }, time: e };
+}
+function Pa(t) {
+  const e = Je(t), n = Math.trunc(e.time.sec / 86400);
+  return Dr(e.date.years, e.date.months, e.date.weeks, n, 0, 0, 0, 0, 0, 0), { ...e.date, days: n };
+}
+function Ue(t, e) {
+  const n = t.time.sign();
+  let r = t.time.abs().subsec, o = 0, a = 0, i = t.time.abs().sec, s = 0, h = 0, d = 0;
+  switch (e) {
+    case "year":
+    case "month":
+    case "week":
+    case "day":
+      o = Math.trunc(r / 1e3), r %= 1e3, a = Math.trunc(o / 1e3), o %= 1e3, i += Math.trunc(a / 1e3), a %= 1e3, s = Math.trunc(i / 60), i %= 60, h = Math.trunc(s / 60), s %= 60, d = Math.trunc(h / 24), h %= 24;
+      break;
+    case "hour":
+      o = Math.trunc(r / 1e3), r %= 1e3, a = Math.trunc(o / 1e3), o %= 1e3, i += Math.trunc(a / 1e3), a %= 1e3, s = Math.trunc(i / 60), i %= 60, h = Math.trunc(s / 60), s %= 60;
+      break;
+    case "minute":
+      o = Math.trunc(r / 1e3), r %= 1e3, a = Math.trunc(o / 1e3), o %= 1e3, i += Math.trunc(a / 1e3), a %= 1e3, s = Math.trunc(i / 60), i %= 60;
+      break;
+    case "second":
+      o = Math.trunc(r / 1e3), r %= 1e3, a = Math.trunc(o / 1e3), o %= 1e3, i += Math.trunc(a / 1e3), a %= 1e3;
+      break;
+    case "millisecond":
+      o = Math.trunc(r / 1e3), r %= 1e3, a = $r(i, 3, Math.trunc(o / 1e3)), o %= 1e3, i = 0;
+      break;
+    case "microsecond":
+      o = $r(i, 6, Math.trunc(r / 1e3)), r %= 1e3, i = 0;
+      break;
+    case "nanosecond":
+      r = $r(i, 9, r), i = 0;
+  }
+  return new (te("%Temporal.Duration%"))(t.date.years, t.date.months, t.date.weeks, t.date.days + n * d, n * h, n * s, n * i, n * a, n * o, n * r);
+}
+function ct(t, e) {
+  return Er(t), e.sign(), { date: t, time: e };
+}
+function kt(t, e, n) {
+  return no({ isoDate: { year: t, month: e + 1, day: n }, time: { hour: 0, minute: 0, second: 0, millisecond: 0 } }) / Et;
+}
+function Jt({ year: t, month: e, day: n }) {
+  if (Math.abs(kt(t, e - 1, n)) > 1e8) throw new RangeError("date/time value is outside the supported range");
+}
+function io(t, e) {
+  const n = e.hour - t.hour, r = e.minute - t.minute, o = e.second - t.second, a = e.millisecond - t.millisecond, i = e.microsecond - t.microsecond, s = e.nanosecond - t.nanosecond;
+  return k.fromComponents(n, r, o, a, i, s);
+}
+function so(t, e, n, r, o) {
+  let a = k.fromEpochNsDiff(e, t);
+  return a = hr(a, n, r, o), ct({ years: 0, months: 0, weeks: 0, days: 0 }, a);
+}
+function Za(t, e, n, r) {
+  Wr(t), Wr(e);
+  let o = io(t.time, e.time);
+  const a = o.sign(), i = Qe(t.isoDate, e.isoDate);
+  let s = e.isoDate;
+  i === a && (s = Oe(s.year, s.month, s.day + a), o = o.add24HourDays(-a));
+  const h = st("day", r), d = Wn(n, t.isoDate, s, h);
+  return r !== h && (o = o.add24HourDays(d.days), d.days = 0), ct(d, o);
+}
+function Fa(t, e, n, r, o) {
+  const a = y.subtract(e, t);
+  if (y.equal(a, ke)) return { date: { years: 0, months: 0, weeks: 0, days: 0 }, time: k.ZERO };
+  const i = y.lessThan(a, ke) ? -1 : 1, s = Fe(n, t), h = Fe(n, e);
+  let d, u = 0, l = i === 1 ? 2 : 1, m = io(s.time, h.time);
+  for (m.sign() === -i && u++; u <= l; u++) {
+    d = j(Oe(h.isoDate.year, h.isoDate.month, h.isoDate.day - u * i), s.time);
+    const p = oe(n, d, "compatible");
+    if (m = k.fromEpochNsDiff(e, p), m.sign() !== -i) break;
+  }
+  const f = st("day", o);
+  return ct(Wn(r, s.isoDate, d.isoDate, f), m);
+}
+function Ba(t, e, n, r, o, a, i, s, h) {
+  let d, u, l, m, f = e;
+  switch (s) {
+    case "year": {
+      const U = wt(f.date.years, i, "trunc");
+      d = U, u = U + i * t, l = { years: d, months: 0, weeks: 0, days: 0 }, m = { ...l, years: u };
+      break;
+    }
+    case "month": {
+      const U = wt(f.date.months, i, "trunc");
+      d = U, u = U + i * t, l = re(f.date, 0, 0, d), m = re(f.date, 0, 0, u);
+      break;
+    }
+    case "week": {
+      const U = re(f.date, 0, 0), ae = Ne(a, r.isoDate, U, "constrain"), Re = Wn(a, ae, Oe(ae.year, ae.month, ae.day + f.date.days), "week"), ft = wt(f.date.weeks + Re.weeks, i, "trunc");
+      d = ft, u = ft + i * t, l = re(f.date, 0, d), m = re(f.date, 0, u);
+      break;
+    }
+    case "day": {
+      const U = wt(f.date.days, i, "trunc");
+      d = U, u = U + i * t, l = re(f.date, d), m = re(f.date, u);
+      break;
+    }
+  }
+  const p = Ne(a, r.isoDate, l, "constrain"), v = Ne(a, r.isoDate, m, "constrain");
+  let w, E;
+  const T = j(p, r.time), D = j(v, r.time);
+  o ? (w = oe(o, T, "compatible"), E = oe(o, D, "compatible")) : (w = ee(T), E = ee(D));
+  const Y = k.fromEpochNsDiff(n, w), O = k.fromEpochNsDiff(E, w), W = fr(h, t < 0 ? "negative" : "positive"), K = Y.add(Y).abs().subtract(O.abs()).sign(), H = Math.abs(d) / i % 2 == 0, Z = Y.isZero() ? Math.abs(d) : Y.cmp(O) ? yr(Math.abs(d), Math.abs(u), K, H, W) : Math.abs(u), De = new k(y.add(y.multiply(O.totalNs, y.BigInt(d)), y.multiply(Y.totalNs, y.BigInt(i * t)))).fdiv(O.totalNs), V = Z === Math.abs(u);
+  return f = { date: V ? m : l, time: k.ZERO }, { nudgeResult: { duration: f, nudgedEpochNs: V ? E : w, didExpandCalendarUnit: V }, total: De };
+}
+function Tr(t, e, n, r, o, a, i, s, h) {
+  let d = t;
+  const u = We(s) || r && s === "day", l = La(d) < 0 ? -1 : 1;
+  let m;
+  return u ? { nudgeResult: m } = Ba(l, d, e, n, r, o, i, s, h) : m = r ? (function(f, p, v, w, E, T, D, Y) {
+    let O = p;
+    const W = Ne(E, v.isoDate, O.date, "constrain"), K = j(W, v.time), H = j(Oe(W.year, W.month, W.day + f), v.time), Z = oe(w, K, "compatible"), De = oe(w, H, "compatible"), V = k.fromEpochNsDiff(De, Z);
+    if (V.sign() !== f) throw new RangeError("time zone returned inconsistent Instants");
+    const U = y.BigInt(Xt[D] * T);
+    let ae = O.time.round(U, Y);
+    const Re = ae.subtract(V), ft = Re.sign() !== -f;
+    let Pt, Zt;
+    return ft ? (Pt = f, ae = Re.round(U, Y), Zt = ae.addToEpochNs(De)) : (Pt = 0, Zt = ae.addToEpochNs(Z)), { duration: ct(re(O.date, O.date.days + Pt), ae), nudgedEpochNs: Zt, didExpandCalendarUnit: ft };
+  })(l, d, n, r, o, i, s, h) : (function(f, p, v, w, E, T) {
+    let D = f;
+    const Y = D.time.add24HourDays(D.date.days), O = Y.round(y.BigInt(w * Xt[E]), T), W = O.subtract(Y), { quotient: K } = Y.divmod(rr), { quotient: H } = O.divmod(rr), Z = Math.sign(H - K) === Y.sign(), De = W.addToEpochNs(p);
+    let V = 0, U = O;
+    return ot(v) === "date" && (V = H, U = O.add(k.fromComponents(24 * -H, 0, 0, 0, 0, 0))), { duration: { date: re(D.date, V), time: U }, nudgedEpochNs: De, didExpandCalendarUnit: Z };
+  })(d, e, a, i, s, h), d = m.duration, m.didExpandCalendarUnit && s !== "week" && (d = (function(f, p, v, w, E, T, D, Y) {
+    let O = p;
+    if (Y === D) return O;
+    const W = Dn.indexOf(D);
+    for (let K = Dn.indexOf(Y) - 1; K >= W; K--) {
+      const H = Dn[K];
+      if (H === "week" && D !== "week") continue;
+      let Z;
+      switch (H) {
+        case "year":
+          Z = { years: O.date.years + f, months: 0, weeks: 0, days: 0 };
+          break;
+        case "month": {
+          const U = O.date.months + f;
+          Z = re(O.date, 0, 0, U);
+          break;
+        }
+        case "week": {
+          const U = O.date.weeks + f;
+          Z = re(O.date, 0, U);
+          break;
+        }
+      }
+      const De = j(Ne(T, w.isoDate, Z, "constrain"), w.time);
+      let V;
+      if (V = E ? oe(E, De, "compatible") : ee(De), tr(v, V) === -f) break;
+      O = { date: Z, time: k.ZERO };
+    }
+    return O;
+  })(l, d, m.nudgedEpochNs, n, r, o, a, st(s, "day"))), d;
+}
+function Lo(t, e, n, r, o, a) {
+  return We(a) || r && a === "day" ? Ba(La(t) < 0 ? -1 : 1, t, e, n, r, o, 1, a, "trunc").total : Cn(t.time.add24HourDays(t.date.days), a);
+}
+function za(t, e, n, r, o, a, i) {
+  if (en(t, e) == 0) return { date: { years: 0, months: 0, weeks: 0, days: 0 }, time: k.ZERO };
+  St(t), St(e);
+  const s = Za(t, e, n, r);
+  return a === "nanosecond" && o === 1 ? s : Tr(s, ee(e), t, null, n, r, o, a, i);
+}
+function Aa(t, e, n, r, o, a, i, s) {
+  if (ot(o) === "time") return so(t, e, a, i, s);
+  const h = Fa(t, e, n, r, o);
+  return i === "nanosecond" && a === 1 ? h : Tr(h, e, Fe(n, t), n, r, o, a, i, s);
+}
+function cn(t, e, n, r, o, a) {
+  const i = Vt.reduce(((f, p) => {
+    const v = p[0], w = p[1], E = p[2];
+    return n !== "datetime" && E !== n || r.includes(w) || f.push(w, v), f;
+  }), []);
+  let s = $e(e, "largestUnit", n, "auto");
+  if (r.includes(s)) throw new RangeError(`largestUnit must be one of ${i.join(", ")}, not ${s}`);
+  const h = on(e);
+  let d = Ae(e, "trunc");
+  t === "since" && (d = (function(f) {
+    switch (f) {
+      case "ceil":
+        return "floor";
+      case "floor":
+        return "ceil";
+      case "halfCeil":
+        return "halfFloor";
+      case "halfFloor":
+        return "halfCeil";
+      default:
+        return f;
+    }
+  })(d));
+  const u = $e(e, "smallestUnit", n, o);
+  if (r.includes(u)) throw new RangeError(`smallestUnit must be one of ${i.join(", ")}, not ${u}`);
+  const l = st(a, u);
+  if (s === "auto" && (s = l), st(s, u) !== s) throw new RangeError(`largestUnit ${s} cannot be smaller than smallestUnit ${u}`);
+  const m = { hour: 24, minute: 60, second: 60, millisecond: 1e3, microsecond: 1e3, nanosecond: 1e3 }[u];
+  return m !== void 0 && an(h, m, !1), { largestUnit: s, roundingIncrement: h, roundingMode: d, smallestUnit: u };
+}
+function Uo(t, e, n, r) {
+  const o = pn(n), a = cn(t, M(r), "time", [], "nanosecond", "second");
+  let i = Ue(so(c(e, I), c(o, I), a.roundingIncrement, a.smallestUnit, a.roundingMode), a.largestUnit);
+  return t === "since" && (i = Ye(i)), i;
+}
+function Po(t, e, n, r) {
+  const o = yn(n), a = c(e, b), i = c(o, b);
+  if (!Ve(a, i)) throw new RangeError(`cannot compute difference between dates of ${a} and ${i} calendars`);
+  const s = cn(t, M(r), "date", [], "day", "day"), h = te("%Temporal.Duration%"), d = c(e, C), u = c(o, C);
+  if (Qe(d, u) === 0) return new h();
+  let l = { date: Wn(a, d, u, s.largestUnit), time: k.ZERO };
+  if (s.smallestUnit !== "day" || s.roundingIncrement !== 1) {
+    const f = j(d, { deltaDays: 0, hour: 0, minute: 0, second: 0, millisecond: 0, microsecond: 0, nanosecond: 0 });
+    l = Tr(l, ee(j(u, { deltaDays: 0, hour: 0, minute: 0, second: 0, millisecond: 0, microsecond: 0, nanosecond: 0 })), f, null, a, s.largestUnit, s.roundingIncrement, s.smallestUnit, s.roundingMode);
+  }
+  let m = Ue(l, "day");
+  return t === "since" && (m = Ye(m)), m;
+}
+function Zo(t, e, n, r) {
+  const o = gn(n), a = c(e, b), i = c(o, b);
+  if (!Ve(a, i)) throw new RangeError(`cannot compute difference between dates of ${a} and ${i} calendars`);
+  const s = cn(t, M(r), "datetime", [], "nanosecond", "day"), h = te("%Temporal.Duration%"), d = c(e, P), u = c(o, P);
+  if (en(d, u) === 0) return new h();
+  let l = Ue(za(d, u, a, s.largestUnit, s.roundingIncrement, s.smallestUnit, s.roundingMode), s.largestUnit);
+  return t === "since" && (l = Ye(l)), l;
+}
+function Fo(t, e, n, r) {
+  const o = pt(n), a = cn(t, M(r), "time", [], "nanosecond", "hour");
+  let i = io(c(e, z), c(o, z));
+  i = hr(i, a.roundingIncrement, a.smallestUnit, a.roundingMode);
+  let s = Ue(ct({ years: 0, months: 0, weeks: 0, days: 0 }, i), a.largestUnit);
+  return t === "since" && (s = Ye(s)), s;
+}
+function Bo(t, e, n, r) {
+  const o = wn(n), a = c(e, b), i = c(o, b);
+  if (!Ve(a, i)) throw new RangeError(`cannot compute difference between months of ${a} and ${i} calendars`);
+  const s = cn(t, M(r), "date", ["week", "day"], "month", "year"), h = te("%Temporal.Duration%");
+  if (Qe(c(e, C), c(o, C)) == 0) return new h();
+  const d = be(a, c(e, C), "year-month");
+  d.day = 1;
+  const u = Mt(a, d, "constrain"), l = be(a, c(o, C), "year-month");
+  l.day = 1;
+  const m = Mt(a, l, "constrain");
+  let f = { date: re(Wn(a, u, m, s.largestUnit), 0, 0), time: k.ZERO };
+  if (s.smallestUnit !== "month" || s.roundingIncrement !== 1) {
+    const v = j(u, { deltaDays: 0, hour: 0, minute: 0, second: 0, millisecond: 0, microsecond: 0, nanosecond: 0 });
+    f = Tr(f, ee(j(m, { deltaDays: 0, hour: 0, minute: 0, second: 0, millisecond: 0, microsecond: 0, nanosecond: 0 })), v, null, a, s.largestUnit, s.roundingIncrement, s.smallestUnit, s.roundingMode);
+  }
+  let p = Ue(f, "day");
+  return t === "since" && (p = Ye(p)), p;
+}
+function zo(t, e, n, r) {
+  const o = vn(n), a = c(e, b), i = c(o, b);
+  if (!Ve(a, i)) throw new RangeError(`cannot compute difference between dates of ${a} and ${i} calendars`);
+  const s = cn(t, M(r), "datetime", [], "nanosecond", "hour"), h = c(e, I), d = c(o, I), u = te("%Temporal.Duration%");
+  let l;
+  if (ot(s.largestUnit) !== "date") l = Ue(so(h, d, s.roundingIncrement, s.smallestUnit, s.roundingMode), s.largestUnit);
+  else {
+    const m = c(e, x);
+    if (!Ra(m, c(o, x))) throw new RangeError("When calculating difference between time zones, largestUnit must be 'hours' or smaller because day lengths can vary between time zones due to DST or time zone offset changes.");
+    if (y.equal(h, d)) return new u();
+    l = Ue(Aa(h, d, m, a, s.largestUnit, s.roundingIncrement, s.smallestUnit, s.roundingMode), "hour");
+  }
+  return t === "since" && (l = Ye(l)), l;
+}
+function Qt({ hour: t, minute: e, second: n, millisecond: r, microsecond: o, nanosecond: a }, i) {
+  let s = n, h = a;
+  return s += i.sec, h += i.subsec, gt(t, e, s, r, o, h);
+}
+function Hr(t, e) {
+  const n = e.addToEpochNs(t);
+  return Xe(n), n;
+}
+function bn(t, e, n, r, o = "constrain") {
+  if (Er(r.date) === 0) return Hr(t, r.time);
+  const a = Fe(e, t);
+  return Hr(oe(e, j(Ne(n, a.isoDate, r.date, o), a.time), "compatible"), r.time);
+}
+function Ao(t, e, n) {
+  let r = Ze(n);
+  t === "subtract" && (r = Ye(r));
+  const o = st(rt(e), rt(r));
+  if (We(o)) throw new RangeError("For years, months, or weeks arithmetic, use date arithmetic relative to a starting point");
+  const a = Je(e), i = Je(r);
+  return Ue(ct({ years: 0, months: 0, weeks: 0, days: 0 }, a.time.add(i.time)), o);
+}
+function qo(t, e, n) {
+  let r = Ze(n);
+  t === "subtract" && (r = Ye(r));
+  const o = rt(r);
+  if (ot(o) === "date") throw new RangeError(`Duration field ${o} not supported by Temporal.Instant. Try Temporal.ZonedDateTime instead.`);
+  const a = Je(r);
+  return _e(Hr(c(e, I), a.time));
+}
+function Wo(t, e, n, r) {
+  const o = c(e, b);
+  let a = Ze(n);
+  t === "subtract" && (a = Ye(a));
+  const i = Pa(a), s = N(M(r));
+  return we(Ne(o, c(e, C), i, s), o);
+}
+function Ho(t, e, n, r) {
+  let o = Ze(n);
+  t === "subtract" && (o = Ye(o));
+  const a = N(M(r)), i = c(e, b), s = Je(o), h = c(e, P), d = Qt(h.time, s.time), u = re(s.date, d.deltaDays);
+  return Dr(u.years, u.months, u.weeks, u.days, 0, 0, 0, 0, 0, 0), Le(j(Ne(i, h.isoDate, u, a), d), i);
+}
+function _o(t, e, n) {
+  let r = Ze(n);
+  t === "subtract" && (r = Ye(r));
+  const o = Je(r), { hour: a, minute: i, second: s, millisecond: h, microsecond: d, nanosecond: u } = Qt(c(e, z), o.time);
+  return at(vr(a, i, s, h, d, u, "reject"));
+}
+function Jo(t, e, n, r) {
+  let o = Ze(n);
+  t === "subtract" && (o = Ye(o));
+  const a = N(M(r)), i = dr(o), s = c(e, b), h = be(s, c(e, C), "year-month");
+  h.day = 1;
+  let d = Mt(s, h, "constrain");
+  if (i < 0) {
+    const l = Ne(s, d, { months: 1 }, "constrain");
+    d = Oe(l.year, l.month, l.day - 1);
+  }
+  const u = Pa(o);
+  return Lt(d), _t(Rn(s, be(s, Ne(s, d, u, a), "year-month"), a), s);
+}
+function Go(t, e, n, r) {
+  let o = Ze(n);
+  t === "subtract" && (o = Ye(o));
+  const a = N(M(r)), i = c(e, x), s = c(e, b), h = qt(o);
+  return ne(bn(c(e, I), i, s, h, a), i, s);
+}
+function wt(t, e, n) {
+  const r = Math.trunc(t / e), o = t % e, a = t < 0 ? "negative" : "positive", i = Math.abs(r), s = i + 1, h = Ce(Math.abs(2 * o) - e), d = i % 2 == 0, u = fr(n, a), l = o === 0 ? i : yr(i, s, h, d, u);
+  return e * (a === "positive" ? l : -l);
+}
+function _r(t, e, n, r) {
+  const o = Xt[n] * e;
+  return (function(a, i, s) {
+    const h = nt(a), d = nt(i), u = y.divide(h, d), l = y.remainder(h, d), m = fr(s, "positive");
+    let f, p;
+    y.lessThan(h, ke) ? (f = y.subtract(u, $n), p = u) : (f = u, p = y.add(u, $n));
+    const v = tr(It(y.multiply(l, Xr)), d) * (y.lessThan(h, ke) ? -1 : 1) + 0, w = y.equal(l, ke) ? u : yr(f, p, v, Qo(f), m);
+    return y.multiply(w, d);
+  })(t, y.BigInt(o), r);
+}
+function Jr(t, e, n, r) {
+  Wr(t);
+  const { year: o, month: a, day: i } = t.isoDate, s = Gr(t.time, e, n, r);
+  return j(Oe(o, a, i + s.deltaDays), s);
+}
+function Gr({ hour: t, minute: e, second: n, millisecond: r, microsecond: o, nanosecond: a }, i, s, h) {
+  let d;
+  switch (s) {
+    case "day":
+    case "hour":
+      d = 1e3 * (1e3 * (1e3 * (60 * (60 * t + e) + n) + r) + o) + a;
+      break;
+    case "minute":
+      d = 1e3 * (1e3 * (1e3 * (60 * e + n) + r) + o) + a;
+      break;
+    case "second":
+      d = 1e3 * (1e3 * (1e3 * n + r) + o) + a;
+      break;
+    case "millisecond":
+      d = 1e3 * (1e3 * r + o) + a;
+      break;
+    case "microsecond":
+      d = 1e3 * o + a;
+      break;
+    case "nanosecond":
+      d = a;
+  }
+  const u = Xt[s], l = wt(d, u * i, h) / u;
+  switch (s) {
+    case "day":
+      return { deltaDays: l, hour: 0, minute: 0, second: 0, millisecond: 0, microsecond: 0, nanosecond: 0 };
+    case "hour":
+      return gt(l, 0, 0, 0, 0, 0);
+    case "minute":
+      return gt(t, l, 0, 0, 0, 0);
+    case "second":
+      return gt(t, e, l, 0, 0, 0);
+    case "millisecond":
+      return gt(t, e, n, l, 0, 0);
+    case "microsecond":
+      return gt(t, e, n, r, l, 0);
+    case "nanosecond":
+      return gt(t, e, n, r, o, l);
+    default:
+      throw new Error(`Invalid unit ${s}`);
+  }
+}
+function hr(t, e, n, r) {
+  const o = Xt[n];
+  return t.round(y.BigInt(o * e), r);
+}
+function Cn(t, e) {
+  const n = Xt[e];
+  return t.fdiv(y.BigInt(n));
+}
+function Qe(t, e) {
+  return t.year !== e.year ? Ce(t.year - e.year) : t.month !== e.month ? Ce(t.month - e.month) : t.day !== e.day ? Ce(t.day - e.day) : 0;
+}
+function Kr(t, e) {
+  return t.hour !== e.hour ? Ce(t.hour - e.hour) : t.minute !== e.minute ? Ce(t.minute - e.minute) : t.second !== e.second ? Ce(t.second - e.second) : t.millisecond !== e.millisecond ? Ce(t.millisecond - e.millisecond) : t.microsecond !== e.microsecond ? Ce(t.microsecond - e.microsecond) : t.nanosecond !== e.nanosecond ? Ce(t.nanosecond - e.nanosecond) : 0;
+}
+function en(t, e) {
+  const n = Qe(t.isoDate, e.isoDate);
+  return n !== 0 ? n : Kr(t.time, e.time);
+}
+function qa(t) {
+  const e = ur(t);
+  return globalThis.BigInt !== void 0 ? globalThis.BigInt(e.toString(10)) : e;
+}
+function Be(t, e) {
+  const n = nt(t), { quotient: r, remainder: o } = mn(n, Un);
+  let a = y.toNumber(r);
+  return e === "floor" && y.toNumber(o) < 0 && (a -= 1), e === "ceil" && y.toNumber(o) > 0 && (a += 1), a;
+}
+function Ge(t) {
+  if (!Number.isInteger(t)) throw new RangeError("epoch milliseconds must be an integer");
+  return y.multiply(y.BigInt(t), Un);
+}
+function ur(t) {
+  let e = t;
+  if (typeof t == "object") {
+    const n = t[Symbol.toPrimitive];
+    n && typeof n == "function" && (e = n.call(t, "number"));
+  }
+  if (typeof e == "number") throw new TypeError("cannot convert number to bigint");
+  return typeof e == "bigint" ? y.BigInt(e.toString(10)) : y.BigInt(e);
+}
+const Vr = (() => {
+  let t = y.BigInt(Date.now() % 1e6);
+  return () => {
+    const e = Date.now(), n = y.BigInt(e), r = y.add(Ge(e), t);
+    return t = y.remainder(n, Un), y.greaterThan(r, Kt) ? Kt : y.lessThan(r, On) ? On : r;
+  };
+})();
+function un() {
+  return new Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+function Ce(t) {
+  return t < 0 ? -1 : t > 0 ? 1 : t;
+}
+function M(t) {
+  if (t === void 0) return /* @__PURE__ */ Object.create(null);
+  if (A(t) && t !== null) return t;
+  throw new TypeError("Options parameter must be an object, not " + (t === null ? "null" : typeof t));
+}
+function Nt(t, e) {
+  const n = /* @__PURE__ */ Object.create(null);
+  return n[t] = e, n;
+}
+function dt(t, e, n, r) {
+  let o = t[e];
+  if (o !== void 0) {
+    if (o = pr(o), !n.includes(o)) throw new RangeError(`${e} must be one of ${n.join(", ")}, not ${o}`);
+    return o;
+  }
+  if (r === ut) throw new RangeError(`${e} option is required`);
+  return r;
+}
+function Me(t) {
+  const e = jn(t);
+  if (!Ei.includes(jn(e))) throw new RangeError(`invalid calendar identifier ${e}`);
+  switch (e) {
+    case "ethiopic-amete-alem":
+      return "ethioaa";
+    case "islamicc":
+      return "islamic-civil";
+  }
+  return e;
+}
+function jn(t) {
+  let e = "";
+  for (let n = 0; n < t.length; n++) {
+    const r = t.charCodeAt(n);
+    e += r >= 65 && r <= 90 ? String.fromCharCode(r + 32) : String.fromCharCode(r);
+  }
+  return e;
+}
+function Tt(t) {
+  throw new TypeError(`Do not use built-in arithmetic operators with Temporal objects. When comparing, use ${t === "PlainMonthDay" ? "Temporal.PlainDate.compare(obj1.toPlainDate(year), obj2.toPlainDate(year))" : `Temporal.${t}.compare(obj1, obj2)`}, not obj1 > obj2. When coercing to strings, use \`\${obj}\` or String(obj), not '' + obj. When coercing to numbers, use properties or methods of the object, not \`+obj\`. When concatenating with strings, use \`\${str}\${obj}\` or str.concat(obj), not str + obj. In React, coerce to a string before rendering a Temporal object.`);
+}
+const Oi = new RegExp(`^${ma.source}$`), Yi = new RegExp(`^${/([+-])([01][0-9]|2[0-3])(?::?([0-5][0-9])(?::?([0-5][0-9])(?:[.,](\d{1,9}))?)?)?/.source}$`);
+function Wa(t, e, n, r = t(e), o = t(n)) {
+  let a = e, i = n, s = r, h = o;
+  for (; i - a > 1; ) {
+    let d = Math.trunc((a + i) / 2);
+    const u = t(d);
+    u === s ? (a = d, s = u) : u === h && (i = d, h = u);
+  }
+  return i;
+}
+function Ha(t) {
+  return [...t];
+}
+function _a(t, e) {
+  if (t !== "gregory" && t !== "iso8601") return;
+  const n = Gn[t];
+  let r = e.year;
+  const { dayOfWeek: o, dayOfYear: a, daysInYear: i } = n.isoToDate(e, { dayOfWeek: !0, dayOfYear: !0, daysInYear: !0 }), s = n.getFirstDayOfWeek(), h = n.getMinimalDaysInFirstWeek();
+  let d = (o + 7 - s) % 7, u = (o - a + 7001 - s) % 7, l = Math.floor((a - 1 + u) / 7);
+  if (7 - u >= h && ++l, l == 0) l = (function(m, f, p, v) {
+    let w = (v - m - p + 1) % 7;
+    w < 0 && (w += 7);
+    let E = Math.floor((p + w - 1) / 7);
+    return 7 - w >= f && ++E, E;
+  })(s, h, a + n.isoToDate(n.dateAdd(e, { years: -1 }, "constrain"), { daysInYear: !0 }).daysInYear, o), r--;
+  else if (a >= i - 5) {
+    let m = (d + i - a) % 7;
+    m < 0 && (m += 7), 6 - m >= h && a + 7 - d > i && (l = 1, r++);
+  }
+  return { week: l, year: r };
+}
+function Ko(t, e, n, r, o) {
+  if (e !== o.year) {
+    if (t * (e - o.year) > 0) return !0;
+  } else if (n !== o.month) {
+    if (t * (n - o.month) > 0) return !0;
+  } else if (r !== o.day && t * (r - o.day) > 0) return !0;
+  return !1;
+}
+const Gn = {};
+function jt(t) {
+  if (!t.startsWith("M")) throw new RangeError(`Invalid month code: ${t}.  Month codes must start with M.`);
+  const e = +t.slice(1);
+  if (Number.isNaN(e)) throw new RangeError(`Invalid month code: ${t}`);
+  return e;
+}
+function Ke(t, e = !1) {
+  return `M${`${t}`.padStart(2, "0")}${e ? "L" : ""}`;
+}
+function co(t, e = void 0, n = 12) {
+  let { month: r, monthCode: o } = t;
+  if (o === void 0) {
+    if (r === void 0) throw new TypeError("Either month or monthCode are required");
+    e === "reject" && G(r, 1, n), e === "constrain" && (r = pe(r, 1, n)), o = Ke(r);
+  } else {
+    const a = jt(o);
+    if (o !== Ke(a)) throw new RangeError(`Invalid month code: ${o}`);
+    if (r !== void 0 && r !== a) throw new RangeError(`monthCode ${o} and month ${r} must match if both are present`);
+    if (r = a, r < 1 || r > n) throw new RangeError(`Invalid monthCode: ${o}`);
+  }
+  return { ...t, month: r, monthCode: o };
+}
+Gn.iso8601 = { resolveFields(t, e) {
+  if ((e === "date" || e === "year-month") && t.year === void 0) throw new TypeError("year is required");
+  if ((e === "date" || e === "month-day") && t.day === void 0) throw new TypeError("day is required");
+  Object.assign(t, co(t));
+}, dateToISO: (t, e) => Tn(t.year, t.month, t.day, e), monthDayToISOReferenceDate(t, e) {
+  const { month: n, day: r } = Tn(t.year ?? 1972, t.month, t.day, e);
+  return { month: n, day: r, year: 1972 };
+}, extraFields: () => [], fieldKeysToIgnore(t) {
+  const e = /* @__PURE__ */ new Set();
+  for (let n = 0; n < t.length; n++) {
+    const r = t[n];
+    e.add(r), r === "month" ? e.add("monthCode") : r === "monthCode" && e.add("month");
+  }
+  return Ha(e);
+}, dateAdd(t, { years: e = 0, months: n = 0, weeks: r = 0, days: o = 0 }, a) {
+  let { year: i, month: s, day: h } = t;
+  return i += e, s += n, { year: i, month: s } = Ct(i, s), { year: i, month: s, day: h } = Tn(i, s, h, a), h += o + 7 * r, Oe(i, s, h);
+}, dateUntil(t, e, n) {
+  const r = -Qe(t, e);
+  if (r === 0) return { years: 0, months: 0, weeks: 0, days: 0 };
+  let o, a = 0, i = 0;
+  if (n === "year" || n === "month") {
+    let u = e.year - t.year;
+    for (u !== 0 && (u -= r); !Ko(r, t.year + u, t.month, t.day, e); ) a = u, u += r;
+    let l = r;
+    for (o = Ct(t.year + a, t.month + l); !Ko(r, o.year, o.month, t.day, e); ) i = l, l += r, o = Ct(o.year, o.month + r);
+    n === "month" && (i += 12 * a, a = 0);
+  }
+  o = Ct(t.year + a, t.month + i);
+  const s = Ua(o.year, o.month, t.day);
+  let h = 0, d = kt(e.year, e.month - 1, e.day) - kt(s.year, s.month - 1, s.day);
+  return n === "week" && (h = Math.trunc(d / 7), d %= 7), { years: a, months: i, weeks: h, days: d };
+}, isoToDate({ year: t, month: e, day: n }, r) {
+  const o = { era: void 0, eraYear: void 0, year: t, month: e, day: n, daysInWeek: 7, monthsInYear: 12 };
+  if (r.monthCode && (o.monthCode = Ke(e)), r.dayOfWeek) {
+    const a = e + (e < 3 ? 10 : -2), i = t - (e < 3 ? 1 : 0), s = Math.floor(i / 100), h = i - 100 * s, d = (n + Math.floor(2.6 * a - 0.2) + (h + Math.floor(h / 4)) + (Math.floor(s / 4) - 2 * s)) % 7;
+    o.dayOfWeek = d + (d <= 0 ? 7 : 0);
+  }
+  if (r.dayOfYear) {
+    let a = n;
+    for (let i = e - 1; i > 0; i--) a += Ot(t, i);
+    o.dayOfYear = a;
+  }
+  return r.weekOfYear && (o.weekOfYear = _a("iso8601", { year: t, month: e, day: n })), r.daysInMonth && (o.daysInMonth = Ot(t, e)), (r.daysInYear || r.inLeapYear) && (o.inLeapYear = cr(t), o.daysInYear = o.inLeapYear ? 366 : 365), o;
+}, getFirstDayOfWeek: () => 1, getMinimalDaysInFirstWeek: () => 4 };
+class J {
+  constructor(e) {
+    if (this.map = /* @__PURE__ */ new Map(), this.calls = 0, this.hits = 0, this.misses = 0, e !== void 0) {
+      let n = 0;
+      for (const r of e.map.entries()) {
+        if (++n > J.MAX_CACHE_ENTRIES) break;
+        this.map.set(...r);
+      }
+    }
+  }
+  get(e) {
+    const n = this.map.get(e);
+    return n && (this.hits++, this.report()), this.calls++, n;
+  }
+  set(e, n) {
+    this.map.set(e, n), this.misses++, this.report();
+  }
+  report() {
+  }
+  setObject(e) {
+    if (J.objectMap.get(e)) throw new RangeError("object already cached");
+    J.objectMap.set(e, this), this.report();
+  }
+  static getCacheForObject(e) {
+    let n = J.objectMap.get(e);
+    return n || (n = new J(), J.objectMap.set(e, n)), n;
+  }
+}
+function Ja({ isoYear: t, isoMonth: e, isoDay: n }) {
+  return `${Jn(t)}-${je(e)}-${je(n)}T00:00Z`;
+}
+function Rr(t, e) {
+  return { years: t.year - e.year, months: t.month - e.month, days: t.day - e.day };
+}
+J.objectMap = /* @__PURE__ */ new WeakMap(), J.MAX_CACHE_ENTRIES = 1e3;
+class Ut {
+  constructor() {
+    this.eras = [], this.hasEra = !1, this.erasBeginMidYear = !1;
+  }
+  getFormatter() {
+    return this.formatter === void 0 && (this.formatter = new Intl.DateTimeFormat(`en-US-u-ca-${this.id}`, { day: "numeric", month: "numeric", year: "numeric", era: "short", timeZone: "UTC" })), this.formatter;
+  }
+  getCalendarParts(e) {
+    let n = this.getFormatter(), r = new Date(e);
+    if (e === "-271821-04-19T00:00Z") {
+      const o = n.resolvedOptions();
+      n = new Intl.DateTimeFormat(o.locale, { ...o, timeZone: "Etc/GMT+1" }), r = /* @__PURE__ */ new Date("-271821-04-20T00:00Z");
+    }
+    try {
+      return n.formatToParts(r);
+    } catch {
+      throw new RangeError(`Invalid ISO date: ${e}`);
+    }
+  }
+  isoToCalendarDate(e, n) {
+    const { year: r, month: o, day: a } = e, i = JSON.stringify({ func: "isoToCalendarDate", isoYear: r, isoMonth: o, isoDay: a, id: this.id }), s = n.get(i);
+    if (s) return s;
+    const h = Ja({ isoYear: r, isoMonth: o, isoDay: a }), d = this.getCalendarParts(h), u = {};
+    for (let m = 0; m < d.length; m++) {
+      const { type: f, value: p } = d[m];
+      if (f !== "year" && f !== "relatedYear" || (this.hasEra ? u.eraYear = +p : u.year = +p), f === "month") {
+        const v = /^([0-9]*)(.*?)$/.exec(p);
+        if (!v || v.length != 3 || !v[1] && !v[2]) throw new RangeError(`Unexpected month: ${p}`);
+        if (u.month = v[1] ? +v[1] : 1, u.month < 1) throw new RangeError(`Invalid month ${p} from ${h}[u-ca-${this.id}] (probably due to https://bugs.chromium.org/p/v8/issues/detail?id=10527)`);
+        if (u.month > 13) throw new RangeError(`Invalid month ${p} from ${h}[u-ca-${this.id}] (probably due to https://bugs.chromium.org/p/v8/issues/detail?id=10529)`);
+        v[2] && (u.monthExtra = v[2]);
+      }
+      f === "day" && (u.day = +p), this.hasEra && f === "era" && p != null && p !== "" && (u.era = p.split(" (")[0].normalize("NFD").replace(/[^-0-9 \p{L}]/gu, "").replace(/ /g, "-").toLowerCase());
+    }
+    if (this.hasEra && u.eraYear === void 0) throw new RangeError(`Intl.DateTimeFormat.formatToParts lacks relatedYear in ${this.id} calendar. Try Node 14+ or modern browsers.`);
+    if (this.hasEra) {
+      const m = this.eras.find(((f) => u.era === f.genericName));
+      m && (u.era = m.code);
+    }
+    if (this.reviseIntlEra) {
+      const { era: m, eraYear: f } = this.reviseIntlEra(u, e);
+      u.era = m, u.eraYear = f;
+    }
+    this.checkIcuBugs && this.checkIcuBugs(e);
+    const l = this.adjustCalendarDate(u, n, "constrain", !0);
+    if (l.year === void 0) throw new RangeError(`Missing year converting ${JSON.stringify(e)}`);
+    if (l.month === void 0) throw new RangeError(`Missing month converting ${JSON.stringify(e)}`);
+    if (l.day === void 0) throw new RangeError(`Missing day converting ${JSON.stringify(e)}`);
+    return n.set(i, l), ["constrain", "reject"].forEach(((m) => {
+      const f = JSON.stringify({ func: "calendarToIsoDate", year: l.year, month: l.month, day: l.day, overflow: m, id: this.id });
+      n.set(f, e);
+    })), l;
+  }
+  validateCalendarDate(e) {
+    const { month: n, year: r, day: o, eraYear: a, monthCode: i, monthExtra: s } = e;
+    if (s !== void 0) throw new RangeError("Unexpected `monthExtra` value");
+    if (r === void 0 && a === void 0) throw new TypeError("year or eraYear is required");
+    if (n === void 0 && i === void 0) throw new TypeError("month or monthCode is required");
+    if (o === void 0) throw new RangeError("Missing day");
+    if (i !== void 0) {
+      if (typeof i != "string") throw new RangeError("monthCode must be a string, not " + typeof i);
+      if (!/^M([01]?\d)(L?)$/.test(i)) throw new RangeError(`Invalid monthCode: ${i}`);
+    }
+    if (this.hasEra && e.era === void 0 != (e.eraYear === void 0)) throw new TypeError("properties era and eraYear must be provided together");
+  }
+  adjustCalendarDate(e, n = void 0, r = "constrain", o = !1) {
+    if (this.calendarType === "lunisolar") throw new RangeError("Override required for lunisolar calendars");
+    let a = e;
+    this.validateCalendarDate(a);
+    const i = this.monthsInYear(a, n);
+    let { month: s, monthCode: h } = a;
+    return { month: s, monthCode: h } = co(a, r, i), { ...a, month: s, monthCode: h };
+  }
+  regulateMonthDayNaive(e, n, r) {
+    const o = this.monthsInYear(e, r);
+    let { month: a, day: i } = e;
+    return n === "reject" ? (G(a, 1, o), G(i, 1, this.maximumMonthLength(e))) : (a = pe(a, 1, o), i = pe(i, 1, this.maximumMonthLength({ ...e, month: a }))), { ...e, month: a, day: i };
+  }
+  calendarToIsoDate(e, n = "constrain", r) {
+    const o = e;
+    let a = this.adjustCalendarDate(e, r, n, !1);
+    a = this.regulateMonthDayNaive(a, n, r);
+    const { year: i, month: s, day: h } = a, d = JSON.stringify({ func: "calendarToIsoDate", year: i, month: s, day: h, overflow: n, id: this.id });
+    let u, l = r.get(d);
+    if (l || o.year !== void 0 && o.month !== void 0 && o.day !== void 0 && (o.year !== a.year || o.month !== a.month || o.day !== a.day) && (u = JSON.stringify({ func: "calendarToIsoDate", year: o.year, month: o.month, day: o.day, overflow: n, id: this.id }), l = r.get(u), l)) return l;
+    let m = this.estimateIsoDate({ year: i, month: s, day: h });
+    const f = (T) => {
+      let D = this.addDaysIso(m, T);
+      if (a.day > this.minimumMonthLength(a)) {
+        let Y = this.isoToCalendarDate(D, r);
+        for (; Y.month !== s || Y.year !== i; ) {
+          if (n === "reject") throw new RangeError(`day ${h} does not exist in month ${s} of year ${i}`);
+          D = this.addDaysIso(D, -1), Y = this.isoToCalendarDate(D, r);
+        }
+      }
+      return D;
+    };
+    let p = 0, v = this.isoToCalendarDate(m, r), w = Rr(a, v);
+    if (w.years !== 0 || w.months !== 0 || w.days !== 0) {
+      const T = 365 * w.years + 30 * w.months + w.days;
+      m = this.addDaysIso(m, T), v = this.isoToCalendarDate(m, r), w = Rr(a, v), w.years === 0 && w.months === 0 ? m = f(w.days) : p = this.compareCalendarDates(a, v);
+    }
+    let E = 8;
+    for (; p; ) {
+      m = this.addDaysIso(m, p * E);
+      const T = v;
+      v = this.isoToCalendarDate(m, r);
+      const D = p;
+      if (p = this.compareCalendarDates(a, v), p) {
+        if (w = Rr(a, v), w.years === 0 && w.months === 0) m = f(w.days), p = 0;
+        else if (D && p !== D) if (E > 1) E /= 2;
+        else {
+          if (n === "reject") throw new RangeError(`Can't find ISO date from calendar date: ${JSON.stringify({ ...o })}`);
+          this.compareCalendarDates(v, T) > 0 && (m = this.addDaysIso(m, -1)), p = 0;
+        }
+      }
+    }
+    if (r.set(d, m), u && r.set(u, m), a.year === void 0 || a.month === void 0 || a.day === void 0 || a.monthCode === void 0 || this.hasEra && (a.era === void 0 || a.eraYear === void 0)) throw new RangeError("Unexpected missing property");
+    return m;
+  }
+  compareCalendarDates(e, n) {
+    return e.year !== n.year ? Ce(e.year - n.year) : e.month !== n.month ? Ce(e.month - n.month) : e.day !== n.day ? Ce(e.day - n.day) : 0;
+  }
+  regulateDate(e, n = "constrain", r) {
+    const o = this.calendarToIsoDate(e, n, r);
+    return this.isoToCalendarDate(o, r);
+  }
+  addDaysIso(e, n) {
+    return Oe(e.year, e.month, e.day + n);
+  }
+  addDaysCalendar(e, n, r) {
+    const o = this.calendarToIsoDate(e, "constrain", r), a = this.addDaysIso(o, n);
+    return this.isoToCalendarDate(a, r);
+  }
+  addMonthsCalendar(e, n, r, o) {
+    let a = e;
+    const { day: i } = a;
+    for (let s = 0, h = Math.abs(n); s < h; s++) {
+      const { month: d } = a, u = a, l = n < 0 ? -Math.max(i, this.daysInPreviousMonth(a, o)) : this.daysInMonth(a, o), m = this.calendarToIsoDate(a, "constrain", o);
+      let f = this.addDaysIso(m, l);
+      if (a = this.isoToCalendarDate(f, o), n > 0) {
+        const p = this.monthsInYear(u, o);
+        for (; a.month - 1 != d % p; ) f = this.addDaysIso(f, -1), a = this.isoToCalendarDate(f, o);
+      }
+      a.day !== i && (a = this.regulateDate({ ...a, day: i }, "constrain", o));
+    }
+    if (r === "reject" && a.day !== i) throw new RangeError(`Day ${i} does not exist in resulting calendar month`);
+    return a;
+  }
+  addCalendar(e, { years: n = 0, months: r = 0, weeks: o = 0, days: a = 0 }, i, s) {
+    const { year: h, day: d, monthCode: u } = e, l = this.adjustCalendarDate({ year: h + n, monthCode: u, day: d }, s), m = this.addMonthsCalendar(l, r, i, s), f = a + 7 * o;
+    return this.addDaysCalendar(m, f, s);
+  }
+  untilCalendar(e, n, r, o) {
+    let a = 0, i = 0, s = 0, h = 0;
+    switch (r) {
+      case "day":
+        a = this.calendarDaysUntil(e, n, o);
+        break;
+      case "week": {
+        const d = this.calendarDaysUntil(e, n, o);
+        a = d % 7, i = (d - a) / 7;
+        break;
+      }
+      case "month":
+      case "year": {
+        const d = this.compareCalendarDates(n, e);
+        if (!d) return { years: 0, months: 0, weeks: 0, days: 0 };
+        const u = n.year - e.year, l = n.day - e.day;
+        if (r === "year" && u) {
+          let p = 0;
+          n.monthCode > e.monthCode && (p = 1), n.monthCode < e.monthCode && (p = -1), p || (p = Math.sign(l)), h = p * d < 0 ? u - d : u;
+        }
+        let m, f = h ? this.addCalendar(e, { years: h }, "constrain", o) : e;
+        do
+          s += d, m = f, f = this.addMonthsCalendar(m, d, "constrain", o), f.day !== e.day && (f = this.regulateDate({ ...f, day: e.day }, "constrain", o));
+        while (this.compareCalendarDates(n, f) * d >= 0);
+        s -= d, a = this.calendarDaysUntil(m, n, o);
+        break;
+      }
+    }
+    return { years: h, months: s, weeks: i, days: a };
+  }
+  daysInMonth(e, n) {
+    const { day: r } = e, o = this.maximumMonthLength(e), a = this.minimumMonthLength(e);
+    if (a === o) return a;
+    const i = r <= o - a ? o : a, s = this.calendarToIsoDate(e, "constrain", n), h = this.addDaysIso(s, i), d = this.isoToCalendarDate(h, n), u = this.addDaysIso(h, -d.day);
+    return this.isoToCalendarDate(u, n).day;
+  }
+  daysInPreviousMonth(e, n) {
+    const { day: r, month: o, year: a } = e;
+    let i = { year: o > 1 ? a : a - 1, month: o, day: 1 };
+    const s = o > 1 ? o - 1 : this.monthsInYear(i, n);
+    i = { ...i, month: s };
+    const h = this.minimumMonthLength(i), d = this.maximumMonthLength(i);
+    if (h === d) return d;
+    const u = this.calendarToIsoDate(e, "constrain", n), l = this.addDaysIso(u, -r);
+    return this.isoToCalendarDate(l, n).day;
+  }
+  startOfCalendarYear(e) {
+    return { year: e.year, month: 1, monthCode: "M01", day: 1 };
+  }
+  startOfCalendarMonth(e) {
+    return { year: e.year, month: e.month, day: 1 };
+  }
+  calendarDaysUntil(e, n, r) {
+    const o = this.calendarToIsoDate(e, "constrain", r), a = this.calendarToIsoDate(n, "constrain", r);
+    return kt(a.year, a.month - 1, a.day) - kt(o.year, o.month - 1, o.day);
+  }
+  monthDaySearchStartYear(e, n) {
+    return 1972;
+  }
+  monthDayFromFields(e, n, r) {
+    let o, a, i, s, h, { era: d, eraYear: u, year: l, month: m, monthCode: f, day: p } = e;
+    if (m !== void 0 && l === void 0 && (!this.hasEra || d === void 0 || u === void 0)) throw new TypeError("when month is present, year (or era and eraYear) are required");
+    (f === void 0 || l !== void 0 || this.hasEra && u !== void 0) && ({ monthCode: f, day: p } = this.isoToCalendarDate(this.calendarToIsoDate(e, n, r), r));
+    const v = { year: this.monthDaySearchStartYear(f, p), month: 12, day: 31 }, w = this.isoToCalendarDate(v, r), E = w.monthCode > f || w.monthCode === f && w.day >= p ? w.year : w.year - 1;
+    for (let T = 0; T < 20; T++) {
+      const D = this.adjustCalendarDate({ day: p, monthCode: f, year: E - T }, r), Y = this.calendarToIsoDate(D, "constrain", r), O = this.isoToCalendarDate(Y, r);
+      if ({ year: o, month: a, day: i } = Y, O.monthCode === f && O.day === p) return { month: a, day: i, year: o };
+      if (n === "constrain") {
+        const W = this.maxLengthOfMonthCodeInAnyYear(O.monthCode);
+        if (O.monthCode === f && O.day === W && p > W) return { month: a, day: i, year: o };
+        (s === void 0 || O.monthCode === s.monthCode && O.day > s.day) && (s = O, h = Y);
+      }
+    }
+    if (n === "constrain" && h !== void 0) return h;
+    throw new RangeError(`No recent ${this.id} year with monthCode ${f} and day ${p}`);
+  }
+  getFirstDayOfWeek() {
+  }
+  getMinimalDaysInFirstWeek() {
+  }
+}
+class Ri extends Ut {
+  constructor() {
+    super(...arguments), this.id = "hebrew", this.calendarType = "lunisolar", this.months = { Tishri: { leap: 1, regular: 1, monthCode: "M01", days: 30 }, Heshvan: { leap: 2, regular: 2, monthCode: "M02", days: { min: 29, max: 30 } }, Kislev: { leap: 3, regular: 3, monthCode: "M03", days: { min: 29, max: 30 } }, Tevet: { leap: 4, regular: 4, monthCode: "M04", days: 29 }, Shevat: { leap: 5, regular: 5, monthCode: "M05", days: 30 }, Adar: { leap: void 0, regular: 6, monthCode: "M06", days: 29 }, "Adar I": { leap: 6, regular: void 0, monthCode: "M05L", days: 30 }, "Adar II": { leap: 7, regular: void 0, monthCode: "M06", days: 29 }, Nisan: { leap: 8, regular: 7, monthCode: "M07", days: 30 }, Iyar: { leap: 9, regular: 8, monthCode: "M08", days: 29 }, Sivan: { leap: 10, regular: 9, monthCode: "M09", days: 30 }, Tamuz: { leap: 11, regular: 10, monthCode: "M10", days: 29 }, Av: { leap: 12, regular: 11, monthCode: "M11", days: 30 }, Elul: { leap: 13, regular: 12, monthCode: "M12", days: 29 } };
+  }
+  inLeapYear(e) {
+    const { year: n } = e;
+    return (7 * n + 1) % 19 < 7;
+  }
+  monthsInYear(e) {
+    return this.inLeapYear(e) ? 13 : 12;
+  }
+  minimumMonthLength(e) {
+    return this.minMaxMonthLength(e, "min");
+  }
+  maximumMonthLength(e) {
+    return this.minMaxMonthLength(e, "max");
+  }
+  minMaxMonthLength(e, n) {
+    const { month: r, year: o } = e, a = this.getMonthCode(o, r), i = Object.entries(this.months).find(((h) => h[1].monthCode === a));
+    if (i === void 0) throw new RangeError(`unmatched Hebrew month: ${r}`);
+    const s = i[1].days;
+    return typeof s == "number" ? s : s[n];
+  }
+  maxLengthOfMonthCodeInAnyYear(e) {
+    return ["M04", "M06", "M08", "M10", "M12"].includes(e) ? 29 : 30;
+  }
+  estimateIsoDate(e) {
+    const { year: n } = e;
+    return { year: n - 3760, month: 1, day: 1 };
+  }
+  getMonthCode(e, n) {
+    return this.inLeapYear({ year: e }) ? n === 6 ? Ke(5, !0) : Ke(n < 6 ? n : n - 1) : Ke(n);
+  }
+  adjustCalendarDate(e, n, r = "constrain", o = !1) {
+    let { year: a, month: i, monthCode: s, day: h, monthExtra: d } = e;
+    if (a === void 0) throw new TypeError("Missing property: year");
+    if (o) {
+      if (d) {
+        const u = this.months[d];
+        if (!u) throw new RangeError(`Unrecognized month from formatToParts: ${d}`);
+        i = this.inLeapYear({ year: a }) ? u.leap : u.regular;
+      }
+      return s = this.getMonthCode(a, i), { year: a, month: i, day: h, monthCode: s };
+    }
+    if (this.validateCalendarDate(e), i === void 0) if (s.endsWith("L")) {
+      if (s !== "M05L") throw new RangeError(`Hebrew leap month must have monthCode M05L, not ${s}`);
+      if (i = 6, !this.inLeapYear({ year: a })) {
+        if (r === "reject") throw new RangeError(`Hebrew monthCode M05L is invalid in year ${a} which is not a leap year`);
+        i = 6, s = "M06";
+      }
+    } else {
+      i = jt(s), this.inLeapYear({ year: a }) && i >= 6 && i++;
+      const u = this.monthsInYear({ year: a });
+      if (i < 1 || i > u) throw new RangeError(`Invalid monthCode: ${s}`);
+    }
+    else if (r === "reject" ? (G(i, 1, this.monthsInYear({ year: a })), G(h, 1, this.maximumMonthLength({ year: a, month: i }))) : (i = pe(i, 1, this.monthsInYear({ year: a })), h = pe(h, 1, this.maximumMonthLength({ year: a, month: i }))), s === void 0) s = this.getMonthCode(a, i);
+    else if (this.getMonthCode(a, i) !== s) throw new RangeError(`monthCode ${s} doesn't correspond to month ${i} in Hebrew year ${a}`);
+    return { ...e, day: h, month: i, monthCode: s, year: a };
+  }
+}
+class dn extends Ut {
+  constructor() {
+    super(...arguments), this.calendarType = "lunar", this.DAYS_PER_ISLAMIC_YEAR = 354 + 11 / 30, this.DAYS_PER_ISO_YEAR = 365.2425;
+  }
+  inLeapYear(e, n) {
+    const r = { year: e.year, month: 1, monthCode: "M01", day: 1 }, o = { year: e.year + 1, month: 1, monthCode: "M01", day: 1 };
+    return this.calendarDaysUntil(r, o, n) === 355;
+  }
+  monthsInYear() {
+    return 12;
+  }
+  minimumMonthLength() {
+    return 29;
+  }
+  maximumMonthLength() {
+    return 30;
+  }
+  maxLengthOfMonthCodeInAnyYear() {
+    return 30;
+  }
+  estimateIsoDate(e) {
+    const { year: n } = this.adjustCalendarDate(e);
+    return { year: Math.floor(n * this.DAYS_PER_ISLAMIC_YEAR / this.DAYS_PER_ISO_YEAR) + 622, month: 1, day: 1 };
+  }
+}
+class Si extends dn {
+  constructor() {
+    super(...arguments), this.id = "islamic";
+  }
+}
+class ki extends dn {
+  constructor() {
+    super(...arguments), this.id = "islamic-umalqura";
+  }
+}
+class Ni extends dn {
+  constructor() {
+    super(...arguments), this.id = "islamic-tbla";
+  }
+}
+class ji extends dn {
+  constructor() {
+    super(...arguments), this.id = "islamic-civil";
+  }
+}
+class xi extends dn {
+  constructor() {
+    super(...arguments), this.id = "islamic-rgsa";
+  }
+}
+class Li extends dn {
+  constructor() {
+    super(...arguments), this.id = "islamicc";
+  }
+}
+class Ui extends Ut {
+  constructor() {
+    super(...arguments), this.id = "persian", this.calendarType = "solar";
+  }
+  inLeapYear(e, n) {
+    return this.daysInMonth({ year: e.year, month: 12, day: 1 }, n) === 30;
+  }
+  monthsInYear() {
+    return 12;
+  }
+  minimumMonthLength(e) {
+    const { month: n } = e;
+    return n === 12 ? 29 : n <= 6 ? 31 : 30;
+  }
+  maximumMonthLength(e) {
+    const { month: n } = e;
+    return n === 12 ? 30 : n <= 6 ? 31 : 30;
+  }
+  maxLengthOfMonthCodeInAnyYear(e) {
+    return jt(e) <= 6 ? 31 : 30;
+  }
+  estimateIsoDate(e) {
+    const { year: n } = this.adjustCalendarDate(e);
+    return { year: n + 621, month: 1, day: 1 };
+  }
+}
+class Pi extends Ut {
+  constructor() {
+    super(...arguments), this.id = "indian", this.calendarType = "solar", this.months = { 1: { length: 30, month: 3, day: 22, leap: { length: 31, month: 3, day: 21 } }, 2: { length: 31, month: 4, day: 21 }, 3: { length: 31, month: 5, day: 22 }, 4: { length: 31, month: 6, day: 22 }, 5: { length: 31, month: 7, day: 23 }, 6: { length: 31, month: 8, day: 23 }, 7: { length: 30, month: 9, day: 23 }, 8: { length: 30, month: 10, day: 23 }, 9: { length: 30, month: 11, day: 22 }, 10: { length: 30, month: 12, day: 22 }, 11: { length: 30, month: 1, nextYear: !0, day: 21 }, 12: { length: 30, month: 2, nextYear: !0, day: 20 } }, this.vulnerableToBceBug = (/* @__PURE__ */ new Date("0000-01-01T00:00Z")).toLocaleDateString("en-US-u-ca-indian", { timeZone: "UTC" }) !== "10/11/-79 Saka";
+  }
+  inLeapYear(e) {
+    return ho(e.year + 78);
+  }
+  monthsInYear() {
+    return 12;
+  }
+  minimumMonthLength(e) {
+    return this.getMonthInfo(e).length;
+  }
+  maximumMonthLength(e) {
+    return this.getMonthInfo(e).length;
+  }
+  maxLengthOfMonthCodeInAnyYear(e) {
+    const n = jt(e);
+    let r = this.months[n];
+    return r = r.leap ?? r, r.length;
+  }
+  getMonthInfo(e) {
+    const { month: n } = e;
+    let r = this.months[n];
+    if (r === void 0) throw new RangeError(`Invalid month: ${n}`);
+    return this.inLeapYear(e) && r.leap && (r = r.leap), r;
+  }
+  estimateIsoDate(e) {
+    const n = this.adjustCalendarDate(e), r = this.getMonthInfo(n);
+    return Oe(n.year + 78 + (r.nextYear ? 1 : 0), r.month, r.day + n.day - 1);
+  }
+  checkIcuBugs(e) {
+    if (this.vulnerableToBceBug && e.year < 1) throw new RangeError(`calendar '${this.id}' is broken for ISO dates before 0001-01-01 (see https://bugs.chromium.org/p/v8/issues/detail?id=10529)`);
+  }
+}
+function ho(t) {
+  return t % 4 == 0 && (t % 100 != 0 || t % 400 == 0);
+}
+class Ga extends Ut {
+  constructor(e, n) {
+    super(), this.calendarType = "solar", this.id = e, this.isoEpoch = n;
+  }
+  inLeapYear(e) {
+    const { year: n } = this.estimateIsoDate({ month: 1, day: 1, year: e.year });
+    return ho(n);
+  }
+  monthsInYear() {
+    return 12;
+  }
+  minimumMonthLength(e) {
+    const { month: n } = e;
+    return n === 2 ? this.inLeapYear(e) ? 29 : 28 : [4, 6, 9, 11].indexOf(n) >= 0 ? 30 : 31;
+  }
+  maximumMonthLength(e) {
+    return this.minimumMonthLength(e);
+  }
+  maxLengthOfMonthCodeInAnyYear(e) {
+    return [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][jt(e) - 1];
+  }
+  estimateIsoDate(e) {
+    const n = this.adjustCalendarDate(e);
+    return Tn(n.year + this.isoEpoch.year, n.month + this.isoEpoch.month, n.day + this.isoEpoch.day, "constrain");
+  }
+}
+class Ka extends Ut {
+  constructor(e, n) {
+    super(), this.hasEra = !0, this.calendarType = "solar", this.id = e;
+    const { eras: r, anchorEra: o } = (function(a) {
+      let i, s = a;
+      if (s.length === 0) throw new RangeError("Invalid era data: eras are required");
+      if (s.length === 1 && s[0].reverseOf) throw new RangeError("Invalid era data: anchor era cannot count years backwards");
+      if (s.length === 1 && !s[0].code) throw new RangeError("Invalid era data: at least one named era is required");
+      if (s.filter(((d) => d.reverseOf != null)).length > 1) throw new RangeError("Invalid era data: only one era can count years backwards");
+      s.forEach(((d) => {
+        if (d.isAnchor || !d.anchorEpoch && !d.reverseOf) {
+          if (i) throw new RangeError("Invalid era data: cannot have multiple anchor eras");
+          i = d, d.anchorEpoch = { year: d.hasYearZero ? 0 : 1 };
+        } else if (!d.code) throw new RangeError("If era name is blank, it must be the anchor era");
+      })), s = s.filter(((d) => d.code)), s.forEach(((d) => {
+        const { reverseOf: u } = d;
+        if (u) {
+          const l = s.find(((m) => m.code === u));
+          if (l === void 0) throw new RangeError(`Invalid era data: unmatched reverseOf era: ${u}`);
+          d.reverseOf = l, d.anchorEpoch = l.anchorEpoch, d.isoEpoch = l.isoEpoch;
+        }
+        d.anchorEpoch.month === void 0 && (d.anchorEpoch.month = 1), d.anchorEpoch.day === void 0 && (d.anchorEpoch.day = 1);
+      })), s.sort(((d, u) => {
+        if (d.reverseOf) return 1;
+        if (u.reverseOf) return -1;
+        if (!d.isoEpoch || !u.isoEpoch) throw new RangeError("Invalid era data: missing ISO epoch");
+        return u.isoEpoch.year - d.isoEpoch.year;
+      }));
+      const h = s[s.length - 1].reverseOf;
+      if (h && h !== s[s.length - 2]) throw new RangeError("Invalid era data: invalid reverse-sign era");
+      return s.forEach(((d, u) => {
+        d.genericName = "era" + (s.length - 1 - u);
+      })), { eras: s, anchorEra: i || s[0] };
+    })(n);
+    this.anchorEra = o, this.eras = r;
+  }
+  inLeapYear(e) {
+    const { year: n } = this.estimateIsoDate({ month: 1, day: 1, year: e.year });
+    return ho(n);
+  }
+  monthsInYear() {
+    return 12;
+  }
+  minimumMonthLength(e) {
+    const { month: n } = e;
+    return n === 2 ? this.inLeapYear(e) ? 29 : 28 : [4, 6, 9, 11].indexOf(n) >= 0 ? 30 : 31;
+  }
+  maximumMonthLength(e) {
+    return this.minimumMonthLength(e);
+  }
+  maxLengthOfMonthCodeInAnyYear(e) {
+    return [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][jt(e) - 1];
+  }
+  completeEraYear(e) {
+    const n = (s, h, d) => {
+      const u = e[s];
+      if (u != null && u != h && !(d || []).includes(u)) {
+        const l = d?.[0];
+        throw new RangeError(`Input ${s} ${u} doesn't match calculated value ${l ? `${h} (also called ${l})` : h}`);
+      }
+    }, r = (s) => {
+      let h;
+      const d = { ...e, year: s }, u = this.eras.find(((l, m) => {
+        if (m === this.eras.length - 1) {
+          if (l.reverseOf) {
+            if (s > 0) throw new RangeError(`Signed year ${s} is invalid for era ${l.code}`);
+            return h = l.anchorEpoch.year - s, !0;
+          }
+          return h = s - l.anchorEpoch.year + (l.hasYearZero ? 0 : 1), !0;
+        }
+        return this.compareCalendarDates(d, l.anchorEpoch) >= 0 && (h = s - l.anchorEpoch.year + (l.hasYearZero ? 0 : 1), !0);
+      }));
+      if (!u) throw new RangeError(`Year ${s} was not matched by any era`);
+      return { eraYear: h, era: u.code, eraNames: u.names };
+    };
+    let { year: o, eraYear: a, era: i } = e;
+    if (o != null) {
+      const s = r(o);
+      ({ eraYear: a, era: i } = s), n("era", i, s?.eraNames), n("eraYear", a);
+    } else {
+      if (a == null) throw new RangeError("Either year or eraYear and era are required");
+      {
+        if (i === void 0) throw new RangeError("era and eraYear must be provided together");
+        const s = this.eras.find((({ code: h, names: d = [] }) => h === i || d.includes(i)));
+        if (!s) throw new RangeError(`Era ${i} (ISO year ${a}) was not matched by any era`);
+        o = s.reverseOf ? s.anchorEpoch.year - a : a + s.anchorEpoch.year - (s.hasYearZero ? 0 : 1), n("year", o), { eraYear: a, era: i } = r(o);
+      }
+    }
+    return { ...e, year: o, eraYear: a, era: i };
+  }
+  adjustCalendarDate(e, n, r = "constrain") {
+    let o = e;
+    const { month: a, monthCode: i } = o;
+    return a === void 0 && (o = { ...o, month: jt(i) }), this.validateCalendarDate(o), o = this.completeEraYear(o), super.adjustCalendarDate(o, n, r);
+  }
+  estimateIsoDate(e) {
+    const n = this.adjustCalendarDate(e), { year: r, month: o, day: a } = n, { anchorEra: i } = this;
+    return Tn(r + i.isoEpoch.year - (i.hasYearZero ? 0 : 1), o, a, "constrain");
+  }
+}
+class uo extends Ka {
+  constructor(e, n) {
+    super(e, n);
+  }
+  isoToCalendarDate(e) {
+    const { year: n, month: r, day: o } = e, a = Ke(r), i = n - this.anchorEra.isoEpoch.year + 1;
+    return this.completeEraYear({ year: i, month: r, monthCode: a, day: o });
+  }
+}
+const He = { inLeapYear(t) {
+  const { year: e } = t;
+  return (e + 1) % 4 == 0;
+}, monthsInYear: () => 13, minimumMonthLength(t) {
+  const { month: e } = t;
+  return e === 13 ? this.inLeapYear(t) ? 6 : 5 : 30;
+}, maximumMonthLength(t) {
+  return this.minimumMonthLength(t);
+}, maxLengthOfMonthCodeInAnyYear: (t) => t === "M13" ? 6 : 30 };
+class Zi extends Ga {
+  constructor(e, n) {
+    super(e, n), this.inLeapYear = He.inLeapYear, this.monthsInYear = He.monthsInYear, this.minimumMonthLength = He.minimumMonthLength, this.maximumMonthLength = He.maximumMonthLength, this.maxLengthOfMonthCodeInAnyYear = He.maxLengthOfMonthCodeInAnyYear;
+  }
+}
+class Va extends Ka {
+  constructor(e, n) {
+    super(e, n), this.inLeapYear = He.inLeapYear, this.monthsInYear = He.monthsInYear, this.minimumMonthLength = He.minimumMonthLength, this.maximumMonthLength = He.maximumMonthLength, this.maxLengthOfMonthCodeInAnyYear = He.maxLengthOfMonthCodeInAnyYear;
+  }
+}
+class Fi extends Zi {
+  constructor() {
+    super("ethioaa", { year: -5492, month: 7, day: 17 });
+  }
+}
+class Bi extends Va {
+  constructor() {
+    super("coptic", [{ code: "coptic", isoEpoch: { year: 284, month: 8, day: 29 } }, { code: "coptic-inverse", reverseOf: "coptic" }]);
+  }
+}
+class zi extends Va {
+  constructor() {
+    super("ethiopic", [{ code: "ethioaa", names: ["ethiopic-amete-alem", "mundi"], isoEpoch: { year: -5492, month: 7, day: 17 } }, { code: "ethiopic", names: ["incar"], isoEpoch: { year: 8, month: 8, day: 27 }, anchorEpoch: { year: 5501 } }]);
+  }
+}
+class Ai extends uo {
+  constructor() {
+    super("roc", [{ code: "roc", names: ["minguo"], isoEpoch: { year: 1912, month: 1, day: 1 } }, { code: "roc-inverse", names: ["before-roc"], reverseOf: "roc" }]);
+  }
+}
+class qi extends Ga {
+  constructor() {
+    super("buddhist", { year: -543, month: 1, day: 1 });
+  }
+}
+class Wi extends uo {
+  constructor() {
+    super("gregory", [{ code: "gregory", names: ["ad", "ce"], isoEpoch: { year: 1, month: 1, day: 1 } }, { code: "gregory-inverse", names: ["be", "bce"], reverseOf: "gregory" }]);
+  }
+  reviseIntlEra(e) {
+    let { era: n, eraYear: r } = e;
+    return n === "b" && (n = "gregory-inverse"), n === "a" && (n = "gregory"), { era: n, eraYear: r };
+  }
+  getFirstDayOfWeek() {
+    return 1;
+  }
+  getMinimalDaysInFirstWeek() {
+    return 1;
+  }
+}
+class Hi extends uo {
+  constructor() {
+    super("japanese", [{ code: "reiwa", isoEpoch: { year: 2019, month: 5, day: 1 }, anchorEpoch: { year: 2019, month: 5, day: 1 } }, { code: "heisei", isoEpoch: { year: 1989, month: 1, day: 8 }, anchorEpoch: { year: 1989, month: 1, day: 8 } }, { code: "showa", isoEpoch: { year: 1926, month: 12, day: 25 }, anchorEpoch: { year: 1926, month: 12, day: 25 } }, { code: "taisho", isoEpoch: { year: 1912, month: 7, day: 30 }, anchorEpoch: { year: 1912, month: 7, day: 30 } }, { code: "meiji", isoEpoch: { year: 1868, month: 9, day: 8 }, anchorEpoch: { year: 1868, month: 9, day: 8 } }, { code: "japanese", names: ["japanese", "gregory", "ad", "ce"], isoEpoch: { year: 1, month: 1, day: 1 } }, { code: "japanese-inverse", names: ["japanese-inverse", "gregory-inverse", "bc", "bce"], reverseOf: "japanese" }]), this.erasBeginMidYear = !0;
+  }
+  reviseIntlEra(e, n) {
+    const { era: r, eraYear: o } = e, { year: a } = n;
+    return this.eras.find(((i) => i.code === r)) ? { era: r, eraYear: o } : a < 1 ? { era: "japanese-inverse", eraYear: 1 - a } : { era: "japanese", eraYear: a };
+  }
+}
+class Xa extends Ut {
+  constructor() {
+    super(...arguments), this.calendarType = "lunisolar";
+  }
+  inLeapYear(e, n) {
+    const r = this.getMonthList(e.year, n);
+    return Object.entries(r).length === 13;
+  }
+  monthsInYear(e, n) {
+    return this.inLeapYear(e, n) ? 13 : 12;
+  }
+  minimumMonthLength() {
+    return 29;
+  }
+  maximumMonthLength() {
+    return 30;
+  }
+  maxLengthOfMonthCodeInAnyYear(e) {
+    return ["M01L", "M09L", "M10L", "M11L", "M12L"].includes(e) ? 29 : 30;
+  }
+  monthDaySearchStartYear(e, n) {
+    const r = { M01L: [1651, 1651], M02L: [1947, 1765], M03L: [1966, 1955], M04L: [1963, 1944], M05L: [1971, 1952], M06L: [1960, 1941], M07L: [1968, 1938], M08L: [1957, 1718], M09L: [1832, 1832], M10L: [1870, 1870], M11L: [1814, 1814], M12L: [1890, 1890] }[e] ?? [1972, 1972];
+    return n < 30 ? r[0] : r[1];
+  }
+  getMonthList(e, n) {
+    if (e === void 0) throw new TypeError("Missing year");
+    const r = JSON.stringify({ func: "getMonthList", calendarYear: e, id: this.id }), o = n.get(r);
+    if (o) return o;
+    const a = this.getFormatter(), i = (w, E) => {
+      const T = Ja({ isoYear: w, isoMonth: 2, isoDay: 1 }), D = new Date(T);
+      D.setUTCDate(E + 1);
+      const Y = a.formatToParts(D), O = Y.find(((Z) => Z.type === "month")).value, W = +Y.find(((Z) => Z.type === "day")).value, K = Y.find(((Z) => Z.type === "relatedYear"));
+      let H;
+      if (K === void 0) throw new RangeError(`Intl.DateTimeFormat.formatToParts lacks relatedYear in ${this.id} calendar. Try Node 14+ or modern browsers.`);
+      return H = +K.value, { calendarMonthString: O, calendarDay: W, calendarYearToVerify: H };
+    };
+    let s = 17, { calendarMonthString: h, calendarDay: d, calendarYearToVerify: u } = i(e, s);
+    h !== "1" && (s += 29, { calendarMonthString: h, calendarDay: d } = i(e, s)), s -= d - 5;
+    const l = {};
+    let m, f, p = 1, v = !1;
+    do
+      ({ calendarMonthString: h, calendarDay: d, calendarYearToVerify: u } = i(e, s)), m && (l[f].daysInMonth = m + 30 - d), u !== e ? v = !0 : (l[h] = { monthIndex: p++ }, s += 30), m = d, f = h;
+    while (!v);
+    return l[f].daysInMonth = m + 30 - d, n.set(r, l), l;
+  }
+  estimateIsoDate(e) {
+    const { year: n, month: r } = e;
+    return { year: n, month: r >= 12 ? 12 : r + 1, day: 1 };
+  }
+  adjustCalendarDate(e, n, r = "constrain", o = !1) {
+    let { year: a, month: i, monthExtra: s, day: h, monthCode: d } = e;
+    if (a === void 0) throw new TypeError("Missing property: year");
+    if (o) {
+      if (s && s !== "bis") throw new RangeError(`Unexpected leap month suffix: ${s}`);
+      const u = Ke(i, s !== void 0), l = `${i}${s || ""}`, m = this.getMonthList(a, n)[l];
+      if (m === void 0) throw new RangeError(`Unmatched month ${l} in Chinese year ${a}`);
+      return i = m.monthIndex, { year: a, month: i, day: h, monthCode: u };
+    }
+    if (this.validateCalendarDate(e), i === void 0) {
+      const u = this.getMonthList(a, n);
+      let l = d.replace(/^M|L$/g, ((f) => f === "L" ? "bis" : ""));
+      l[0] === "0" && (l = l.slice(1));
+      let m = u[l];
+      if (i = m && m.monthIndex, i === void 0 && d.endsWith("L") && d != "M13L" && r === "constrain") {
+        const f = +d.replace(/^M0?|L$/g, "");
+        m = u[f], m && (i = m.monthIndex, d = Ke(f));
+      }
+      if (i === void 0) throw new RangeError(`Unmatched month ${d} in Chinese year ${a}`);
+    } else if (d === void 0) {
+      const u = this.getMonthList(a, n), l = Object.entries(u), m = l.length;
+      r === "reject" ? (G(i, 1, m), G(h, 1, this.maximumMonthLength())) : (i = pe(i, 1, m), h = pe(h, 1, this.maximumMonthLength()));
+      const f = l.find(((p) => p[1].monthIndex === i));
+      if (f === void 0) throw new RangeError(`Invalid month ${i} in Chinese year ${a}`);
+      d = Ke(+f[0].replace("bis", ""), f[0].indexOf("bis") !== -1);
+    } else {
+      const u = this.getMonthList(a, n);
+      let l = d.replace(/^M|L$/g, ((f) => f === "L" ? "bis" : ""));
+      l[0] === "0" && (l = l.slice(1));
+      const m = u[l];
+      if (!m) throw new RangeError(`Unmatched monthCode ${d} in Chinese year ${a}`);
+      if (i !== m.monthIndex) throw new RangeError(`monthCode ${d} doesn't correspond to month ${i} in Chinese year ${a}`);
+    }
+    return { ...e, year: a, month: i, monthCode: d, day: h };
+  }
+}
+class _i extends Xa {
+  constructor() {
+    super(...arguments), this.id = "chinese";
+  }
+}
+class Ji extends Xa {
+  constructor() {
+    super(...arguments), this.id = "dangi";
+  }
+}
+class Gi {
+  constructor(e) {
+    this.helper = e;
+  }
+  extraFields(e) {
+    return this.helper.hasEra && e.includes("year") ? ["era", "eraYear"] : [];
+  }
+  resolveFields(e) {
+    if (this.helper.calendarType !== "lunisolar") {
+      const n = new J();
+      co(e, void 0, this.helper.monthsInYear({ year: e.year ?? 1972 }, n));
+    }
+  }
+  dateToISO(e, n) {
+    const r = new J(), o = this.helper.calendarToIsoDate(e, n, r);
+    return r.setObject(o), o;
+  }
+  monthDayToISOReferenceDate(e, n) {
+    const r = new J(), o = this.helper.monthDayFromFields(e, n, r);
+    return r.setObject(o), o;
+  }
+  fieldKeysToIgnore(e) {
+    const n = /* @__PURE__ */ new Set();
+    for (let r = 0; r < e.length; r++) {
+      const o = e[r];
+      switch (n.add(o), o) {
+        case "era":
+          n.add("eraYear"), n.add("year");
+          break;
+        case "eraYear":
+          n.add("era"), n.add("year");
+          break;
+        case "year":
+          n.add("era"), n.add("eraYear");
+          break;
+        case "month":
+          n.add("monthCode"), this.helper.erasBeginMidYear && (n.add("era"), n.add("eraYear"));
+          break;
+        case "monthCode":
+          n.add("month"), this.helper.erasBeginMidYear && (n.add("era"), n.add("eraYear"));
+          break;
+        case "day":
+          this.helper.erasBeginMidYear && (n.add("era"), n.add("eraYear"));
+      }
+    }
+    return Ha(n);
+  }
+  dateAdd(e, { years: n, months: r, weeks: o, days: a }, i) {
+    const s = J.getCacheForObject(e), h = this.helper.isoToCalendarDate(e, s), d = this.helper.addCalendar(h, { years: n, months: r, weeks: o, days: a }, i, s), u = this.helper.calendarToIsoDate(d, "constrain", s);
+    return J.getCacheForObject(u) || new J(s).setObject(u), u;
+  }
+  dateUntil(e, n, r) {
+    const o = J.getCacheForObject(e), a = J.getCacheForObject(n), i = this.helper.isoToCalendarDate(e, o), s = this.helper.isoToCalendarDate(n, a);
+    return this.helper.untilCalendar(i, s, r, o);
+  }
+  isoToDate(e, n) {
+    const r = J.getCacheForObject(e), o = this.helper.isoToCalendarDate(e, r);
+    if (n.dayOfWeek && (o.dayOfWeek = Gn.iso8601.isoToDate(e, { dayOfWeek: !0 }).dayOfWeek), n.dayOfYear) {
+      const a = this.helper.startOfCalendarYear(o), i = this.helper.calendarDaysUntil(a, o, r);
+      o.dayOfYear = i + 1;
+    }
+    if (n.weekOfYear && (o.weekOfYear = _a(this.helper.id, e)), o.daysInWeek = 7, n.daysInMonth && (o.daysInMonth = this.helper.daysInMonth(o, r)), n.daysInYear) {
+      const a = this.helper.startOfCalendarYear(o), i = this.helper.addCalendar(a, { years: 1 }, "constrain", r);
+      o.daysInYear = this.helper.calendarDaysUntil(a, i, r);
+    }
+    return n.monthsInYear && (o.monthsInYear = this.helper.monthsInYear(o, r)), n.inLeapYear && (o.inLeapYear = this.helper.inLeapYear(o, r)), o;
+  }
+  getFirstDayOfWeek() {
+    return this.helper.getFirstDayOfWeek();
+  }
+  getMinimalDaysInFirstWeek() {
+    return this.helper.getMinimalDaysInFirstWeek();
+  }
+}
+for (const t of [Ri, Ui, zi, Fi, Bi, _i, Ji, Ai, Pi, qi, Wi, Hi, Si, ki, Ni, ji, xi, Li]) {
+  const e = new t();
+  Gn[e.id] = new Gi(e);
+}
+Ur("calendarImpl", (function(t) {
+  return Gn[t];
+}));
+const xn = Intl.DateTimeFormat;
+function Ft(t, e) {
+  let n = c(t, e);
+  return typeof n == "function" && (n = new xn(c(t, da), n(c(t, Nr))), (function(r, o, a) {
+    const i = mr(r);
+    if (i === void 0) throw new TypeError("Missing slots for the given container");
+    if (i[o] === void 0) throw new TypeError(`tried to reset ${o} which was not set`);
+    i[o] = a;
+  })(t, e, n)), n;
+}
+function ln(t) {
+  return Ee(t, xt);
+}
+class Ln {
+  constructor(e = void 0, n = void 0) {
+    (function(r, o, a) {
+      const i = a !== void 0;
+      let s;
+      if (i) {
+        const l = ["localeMatcher", "calendar", "numberingSystem", "hour12", "hourCycle", "timeZone", "weekday", "era", "year", "month", "day", "dayPeriod", "hour", "minute", "second", "fractionalSecondDigits", "timeZoneName", "formatMatcher", "dateStyle", "timeStyle"];
+        s = (function(f) {
+          if (f == null) throw new TypeError(`Expected object not ${f}`);
+          return Object(f);
+        })(a);
+        const m = /* @__PURE__ */ Object.create(null);
+        for (let f = 0; f < l.length; f++) {
+          const p = l[f];
+          Object.prototype.hasOwnProperty.call(s, p) && (m[p] = s[p]);
+        }
+        s = m;
+      } else s = /* @__PURE__ */ Object.create(null);
+      const h = new xn(o, s), d = h.resolvedOptions();
+      if (lt(r), i) {
+        const l = Object.assign(/* @__PURE__ */ Object.create(null), d);
+        for (const m in l) Object.prototype.hasOwnProperty.call(s, m) || delete l[m];
+        l.hour12 = s.hour12, l.hourCycle = s.hourCycle, R(r, Nr, l);
+      } else R(r, Nr, s);
+      R(r, da, d.locale), R(r, xt, h), R(r, At, d.timeZone), R(r, fn, d.calendar), R(r, ra, os), R(r, oa, ns), R(r, aa, rs), R(r, ia, ts), R(r, sa, as), R(r, ca, is);
+      const u = i ? s.timeZone : void 0;
+      if (u === void 0) R(r, kr, d.timeZone);
+      else {
+        const l = pr(u);
+        if (l.startsWith("−")) throw new RangeError("Unicode minus (U+2212) is not supported in time zone offsets");
+        R(r, kr, ve(l));
+      }
+    })(this, e, n);
+  }
+  get format() {
+    g(this, ln);
+    const e = Vi.bind(this);
+    return Object.defineProperties(e, { length: { value: 1, enumerable: !1, writable: !1, configurable: !0 }, name: { value: "", enumerable: !1, writable: !1, configurable: !0 } }), e;
+  }
+  formatRange(e, n) {
+    return g(this, ln), Qi.call(this, e, n);
+  }
+  formatToParts(e, ...n) {
+    return g(this, ln), Xi.call(this, e, ...n);
+  }
+  formatRangeToParts(e, n) {
+    return g(this, ln), es.call(this, e, n);
+  }
+  resolvedOptions() {
+    return g(this, ln), Ki.call(this);
+  }
+}
+"formatToParts" in xn.prototype || delete Ln.prototype.formatToParts, "formatRangeToParts" in xn.prototype || delete Ln.prototype.formatRangeToParts;
+const Pe = function(t = void 0, e = void 0) {
+  return new Ln(t, e);
+};
+function Ki() {
+  const t = c(this, xt).resolvedOptions();
+  return t.timeZone = c(this, kr), t;
+}
+function Vi(t, ...e) {
+  let n, r, o = tn(t, this);
+  return o.formatter ? (n = o.formatter, r = [Be(o.epochNs, "floor")]) : (n = c(this, xt), r = [t, ...e]), n.format(...r);
+}
+function Xi(t, ...e) {
+  let n, r, o = tn(t, this);
+  return o.formatter ? (n = o.formatter, r = [Be(o.epochNs, "floor")]) : (n = c(this, xt), r = [t, ...e]), n.formatToParts(...r);
+}
+function Qi(t, e) {
+  if (t === void 0 || e === void 0) throw new TypeError("Intl.DateTimeFormat.formatRange requires two values");
+  const n = lr(t), r = lr(e);
+  let o, a = [n, r];
+  if (ht(n) !== ht(r)) throw new TypeError("Intl.DateTimeFormat.formatRange accepts two values of the same type");
+  if (ht(n)) {
+    if (!Qa(n, r)) throw new TypeError("Intl.DateTimeFormat.formatRange accepts two values of the same type");
+    const { epochNs: i, formatter: s } = tn(n, this), { epochNs: h, formatter: d } = tn(r, this);
+    s && (o = s, a = [Be(i, "floor"), Be(h, "floor")]);
+  }
+  return o || (o = c(this, xt)), o.formatRange(...a);
+}
+function es(t, e) {
+  if (t === void 0 || e === void 0) throw new TypeError("Intl.DateTimeFormat.formatRange requires two values");
+  const n = lr(t), r = lr(e);
+  let o, a = [n, r];
+  if (ht(n) !== ht(r)) throw new TypeError("Intl.DateTimeFormat.formatRangeToParts accepts two values of the same type");
+  if (ht(n)) {
+    if (!Qa(n, r)) throw new TypeError("Intl.DateTimeFormat.formatRangeToParts accepts two values of the same type");
+    const { epochNs: i, formatter: s } = tn(n, this), { epochNs: h, formatter: d } = tn(r, this);
+    s && (o = s, a = [Be(i, "floor"), Be(h, "floor")]);
+  }
+  return o || (o = c(this, xt)), o.formatRangeToParts(...a);
+}
+function Kn(t = {}, e = {}) {
+  const n = Object.assign({}, t), r = ["year", "month", "day", "hour", "minute", "second", "weekday", "dayPeriod", "timeZoneName", "dateStyle", "timeStyle"];
+  for (let o = 0; o < r.length; o++) {
+    const a = r[o];
+    n[a] = a in e ? e[a] : n[a], n[a] !== !1 && n[a] !== void 0 || delete n[a];
+  }
+  return n;
+}
+function ts(t) {
+  const e = Kn(t, { year: !1, month: !1, day: !1, weekday: !1, timeZoneName: !1, dateStyle: !1 });
+  if (e.timeStyle !== "long" && e.timeStyle !== "full" || (delete e.timeStyle, Object.assign(e, { hour: "numeric", minute: "2-digit", second: "2-digit" })), !Cr(e)) {
+    if (Vn(t)) throw new TypeError(`cannot format Temporal.PlainTime with options [${Object.keys(t)}]`);
+    Object.assign(e, { hour: "numeric", minute: "numeric", second: "numeric" });
+  }
+  return e;
+}
+function ns(t) {
+  const e = { short: { year: "2-digit", month: "numeric" }, medium: { year: "numeric", month: "short" }, long: { year: "numeric", month: "long" }, full: { year: "numeric", month: "long" } }, n = Kn(t, { day: !1, hour: !1, minute: !1, second: !1, weekday: !1, dayPeriod: !1, timeZoneName: !1, timeStyle: !1 });
+  if ("dateStyle" in n && n.dateStyle) {
+    const r = n.dateStyle;
+    delete n.dateStyle, Object.assign(n, e[r]);
+  }
+  if (!("year" in n || "month" in n || "era" in n)) {
+    if (Vn(t)) throw new TypeError(`cannot format PlainYearMonth with options [${Object.keys(t)}]`);
+    Object.assign(n, { year: "numeric", month: "numeric" });
+  }
+  return n;
+}
+function rs(t) {
+  const e = { short: { month: "numeric", day: "numeric" }, medium: { month: "short", day: "numeric" }, long: { month: "long", day: "numeric" }, full: { month: "long", day: "numeric" } }, n = Kn(t, { year: !1, hour: !1, minute: !1, second: !1, weekday: !1, dayPeriod: !1, timeZoneName: !1, timeStyle: !1 });
+  if ("dateStyle" in n && n.dateStyle) {
+    const r = n.dateStyle;
+    delete n.dateStyle, Object.assign(n, e[r]);
+  }
+  if (!("month" in n) && !("day" in n)) {
+    if (Vn(t)) throw new TypeError(`cannot format PlainMonthDay with options [${Object.keys(t)}]`);
+    Object.assign(n, { month: "numeric", day: "numeric" });
+  }
+  return n;
+}
+function os(t) {
+  const e = Kn(t, { hour: !1, minute: !1, second: !1, dayPeriod: !1, timeZoneName: !1, timeStyle: !1 });
+  if (!Ir(e)) {
+    if (Vn(t)) throw new TypeError(`cannot format PlainDate with options [${Object.keys(t)}]`);
+    Object.assign(e, { year: "numeric", month: "numeric", day: "numeric" });
+  }
+  return e;
+}
+function as(t) {
+  const e = Kn(t, { timeZoneName: !1 });
+  if ((e.timeStyle === "long" || e.timeStyle === "full") && (delete e.timeStyle, Object.assign(e, { hour: "numeric", minute: "2-digit", second: "2-digit" }), e.dateStyle) && (Object.assign(e, { short: { year: "numeric", month: "numeric", day: "numeric" }, medium: { year: "numeric", month: "short", day: "numeric" }, long: { year: "numeric", month: "long", day: "numeric" }, full: { year: "numeric", month: "long", day: "numeric", weekday: "long" } }[e.dateStyle]), delete e.dateStyle), !Cr(e) && !Ir(e)) {
+    if (Vn(t)) throw new TypeError(`cannot format PlainDateTime with options [${Object.keys(t)}]`);
+    Object.assign(e, { year: "numeric", month: "numeric", day: "numeric", hour: "numeric", minute: "numeric", second: "numeric" });
+  }
+  return e;
+}
+function is(t) {
+  let e = t;
+  return Cr(e) || Ir(e) || (e = Object.assign({}, e, { year: "numeric", month: "numeric", day: "numeric", hour: "numeric", minute: "numeric", second: "numeric" })), e;
+}
+function Ir(t) {
+  return "year" in t || "month" in t || "day" in t || "weekday" in t || "dateStyle" in t || "era" in t;
+}
+function Cr(t) {
+  return "hour" in t || "minute" in t || "second" in t || "timeStyle" in t || "dayPeriod" in t || "fractionalSecondDigits" in t;
+}
+function Vn(t) {
+  return Ir(t) || Cr(t) || "dateStyle" in t || "timeStyle" in t || "timeZoneName" in t;
+}
+function ht(t) {
+  return B(t) || q(t) || L(t) || S(t) || Q(t) || Se(t) || X(t);
+}
+function lr(t) {
+  return ht(t) ? t : gr(t);
+}
+function Qa(t, e) {
+  return !(!ht(t) || !ht(e) || q(t) && !q(e) || B(t) && !B(e) || L(t) && !L(e) || S(t) && !S(e) || Q(t) && !Q(e) || Se(t) && !Se(e) || X(t) && !X(e));
+}
+function tn(t, e) {
+  if (q(t)) {
+    const n = { isoDate: { year: 1970, month: 1, day: 1 }, time: c(t, z) };
+    return { epochNs: oe(c(e, At), n, "compatible"), formatter: Ft(e, ia) };
+  }
+  if (Q(t)) {
+    const n = c(t, b), r = c(e, fn);
+    if (n !== r) throw new RangeError(`cannot format PlainYearMonth with calendar ${n} in locale with calendar ${r}`);
+    const o = j(c(t, C), { deltaDays: 0, hour: 12, minute: 0, second: 0, millisecond: 0, microsecond: 0, nanosecond: 0 });
+    return { epochNs: oe(c(e, At), o, "compatible"), formatter: Ft(e, oa) };
+  }
+  if (Se(t)) {
+    const n = c(t, b), r = c(e, fn);
+    if (n !== r) throw new RangeError(`cannot format PlainMonthDay with calendar ${n} in locale with calendar ${r}`);
+    const o = j(c(t, C), { deltaDays: 0, hour: 12, minute: 0, second: 0, millisecond: 0, microsecond: 0, nanosecond: 0 });
+    return { epochNs: oe(c(e, At), o, "compatible"), formatter: Ft(e, aa) };
+  }
+  if (B(t)) {
+    const n = c(t, b), r = c(e, fn);
+    if (n !== "iso8601" && n !== r) throw new RangeError(`cannot format PlainDate with calendar ${n} in locale with calendar ${r}`);
+    const o = j(c(t, C), { deltaDays: 0, hour: 12, minute: 0, second: 0, millisecond: 0, microsecond: 0, nanosecond: 0 });
+    return { epochNs: oe(c(e, At), o, "compatible"), formatter: Ft(e, ra) };
+  }
+  if (L(t)) {
+    const n = c(t, b), r = c(e, fn);
+    if (n !== "iso8601" && n !== r) throw new RangeError(`cannot format PlainDateTime with calendar ${n} in locale with calendar ${r}`);
+    const o = c(t, P);
+    return { epochNs: oe(c(e, At), o, "compatible"), formatter: Ft(e, sa) };
+  }
+  if (S(t)) throw new TypeError("Temporal.ZonedDateTime not supported in DateTimeFormat methods. Use toLocaleString() instead.");
+  return X(t) ? { epochNs: c(t, I), formatter: Ft(e, ca) } : {};
+}
+function ei(t) {
+  const e = /* @__PURE__ */ Object.create(null);
+  return e.years = c(t, de), e.months = c(t, he), e.weeks = c(t, Te), e.days = c(t, ue), e.hours = c(t, le), e.minutes = c(t, me), e.seconds = c(t, fe), e.milliseconds = c(t, ye), e.microseconds = c(t, ge), e.nanoseconds = c(t, Ie), e;
+}
+Ln.prototype.constructor = Pe, Object.defineProperty(Pe, "prototype", { value: Ln.prototype, writable: !1, enumerable: !1, configurable: !1 }), Pe.supportedLocalesOf = xn.supportedLocalesOf, mt(Pe, "Intl.DateTimeFormat");
+const { format: ss, formatToParts: cs } = Intl.DurationFormat?.prototype ?? /* @__PURE__ */ Object.create(null);
+function ti(t) {
+  Intl.DurationFormat.prototype.resolvedOptions.call(this);
+  const e = ei(Ze(t));
+  return ss.call(this, e);
+}
+Intl.DurationFormat?.prototype && (Intl.DurationFormat.prototype.format = ti, Intl.DurationFormat.prototype.formatToParts = function(t) {
+  Intl.DurationFormat.prototype.resolvedOptions.call(this);
+  const e = ei(Ze(t));
+  return cs.call(this, e);
+});
+class lo {
+  constructor(e) {
+    if (arguments.length < 1) throw new TypeError("missing argument: epochNanoseconds is required");
+    Oa(this, ur(e));
+  }
+  get epochMilliseconds() {
+    return g(this, X), Be(c(this, I), "floor");
+  }
+  get epochNanoseconds() {
+    return g(this, X), qa(y.BigInt(c(this, I)));
+  }
+  add(e) {
+    return g(this, X), qo("add", this, e);
+  }
+  subtract(e) {
+    return g(this, X), qo("subtract", this, e);
+  }
+  until(e, n = void 0) {
+    return g(this, X), Uo("until", this, e, n);
+  }
+  since(e, n = void 0) {
+    return g(this, X), Uo("since", this, e, n);
+  }
+  round(e) {
+    if (g(this, X), e === void 0) throw new TypeError("options parameter is required");
+    const n = typeof e == "string" ? Nt("smallestUnit", e) : M(e), r = on(n), o = Ae(n, "halfExpand"), a = $e(n, "smallestUnit", "time", ut);
+    return an(r, { hour: 24, minute: 1440, second: 86400, millisecond: 864e5, microsecond: 864e8, nanosecond: 864e11 }[a], !0), _e(_r(c(this, I), r, a, o));
+  }
+  equals(e) {
+    g(this, X);
+    const n = pn(e), r = c(this, I), o = c(n, I);
+    return y.equal(y.BigInt(r), y.BigInt(o));
+  }
+  toString(e = void 0) {
+    g(this, X);
+    const n = M(e), r = Bn(n), o = Ae(n, "trunc"), a = $e(n, "smallestUnit", "time", void 0);
+    if (a === "hour") throw new RangeError('smallestUnit must be a time unit other than "hour"');
+    let i = n.timeZone;
+    i !== void 0 && (i = ve(i));
+    const { precision: s, unit: h, increment: d } = zn(a, r);
+    return Oo(_e(_r(c(this, I), d, h, o)), i, s);
+  }
+  toJSON() {
+    return g(this, X), Oo(this, void 0, "auto");
+  }
+  toLocaleString(e = void 0, n = void 0) {
+    return g(this, X), new Pe(e, n).format(this);
+  }
+  valueOf() {
+    Tt("Instant");
+  }
+  toZonedDateTimeISO(e) {
+    g(this, X);
+    const n = ve(e);
+    return ne(c(this, I), n, "iso8601");
+  }
+  static fromEpochMilliseconds(e) {
+    return _e(Ge(gr(e)));
+  }
+  static fromEpochNanoseconds(e) {
+    return _e(ur(e));
+  }
+  static from(e) {
+    return pn(e);
+  }
+  static compare(e, n) {
+    const r = pn(e), o = pn(n), a = c(r, I), i = c(o, I);
+    return y.lessThan(a, i) ? -1 : y.greaterThan(a, i) ? 1 : 0;
+  }
+}
+mt(lo, "Temporal.Instant");
+class mo {
+  constructor(e, n, r, o = "iso8601") {
+    const a = $(e), i = $(n), s = $(r), h = Me(o === void 0 ? "iso8601" : _(o));
+    Rt(a, i, s), Da(this, { year: a, month: i, day: s }, h);
+  }
+  get calendarId() {
+    return g(this, B), c(this, b);
+  }
+  get era() {
+    return ie(this, "era");
+  }
+  get eraYear() {
+    return ie(this, "eraYear");
+  }
+  get year() {
+    return ie(this, "year");
+  }
+  get month() {
+    return ie(this, "month");
+  }
+  get monthCode() {
+    return ie(this, "monthCode");
+  }
+  get day() {
+    return ie(this, "day");
+  }
+  get dayOfWeek() {
+    return ie(this, "dayOfWeek");
+  }
+  get dayOfYear() {
+    return ie(this, "dayOfYear");
+  }
+  get weekOfYear() {
+    return ie(this, "weekOfYear")?.week;
+  }
+  get yearOfWeek() {
+    return ie(this, "weekOfYear")?.year;
+  }
+  get daysInWeek() {
+    return ie(this, "daysInWeek");
+  }
+  get daysInMonth() {
+    return ie(this, "daysInMonth");
+  }
+  get daysInYear() {
+    return ie(this, "daysInYear");
+  }
+  get monthsInYear() {
+    return ie(this, "monthsInYear");
+  }
+  get inLeapYear() {
+    return ie(this, "inLeapYear");
+  }
+  with(e, n = void 0) {
+    if (g(this, B), !A(e)) throw new TypeError("invalid argument");
+    rn(e);
+    const r = c(this, b);
+    let o = be(r, c(this, C));
+    return o = Yt(r, o, xe(r, e, ["year", "month", "monthCode", "day"], [], "partial")), we(Mt(r, o, N(M(n))), r);
+  }
+  withCalendar(e) {
+    g(this, B);
+    const n = Hn(e);
+    return we(c(this, C), n);
+  }
+  add(e, n = void 0) {
+    return g(this, B), Wo("add", this, e, n);
+  }
+  subtract(e, n = void 0) {
+    return g(this, B), Wo("subtract", this, e, n);
+  }
+  until(e, n = void 0) {
+    return g(this, B), Po("until", this, e, n);
+  }
+  since(e, n = void 0) {
+    return g(this, B), Po("since", this, e, n);
+  }
+  equals(e) {
+    g(this, B);
+    const n = yn(e);
+    return Qe(c(this, C), c(n, C)) === 0 && Ve(c(this, b), c(n, b));
+  }
+  toString(e = void 0) {
+    return g(this, B), Yo(this, Fn(M(e)));
+  }
+  toJSON() {
+    return g(this, B), Yo(this);
+  }
+  toLocaleString(e = void 0, n = void 0) {
+    return g(this, B), new Pe(e, n).format(this);
+  }
+  valueOf() {
+    Tt("PlainDate");
+  }
+  toPlainDateTime(e = void 0) {
+    g(this, B);
+    const n = Ma(e);
+    return Le(j(c(this, C), n), c(this, b));
+  }
+  toZonedDateTime(e) {
+    let n, r;
+    if (g(this, B), A(e)) {
+      const i = e.timeZone;
+      i === void 0 ? n = ve(e) : (n = ve(i), r = e.plainTime);
+    } else n = ve(e);
+    const o = c(this, C);
+    let a;
+    return r === void 0 ? a = yt(n, o) : (r = pt(r), a = oe(n, j(o, c(r, z)), "compatible")), ne(a, n, c(this, b));
+  }
+  toPlainYearMonth() {
+    g(this, B);
+    const e = c(this, b);
+    return _t(Rn(e, be(e, c(this, C)), "constrain"), e);
+  }
+  toPlainMonthDay() {
+    g(this, B);
+    const e = c(this, b);
+    return Ht(ir(e, be(e, c(this, C)), "constrain"), e);
+  }
+  static from(e, n = void 0) {
+    return yn(e, n);
+  }
+  static compare(e, n) {
+    const r = yn(e), o = yn(n);
+    return Qe(c(r, C), c(o, C));
+  }
+}
+function ie(t, e) {
+  g(t, B);
+  const n = c(t, C);
+  return An(t).isoToDate(n, { [e]: !0 })[e];
+}
+mt(mo, "Temporal.PlainDate");
+class fo {
+  constructor(e, n, r, o = 0, a = 0, i = 0, s = 0, h = 0, d = 0, u = "iso8601") {
+    const l = $(e), m = $(n), f = $(r), p = o === void 0 ? 0 : $(o), v = a === void 0 ? 0 : $(a), w = i === void 0 ? 0 : $(i), E = s === void 0 ? 0 : $(s), T = h === void 0 ? 0 : $(h), D = d === void 0 ? 0 : $(d), Y = Me(u === void 0 ? "iso8601" : _(u));
+    oo(l, m, f, p, v, w, E, T, D), Ta(this, { isoDate: { year: l, month: m, day: f }, time: { hour: p, minute: v, second: w, millisecond: E, microsecond: T, nanosecond: D } }, Y);
+  }
+  get calendarId() {
+    return g(this, L), c(this, b);
+  }
+  get year() {
+    return se(this, "year");
+  }
+  get month() {
+    return se(this, "month");
+  }
+  get monthCode() {
+    return se(this, "monthCode");
+  }
+  get day() {
+    return se(this, "day");
+  }
+  get hour() {
+    return Bt(this, "hour");
+  }
+  get minute() {
+    return Bt(this, "minute");
+  }
+  get second() {
+    return Bt(this, "second");
+  }
+  get millisecond() {
+    return Bt(this, "millisecond");
+  }
+  get microsecond() {
+    return Bt(this, "microsecond");
+  }
+  get nanosecond() {
+    return Bt(this, "nanosecond");
+  }
+  get era() {
+    return se(this, "era");
+  }
+  get eraYear() {
+    return se(this, "eraYear");
+  }
+  get dayOfWeek() {
+    return se(this, "dayOfWeek");
+  }
+  get dayOfYear() {
+    return se(this, "dayOfYear");
+  }
+  get weekOfYear() {
+    return se(this, "weekOfYear")?.week;
+  }
+  get yearOfWeek() {
+    return se(this, "weekOfYear")?.year;
+  }
+  get daysInWeek() {
+    return se(this, "daysInWeek");
+  }
+  get daysInYear() {
+    return se(this, "daysInYear");
+  }
+  get daysInMonth() {
+    return se(this, "daysInMonth");
+  }
+  get monthsInYear() {
+    return se(this, "monthsInYear");
+  }
+  get inLeapYear() {
+    return se(this, "inLeapYear");
+  }
+  with(e, n = void 0) {
+    if (g(this, L), !A(e)) throw new TypeError("invalid argument");
+    rn(e);
+    const r = c(this, b), o = c(this, P);
+    let a = { ...be(r, o.isoDate), ...o.time };
+    return a = Yt(r, a, xe(r, e, ["year", "month", "monthCode", "day"], ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"], "partial")), Le(qn(r, a, N(M(n))), r);
+  }
+  withPlainTime(e = void 0) {
+    g(this, L);
+    const n = Ma(e);
+    return Le(j(c(this, P).isoDate, n), c(this, b));
+  }
+  withCalendar(e) {
+    g(this, L);
+    const n = Hn(e);
+    return Le(c(this, P), n);
+  }
+  add(e, n = void 0) {
+    return g(this, L), Ho("add", this, e, n);
+  }
+  subtract(e, n = void 0) {
+    return g(this, L), Ho("subtract", this, e, n);
+  }
+  until(e, n = void 0) {
+    return g(this, L), Zo("until", this, e, n);
+  }
+  since(e, n = void 0) {
+    return g(this, L), Zo("since", this, e, n);
+  }
+  round(e) {
+    if (g(this, L), e === void 0) throw new TypeError("options parameter is required");
+    const n = typeof e == "string" ? Nt("smallestUnit", e) : M(e), r = on(n), o = Ae(n, "halfExpand"), a = $e(n, "smallestUnit", "time", ut, ["day"]), i = { day: 1, hour: 24, minute: 60, second: 60, millisecond: 1e3, microsecond: 1e3, nanosecond: 1e3 }[a];
+    an(r, i, i === 1);
+    const s = c(this, P);
+    return Le(r === 1 && a === "nanosecond" ? s : Jr(s, r, a, o), c(this, b));
+  }
+  equals(e) {
+    g(this, L);
+    const n = gn(e);
+    return en(c(this, P), c(n, P)) === 0 && Ve(c(this, b), c(n, b));
+  }
+  toString(e = void 0) {
+    g(this, L);
+    const n = M(e), r = Fn(n), o = Bn(n), a = Ae(n, "trunc"), i = $e(n, "smallestUnit", "time", void 0);
+    if (i === "hour") throw new RangeError('smallestUnit must be a time unit other than "hour"');
+    const { precision: s, unit: h, increment: d } = zn(i, o), u = Jr(c(this, P), d, h, a);
+    return St(u), kn(u, c(this, b), s, r);
+  }
+  toJSON() {
+    return g(this, L), kn(c(this, P), c(this, b), "auto");
+  }
+  toLocaleString(e = void 0, n = void 0) {
+    return g(this, L), new Pe(e, n).format(this);
+  }
+  valueOf() {
+    Tt("PlainDateTime");
+  }
+  toZonedDateTime(e, n = void 0) {
+    g(this, L);
+    const r = ve(e), o = In(M(n));
+    return ne(oe(r, c(this, P), o), r, c(this, b));
+  }
+  toPlainDate() {
+    return g(this, L), we(c(this, P).isoDate, c(this, b));
+  }
+  toPlainTime() {
+    return g(this, L), at(c(this, P).time);
+  }
+  static from(e, n = void 0) {
+    return gn(e, n);
+  }
+  static compare(e, n) {
+    const r = gn(e), o = gn(n);
+    return en(c(r, P), c(o, P));
+  }
+}
+function se(t, e) {
+  g(t, L);
+  const n = c(t, P).isoDate;
+  return An(t).isoToDate(n, { [e]: !0 })[e];
+}
+function Bt(t, e) {
+  return g(t, L), c(t, P).time[e];
+}
+mt(fo, "Temporal.PlainDateTime");
+class nn {
+  constructor(e = 0, n = 0, r = 0, o = 0, a = 0, i = 0, s = 0, h = 0, d = 0, u = 0) {
+    const l = e === void 0 ? 0 : ze(e), m = n === void 0 ? 0 : ze(n), f = r === void 0 ? 0 : ze(r), p = o === void 0 ? 0 : ze(o), v = a === void 0 ? 0 : ze(a), w = i === void 0 ? 0 : ze(i), E = s === void 0 ? 0 : ze(s), T = h === void 0 ? 0 : ze(h), D = d === void 0 ? 0 : ze(d), Y = u === void 0 ? 0 : ze(u);
+    Dr(l, m, f, p, v, w, E, T, D, Y), lt(this), R(this, de, l), R(this, he, m), R(this, Te, f), R(this, ue, p), R(this, le, v), R(this, me, w), R(this, fe, E), R(this, ye, T), R(this, ge, D), R(this, Ie, Y);
+  }
+  get years() {
+    return g(this, F), c(this, de);
+  }
+  get months() {
+    return g(this, F), c(this, he);
+  }
+  get weeks() {
+    return g(this, F), c(this, Te);
+  }
+  get days() {
+    return g(this, F), c(this, ue);
+  }
+  get hours() {
+    return g(this, F), c(this, le);
+  }
+  get minutes() {
+    return g(this, F), c(this, me);
+  }
+  get seconds() {
+    return g(this, F), c(this, fe);
+  }
+  get milliseconds() {
+    return g(this, F), c(this, ye);
+  }
+  get microseconds() {
+    return g(this, F), c(this, ge);
+  }
+  get nanoseconds() {
+    return g(this, F), c(this, Ie);
+  }
+  get sign() {
+    return g(this, F), dr(this);
+  }
+  get blank() {
+    return g(this, F), dr(this) === 0;
+  }
+  with(e) {
+    g(this, F);
+    const n = Ea(e), { years: r = c(this, de), months: o = c(this, he), weeks: a = c(this, Te), days: i = c(this, ue), hours: s = c(this, le), minutes: h = c(this, me), seconds: d = c(this, fe), milliseconds: u = c(this, ye), microseconds: l = c(this, ge), nanoseconds: m = c(this, Ie) } = n;
+    return new nn(r, o, a, i, s, h, d, u, l, m);
+  }
+  negated() {
+    return g(this, F), Ye(this);
+  }
+  abs() {
+    return g(this, F), new nn(Math.abs(c(this, de)), Math.abs(c(this, he)), Math.abs(c(this, Te)), Math.abs(c(this, ue)), Math.abs(c(this, le)), Math.abs(c(this, me)), Math.abs(c(this, fe)), Math.abs(c(this, ye)), Math.abs(c(this, ge)), Math.abs(c(this, Ie)));
+  }
+  add(e) {
+    return g(this, F), Ao("add", this, e);
+  }
+  subtract(e) {
+    return g(this, F), Ao("subtract", this, e);
+  }
+  round(e) {
+    if (g(this, F), e === void 0) throw new TypeError("options parameter is required");
+    const n = rt(this), r = typeof e == "string" ? Nt("smallestUnit", e) : M(e);
+    let o = $e(r, "largestUnit", "datetime", void 0, ["auto"]), { plainRelativeTo: a, zonedRelativeTo: i } = Yr(r);
+    const s = on(r), h = Ae(r, "halfExpand");
+    let d = $e(r, "smallestUnit", "datetime", void 0), u = !0;
+    d || (u = !1, d = "nanosecond");
+    const l = st(n, d);
+    let m = !0;
+    if (o || (m = !1, o = l), o === "auto" && (o = l), !u && !m) throw new RangeError("at least one of smallestUnit or largestUnit is required");
+    if (st(o, d) !== o) throw new RangeError(`largestUnit ${o} cannot be smaller than smallestUnit ${d}`);
+    const f = { hour: 24, minute: 60, second: 60, millisecond: 1e3, microsecond: 1e3, nanosecond: 1e3 }[d];
+    if (f !== void 0 && an(s, f, !1), s > 1 && ot(d) === "date" && o !== d) throw new RangeError("For calendar units with roundingIncrement > 1, use largestUnit = smallestUnit");
+    if (i) {
+      let v = qt(this);
+      const w = c(i, x), E = c(i, b), T = c(i, I);
+      return v = Aa(T, bn(T, w, E, v), w, E, o, s, d, h), ot(o) === "date" && (o = "hour"), Ue(v, o);
+    }
+    if (a) {
+      let v = Je(this);
+      const w = Qt({ hour: 0, minute: 0, second: 0, millisecond: 0, microsecond: 0, nanosecond: 0 }, v.time), E = c(a, C), T = c(a, b), D = Ne(T, E, re(v.date, w.deltaDays), "constrain");
+      return v = za(j(E, { deltaDays: 0, hour: 0, minute: 0, second: 0, millisecond: 0, microsecond: 0, nanosecond: 0 }), j(D, w), T, o, s, d, h), Ue(v, o);
+    }
+    if (We(n)) throw new RangeError(`a starting point is required for ${n}s balancing`);
+    if (We(o)) throw new RangeError(`a starting point is required for ${o}s balancing`);
+    let p = Je(this);
+    if (d === "day") {
+      const { quotient: v, remainder: w } = p.time.divmod(rr);
+      let E = p.date.days + v + Cn(w, "day");
+      E = wt(E, s, h), p = ct({ years: 0, months: 0, weeks: 0, days: E }, k.ZERO);
+    } else p = ct({ years: 0, months: 0, weeks: 0, days: 0 }, hr(p.time, s, d, h));
+    return Ue(p, o);
+  }
+  total(e) {
+    if (g(this, F), e === void 0) throw new TypeError("options argument is required");
+    const n = typeof e == "string" ? Nt("unit", e) : M(e);
+    let { plainRelativeTo: r, zonedRelativeTo: o } = Yr(n);
+    const a = $e(n, "unit", "datetime", ut);
+    if (o) {
+      const s = qt(this), h = c(o, x), d = c(o, b), u = c(o, I);
+      return (function(l, m, f, p, v) {
+        return ot(v) === "time" ? Cn(k.fromEpochNsDiff(m, l), v) : Lo(Fa(l, m, f, p, v), m, Fe(f, l), f, p, v);
+      })(u, bn(u, h, d, s), h, d, a);
+    }
+    if (r) {
+      const s = Je(this);
+      let h = Qt({ hour: 0, minute: 0, second: 0, millisecond: 0, microsecond: 0, nanosecond: 0 }, s.time);
+      const d = c(r, C), u = c(r, b), l = Ne(u, d, re(s.date, h.deltaDays), "constrain");
+      return (function(m, f, p, v) {
+        if (en(m, f) == 0) return 0;
+        St(m), St(f);
+        const w = Za(m, f, p, v);
+        return v === "nanosecond" ? y.toNumber(w.time.totalNs) : Lo(w, ee(f), m, null, p, v);
+      })(j(d, { deltaDays: 0, hour: 0, minute: 0, second: 0, millisecond: 0, microsecond: 0, nanosecond: 0 }), j(l, h), u, a);
+    }
+    const i = rt(this);
+    if (We(i)) throw new RangeError(`a starting point is required for ${i}s total`);
+    if (We(a)) throw new RangeError(`a starting point is required for ${a}s total`);
+    return Cn(Je(this).time, a);
+  }
+  toString(e = void 0) {
+    g(this, F);
+    const n = M(e), r = Bn(n), o = Ae(n, "trunc"), a = $e(n, "smallestUnit", "time", void 0);
+    if (a === "hour" || a === "minute") throw new RangeError('smallestUnit must be a time unit other than "hours" or "minutes"');
+    const { precision: i, unit: s, increment: h } = zn(a, r);
+    if (s === "nanosecond" && h === 1) return Qn(this, i);
+    const d = rt(this);
+    let u = qt(this);
+    const l = hr(u.time, h, s, o);
+    return u = ct(u.date, l), Qn(Ue(u, st(d, "second")), i);
+  }
+  toJSON() {
+    return g(this, F), Qn(this, "auto");
+  }
+  toLocaleString(e = void 0, n = void 0) {
+    if (g(this, F), typeof Intl.DurationFormat == "function") {
+      const r = new Intl.DurationFormat(e, n);
+      return ti.call(r, this);
+    }
+    return console.warn("Temporal.Duration.prototype.toLocaleString() requires Intl.DurationFormat."), Qn(this, "auto");
+  }
+  valueOf() {
+    Tt("Duration");
+  }
+  static from(e) {
+    return Ze(e);
+  }
+  static compare(e, n, r = void 0) {
+    const o = Ze(e), a = Ze(n), i = M(r), { plainRelativeTo: s, zonedRelativeTo: h } = Yr(i);
+    if (c(o, de) === c(a, de) && c(o, he) === c(a, he) && c(o, Te) === c(a, Te) && c(o, ue) === c(a, ue) && c(o, le) === c(a, le) && c(o, me) === c(a, me) && c(o, fe) === c(a, fe) && c(o, ye) === c(a, ye) && c(o, ge) === c(a, ge) && c(o, Ie) === c(a, Ie)) return 0;
+    const d = rt(o), u = rt(a), l = qt(o), m = qt(a);
+    if (h && (ot(d) === "date" || ot(u) === "date")) {
+      const E = c(h, x), T = c(h, b), D = c(h, I), Y = bn(D, E, T, l), O = bn(D, E, T, m);
+      return Ce(y.toNumber(y.subtract(Y, O)));
+    }
+    let f = l.date.days, p = m.date.days;
+    if (We(d) || We(u)) {
+      if (!s) throw new RangeError("A starting point is required for years, months, or weeks comparison");
+      f = xo(l.date, s), p = xo(m.date, s);
+    }
+    const v = l.time.add24HourDays(f), w = m.time.add24HourDays(p);
+    return v.cmp(w);
+  }
+}
+mt(nn, "Temporal.Duration");
+class yo {
+  constructor(e, n, r = "iso8601", o = 1972) {
+    const a = $(e), i = $(n), s = Me(r === void 0 ? "iso8601" : _(r)), h = $(o);
+    Rt(h, a, i), Ia(this, { year: h, month: a, day: i }, s);
+  }
+  get monthCode() {
+    return Vo(this, "monthCode");
+  }
+  get day() {
+    return Vo(this, "day");
+  }
+  get calendarId() {
+    return g(this, Se), c(this, b);
+  }
+  with(e, n = void 0) {
+    if (g(this, Se), !A(e)) throw new TypeError("invalid argument");
+    rn(e);
+    const r = c(this, b);
+    let o = be(r, c(this, C), "month-day");
+    return o = Yt(r, o, xe(r, e, ["year", "month", "monthCode", "day"], [], "partial")), Ht(ir(r, o, N(M(n))), r);
+  }
+  equals(e) {
+    g(this, Se);
+    const n = Co(e);
+    return Qe(c(this, C), c(n, C)) === 0 && Ve(c(this, b), c(n, b));
+  }
+  toString(e = void 0) {
+    return g(this, Se), So(this, Fn(M(e)));
+  }
+  toJSON() {
+    return g(this, Se), So(this);
+  }
+  toLocaleString(e = void 0, n = void 0) {
+    return g(this, Se), new Pe(e, n).format(this);
+  }
+  valueOf() {
+    Tt("PlainMonthDay");
+  }
+  toPlainDate(e) {
+    if (g(this, Se), !A(e)) throw new TypeError("argument should be an object");
+    const n = c(this, b);
+    return we(Mt(n, Yt(n, be(n, c(this, C), "month-day"), xe(n, e, ["year"], [], [])), "constrain"), n);
+  }
+  static from(e, n = void 0) {
+    return Co(e, n);
+  }
+}
+function Vo(t, e) {
+  g(t, Se);
+  const n = c(t, C);
+  return An(t).isoToDate(n, { [e]: !0 })[e];
+}
+function Sr(t) {
+  return Fe(t, Vr());
+}
+mt(yo, "Temporal.PlainMonthDay");
+const ni = { instant: () => _e(Vr()), plainDateTimeISO: (t = un()) => Le(Sr(ve(t)), "iso8601"), plainDateISO: (t = un()) => we(Sr(ve(t)).isoDate, "iso8601"), plainTimeISO: (t = un()) => at(Sr(ve(t)).time), timeZoneId: () => un(), zonedDateTimeISO: (t = un()) => {
+  const e = ve(t);
+  return ne(Vr(), e, "iso8601");
+}, [Symbol.toStringTag]: "Temporal.Now" };
+Object.defineProperty(ni, Symbol.toStringTag, { value: "Temporal.Now", writable: !1, enumerable: !1, configurable: !0 });
+class Xn {
+  constructor(e = 0, n = 0, r = 0, o = 0, a = 0, i = 0) {
+    const s = e === void 0 ? 0 : $(e), h = n === void 0 ? 0 : $(n), d = r === void 0 ? 0 : $(r), u = o === void 0 ? 0 : $(o), l = a === void 0 ? 0 : $(a), m = i === void 0 ? 0 : $(i);
+    Mr(s, h, d, u, l, m), Ca(this, { hour: s, minute: h, second: d, millisecond: u, microsecond: l, nanosecond: m });
+  }
+  get hour() {
+    return g(this, q), c(this, z).hour;
+  }
+  get minute() {
+    return g(this, q), c(this, z).minute;
+  }
+  get second() {
+    return g(this, q), c(this, z).second;
+  }
+  get millisecond() {
+    return g(this, q), c(this, z).millisecond;
+  }
+  get microsecond() {
+    return g(this, q), c(this, z).microsecond;
+  }
+  get nanosecond() {
+    return g(this, q), c(this, z).nanosecond;
+  }
+  with(e, n = void 0) {
+    if (g(this, q), !A(e)) throw new TypeError("invalid argument");
+    rn(e);
+    const r = Br(e, "partial"), o = Br(this);
+    let { hour: a, minute: i, second: s, millisecond: h, microsecond: d, nanosecond: u } = Object.assign(o, r);
+    const l = N(M(n));
+    return { hour: a, minute: i, second: s, millisecond: h, microsecond: d, nanosecond: u } = vr(a, i, s, h, d, u, l), new Xn(a, i, s, h, d, u);
+  }
+  add(e) {
+    return g(this, q), _o("add", this, e);
+  }
+  subtract(e) {
+    return g(this, q), _o("subtract", this, e);
+  }
+  until(e, n = void 0) {
+    return g(this, q), Fo("until", this, e, n);
+  }
+  since(e, n = void 0) {
+    return g(this, q), Fo("since", this, e, n);
+  }
+  round(e) {
+    if (g(this, q), e === void 0) throw new TypeError("options parameter is required");
+    const n = typeof e == "string" ? Nt("smallestUnit", e) : M(e), r = on(n), o = Ae(n, "halfExpand"), a = $e(n, "smallestUnit", "time", ut);
+    return an(r, { hour: 24, minute: 60, second: 60, millisecond: 1e3, microsecond: 1e3, nanosecond: 1e3 }[a], !1), at(Gr(c(this, z), r, a, o));
+  }
+  equals(e) {
+    g(this, q);
+    const n = pt(e);
+    return Kr(c(this, z), c(n, z)) === 0;
+  }
+  toString(e = void 0) {
+    g(this, q);
+    const n = M(e), r = Bn(n), o = Ae(n, "trunc"), a = $e(n, "smallestUnit", "time", void 0);
+    if (a === "hour") throw new RangeError('smallestUnit must be a time unit other than "hour"');
+    const { precision: i, unit: s, increment: h } = zn(a, r);
+    return Ro(Gr(c(this, z), h, s, o), i);
+  }
+  toJSON() {
+    return g(this, q), Ro(c(this, z), "auto");
+  }
+  toLocaleString(e = void 0, n = void 0) {
+    return g(this, q), new Pe(e, n).format(this);
+  }
+  valueOf() {
+    Tt("PlainTime");
+  }
+  static from(e, n = void 0) {
+    return pt(e, n);
+  }
+  static compare(e, n) {
+    const r = pt(e), o = pt(n);
+    return Kr(c(r, z), c(o, z));
+  }
+}
+mt(Xn, "Temporal.PlainTime");
+class go {
+  constructor(e, n, r = "iso8601", o = 1) {
+    const a = $(e), i = $(n), s = Me(r === void 0 ? "iso8601" : _(r)), h = $(o);
+    Rt(a, i, h), $a(this, { year: a, month: i, day: h }, s);
+  }
+  get year() {
+    return tt(this, "year");
+  }
+  get month() {
+    return tt(this, "month");
+  }
+  get monthCode() {
+    return tt(this, "monthCode");
+  }
+  get calendarId() {
+    return g(this, Q), c(this, b);
+  }
+  get era() {
+    return tt(this, "era");
+  }
+  get eraYear() {
+    return tt(this, "eraYear");
+  }
+  get daysInMonth() {
+    return tt(this, "daysInMonth");
+  }
+  get daysInYear() {
+    return tt(this, "daysInYear");
+  }
+  get monthsInYear() {
+    return tt(this, "monthsInYear");
+  }
+  get inLeapYear() {
+    return tt(this, "inLeapYear");
+  }
+  with(e, n = void 0) {
+    if (g(this, Q), !A(e)) throw new TypeError("invalid argument");
+    rn(e);
+    const r = c(this, b);
+    let o = be(r, c(this, C), "year-month");
+    return o = Yt(r, o, xe(r, e, ["year", "month", "monthCode"], [], "partial")), _t(Rn(r, o, N(M(n))), r);
+  }
+  add(e, n = void 0) {
+    return g(this, Q), Jo("add", this, e, n);
+  }
+  subtract(e, n = void 0) {
+    return g(this, Q), Jo("subtract", this, e, n);
+  }
+  until(e, n = void 0) {
+    return g(this, Q), Bo("until", this, e, n);
+  }
+  since(e, n = void 0) {
+    return g(this, Q), Bo("since", this, e, n);
+  }
+  equals(e) {
+    g(this, Q);
+    const n = wn(e);
+    return Qe(c(this, C), c(n, C)) === 0 && Ve(c(this, b), c(n, b));
+  }
+  toString(e = void 0) {
+    return g(this, Q), ko(this, Fn(M(e)));
+  }
+  toJSON() {
+    return g(this, Q), ko(this);
+  }
+  toLocaleString(e = void 0, n = void 0) {
+    return g(this, Q), new Pe(e, n).format(this);
+  }
+  valueOf() {
+    Tt("PlainYearMonth");
+  }
+  toPlainDate(e) {
+    if (g(this, Q), !A(e)) throw new TypeError("argument should be an object");
+    const n = c(this, b);
+    return we(Mt(n, Yt(n, be(n, c(this, C), "year-month"), xe(n, e, ["day"], [], [])), "constrain"), n);
+  }
+  static from(e, n = void 0) {
+    return wn(e, n);
+  }
+  static compare(e, n) {
+    const r = wn(e), o = wn(n);
+    return Qe(c(r, C), c(o, C));
+  }
+}
+function tt(t, e) {
+  g(t, Q);
+  const n = c(t, C);
+  return An(t).isoToDate(n, { [e]: !0 })[e];
+}
+mt(go, "Temporal.PlainYearMonth");
+const ds = Pe.prototype.resolvedOptions;
+class po {
+  constructor(e, n, r = "iso8601") {
+    if (arguments.length < 1) throw new TypeError("missing argument: epochNanoseconds is required");
+    const o = ur(e);
+    let a = _(n);
+    const { tzName: i, offsetMinutes: s } = vt(a);
+    if (s === void 0) {
+      const h = sr(i);
+      if (!h) throw new RangeError(`unknown time zone ${i}`);
+      a = h.identifier;
+    } else a = to(s);
+    Ya(this, o, a, Me(r === void 0 ? "iso8601" : _(r)));
+  }
+  get calendarId() {
+    return g(this, S), c(this, b);
+  }
+  get timeZoneId() {
+    return g(this, S), c(this, x);
+  }
+  get year() {
+    return ce(this, "year");
+  }
+  get month() {
+    return ce(this, "month");
+  }
+  get monthCode() {
+    return ce(this, "monthCode");
+  }
+  get day() {
+    return ce(this, "day");
+  }
+  get hour() {
+    return zt(this, "hour");
+  }
+  get minute() {
+    return zt(this, "minute");
+  }
+  get second() {
+    return zt(this, "second");
+  }
+  get millisecond() {
+    return zt(this, "millisecond");
+  }
+  get microsecond() {
+    return zt(this, "microsecond");
+  }
+  get nanosecond() {
+    return zt(this, "nanosecond");
+  }
+  get era() {
+    return ce(this, "era");
+  }
+  get eraYear() {
+    return ce(this, "eraYear");
+  }
+  get epochMilliseconds() {
+    return g(this, S), Be(c(this, I), "floor");
+  }
+  get epochNanoseconds() {
+    return g(this, S), qa(c(this, I));
+  }
+  get dayOfWeek() {
+    return ce(this, "dayOfWeek");
+  }
+  get dayOfYear() {
+    return ce(this, "dayOfYear");
+  }
+  get weekOfYear() {
+    return ce(this, "weekOfYear")?.week;
+  }
+  get yearOfWeek() {
+    return ce(this, "weekOfYear")?.year;
+  }
+  get hoursInDay() {
+    g(this, S);
+    const e = c(this, x), n = qe(this).isoDate, r = Oe(n.year, n.month, n.day + 1), o = yt(e, n), a = yt(e, r);
+    return Cn(k.fromEpochNsDiff(a, o), "hour");
+  }
+  get daysInWeek() {
+    return ce(this, "daysInWeek");
+  }
+  get daysInMonth() {
+    return ce(this, "daysInMonth");
+  }
+  get daysInYear() {
+    return ce(this, "daysInYear");
+  }
+  get monthsInYear() {
+    return ce(this, "monthsInYear");
+  }
+  get inLeapYear() {
+    return ce(this, "inLeapYear");
+  }
+  get offset() {
+    return g(this, S), zr(it(c(this, x), c(this, I)));
+  }
+  get offsetNanoseconds() {
+    return g(this, S), it(c(this, x), c(this, I));
+  }
+  with(e, n = void 0) {
+    if (g(this, S), !A(e)) throw new TypeError("invalid zoned-date-time-like");
+    rn(e);
+    const r = c(this, b), o = c(this, x), a = it(o, c(this, I)), i = qe(this);
+    let s = { ...be(r, i.isoDate), ...i.time, offset: zr(a) };
+    s = Yt(r, s, xe(r, e, ["year", "month", "monthCode", "day"], ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond", "offset"], "partial"));
+    const h = M(n), d = In(h), u = er(h, "prefer"), l = qn(r, s, N(h)), m = sn(s.offset);
+    return ne(ar(l.isoDate, l.time, "option", m, o, d, u, !1), o, r);
+  }
+  withPlainTime(e = void 0) {
+    g(this, S);
+    const n = c(this, x), r = c(this, b), o = qe(this).isoDate;
+    let a;
+    return a = e === void 0 ? yt(n, o) : oe(n, j(o, c(pt(e), z)), "compatible"), ne(a, n, r);
+  }
+  withTimeZone(e) {
+    g(this, S);
+    const n = ve(e);
+    return ne(c(this, I), n, c(this, b));
+  }
+  withCalendar(e) {
+    g(this, S);
+    const n = Hn(e);
+    return ne(c(this, I), c(this, x), n);
+  }
+  add(e, n = void 0) {
+    return g(this, S), Go("add", this, e, n);
+  }
+  subtract(e, n = void 0) {
+    return g(this, S), Go("subtract", this, e, n);
+  }
+  until(e, n = void 0) {
+    return g(this, S), zo("until", this, e, n);
+  }
+  since(e, n = void 0) {
+    return g(this, S), zo("since", this, e, n);
+  }
+  round(e) {
+    if (g(this, S), e === void 0) throw new TypeError("options parameter is required");
+    const n = typeof e == "string" ? Nt("smallestUnit", e) : M(e), r = on(n), o = Ae(n, "halfExpand"), a = $e(n, "smallestUnit", "time", ut, ["day"]), i = { day: 1, hour: 24, minute: 60, second: 60, millisecond: 1e3, microsecond: 1e3, nanosecond: 1e3 }[a];
+    if (an(r, i, i === 1), a === "nanosecond" && r === 1) return ne(c(this, I), c(this, x), c(this, b));
+    const s = c(this, x), h = c(this, I), d = qe(this);
+    let u;
+    if (a === "day") {
+      const l = d.isoDate, m = Oe(l.year, l.month, l.day + 1), f = yt(s, l), p = yt(s, m), v = y.subtract(p, f);
+      u = k.fromEpochNsDiff(h, f).round(v, o).addToEpochNs(f);
+    } else {
+      const l = Jr(d, r, a, o), m = it(s, h);
+      u = ar(l.isoDate, l.time, "option", m, s, "compatible", "prefer", !1);
+    }
+    return ne(u, s, c(this, b));
+  }
+  equals(e) {
+    g(this, S);
+    const n = vn(e), r = c(this, I), o = c(n, I);
+    return !!y.equal(y.BigInt(r), y.BigInt(o)) && !!Ra(c(this, x), c(n, x)) && Ve(c(this, b), c(n, b));
+  }
+  toString(e = void 0) {
+    g(this, S);
+    const n = M(e), r = Fn(n), o = Bn(n), a = (function(m) {
+      return dt(m, "offset", ["auto", "never"], "auto");
+    })(n), i = Ae(n, "trunc"), s = $e(n, "smallestUnit", "time", void 0);
+    if (s === "hour") throw new RangeError('smallestUnit must be a time unit other than "hour"');
+    const h = (function(m) {
+      return dt(m, "timeZoneName", ["auto", "never", "critical"], "auto");
+    })(n), { precision: d, unit: u, increment: l } = zn(s, o);
+    return No(this, d, r, h, a, { unit: u, increment: l, roundingMode: i });
+  }
+  toLocaleString(e = void 0, n = void 0) {
+    g(this, S);
+    const r = M(n), o = /* @__PURE__ */ Object.create(null);
+    if ((function(h, d, u, l) {
+      if (d == null) return;
+      const m = Reflect.ownKeys(d);
+      for (let f = 0; f < m.length; f++) {
+        const p = m[f];
+        if (!u.some(((v) => Object.is(v, p))) && Object.prototype.propertyIsEnumerable.call(d, p)) {
+          const v = d[p];
+          h[p] = v;
+        }
+      }
+    })(o, r, ["timeZone"]), r.timeZone !== void 0) throw new TypeError("ZonedDateTime toLocaleString does not accept a timeZone option");
+    if (o.year === void 0 && o.month === void 0 && o.day === void 0 && o.era === void 0 && o.weekday === void 0 && o.dateStyle === void 0 && o.hour === void 0 && o.minute === void 0 && o.second === void 0 && o.fractionalSecondDigits === void 0 && o.timeStyle === void 0 && o.dayPeriod === void 0 && o.timeZoneName === void 0 && (o.timeZoneName = "short"), o.timeZone = c(this, x), jo(o.timeZone)) throw new RangeError("toLocaleString does not currently support offset time zones");
+    const a = new Pe(e, o), i = ds.call(a).calendar, s = c(this, b);
+    if (s !== "iso8601" && i !== "iso8601" && !Ve(i, s)) throw new RangeError(`cannot format ZonedDateTime with calendar ${s} in locale with calendar ${i}`);
+    return a.format(_e(c(this, I)));
+  }
+  toJSON() {
+    return g(this, S), No(this, "auto");
+  }
+  valueOf() {
+    Tt("ZonedDateTime");
+  }
+  startOfDay() {
+    g(this, S);
+    const e = c(this, x);
+    return ne(yt(e, qe(this).isoDate), e, c(this, b));
+  }
+  getTimeZoneTransition(e) {
+    g(this, S);
+    const n = c(this, x);
+    if (e === void 0) throw new TypeError("options parameter is required");
+    const r = dt(typeof e == "string" ? Nt("direction", e) : M(e), "direction", ["next", "previous"], ut);
+    if (r === void 0) throw new TypeError("direction option is required");
+    if (jo(n) || n === "UTC") return null;
+    const o = c(this, I), a = r === "next" ? ro(n, o) : qr(n, o);
+    return a === null ? null : ne(a, n, c(this, b));
+  }
+  toInstant() {
+    return g(this, S), _e(c(this, I));
+  }
+  toPlainDate() {
+    return g(this, S), we(qe(this).isoDate, c(this, b));
+  }
+  toPlainTime() {
+    return g(this, S), at(qe(this).time);
+  }
+  toPlainDateTime() {
+    return g(this, S), Le(qe(this), c(this, b));
+  }
+  static from(e, n = void 0) {
+    return vn(e, n);
+  }
+  static compare(e, n) {
+    const r = vn(e), o = vn(n), a = c(r, I), i = c(o, I);
+    return y.lessThan(y.BigInt(a), y.BigInt(i)) ? -1 : y.greaterThan(y.BigInt(a), y.BigInt(i)) ? 1 : 0;
+  }
+}
+function qe(t) {
+  return Fe(c(t, x), c(t, I));
+}
+function ce(t, e) {
+  g(t, S);
+  const n = qe(t).isoDate;
+  return An(t).isoToDate(n, { [e]: !0 })[e];
+}
+function zt(t, e) {
+  return g(t, S), qe(t).time[e];
+}
+mt(po, "Temporal.ZonedDateTime");
+var ls = Object.freeze({ __proto__: null, Duration: nn, Instant: lo, Now: ni, PlainDate: mo, PlainDateTime: fo, PlainMonthDay: yo, PlainTime: Xn, PlainYearMonth: go, ZonedDateTime: po });
+const hs = [lo, mo, fo, nn, yo, Xn, go, po];
+for (const t of hs) {
+  const e = Object.getOwnPropertyDescriptor(t, "prototype");
+  (e.configurable || e.enumerable || e.writable) && (e.configurable = !1, e.enumerable = !1, e.writable = !1, Object.defineProperty(t, "prototype", e));
+}
+export {
+  ls as Temporal
+};