temporal-polyfill-lite 0.2.0 → 0.2.2

package/dist/Temporal-BUBnYRDZ.js

@@ -0,0 +1,4151 @@
+function getNameFromUnit(e) {
+  return de[e];
+}
+function nanosecondsForTimeUnit(e) {
+  return Te[e - 3];
+}
+function isObject(e) {
+  return ("object" == typeof e || "function" == typeof e) && null !== e;
+}
+function createNullPrototypeObject(e) {
+  return Object.assign(Object.create(null), e);
+}
+function mapUnlessUndefined(e, t) {
+  return void 0 === e ? void 0 : t(e);
+}
+function withArray(e, t) {
+  return e.map((e, o) => e ?? t[o]);
+}
+function throwRangeError(e) {
+  throw new RangeError(e);
+}
+function throwTypeError(e) {
+  throw new TypeError(e);
+}
+function toPrimitive(e) {
+  if (!isObject(e)) return e;
+  const t = e[Symbol.toPrimitive];
+  if (null != t) {
+    const o = Date.call.call(t, e, "string");
+    if (!isObject(o)) return o;
+    throwTypeError("cannot convert value to primitive");
+  }
+  return Date.prototype[Symbol.toPrimitive].call(e, "string");
+}
+function toString(e) {
+  return `${e}`;
+}
+function toBoolean(e) {
+  return !!e;
+}
+function toBigInt(e) {
+  return isObject(e) || "number" == typeof e ? BigInt.asIntN(2 ** 53 - 1, e) : BigInt(e);
+}
+function toIntegerIfIntegral(e) {
+  const t = ye(e);
+  return (Number.isInteger(t) || throwRangeError(invalidNumber(t)), t + 0);
+}
+function toIntegerWithTruncation(e) {
+  const t = ye(e);
+  return ((!isNaN(t) && isFinite(t)) || throwRangeError(invalidNumber(t)), Math.trunc(t) + 0);
+}
+function toPositiveIntegerWithTruncation(e) {
+  const t = toIntegerWithTruncation(e);
+  return (t <= 0 && throwRangeError(invalidNumber(t)), t);
+}
+function getOptionsObject(e = createNullPrototypeObject({})) {
+  return (isObject(e) || throwTypeError("invalid options object"), e);
+}
+function getOption(e, t, o, n) {
+  const r = e[t];
+  if (void 0 === r) return (n === a && throwRangeError(missingField(t)), n);
+  const i = toString(r);
+  return (o.includes(i) || throwRangeError(invalidField(t)), i);
+}
+function getRoundToOptionsObject(e) {
+  return (
+    void 0 === e && throwTypeError(ve),
+    "string" == typeof e ? createNullPrototypeObject({ smallestUnit: e }) : getOptionsObject(e)
+  );
+}
+function validateString(e) {
+  "string" != typeof e && throwTypeError(((e) => `${e} is not a string`)(e));
+}
+function divFloor(e, t) {
+  return Math.floor(e / t) + 0;
+}
+function modFloor(e, t) {
+  return (((e % t) + t) % t) + 0;
+}
+function divTrunc(e, t) {
+  return Math.trunc(e / t) + 0;
+}
+function sign(e) {
+  return e < 0 ? -1 : e ? 1 : 0;
+}
+function compare(e, t) {
+  return sign(e - t);
+}
+function clamp(e, t, o) {
+  return e < t ? t : e > o ? o : e;
+}
+function isWithin(e, t, o) {
+  return e >= t && e <= o;
+}
+function makePropertyNonEnumerable(e, t) {
+  Object.defineProperty(e, t, { enumerable: !1 });
+}
+function makePropertiesNonEnumerable(e) {
+  for (const t of Object.keys(e)) makePropertyNonEnumerable(e, t);
+}
+function defineNonEnumerableProperty(e, t, o) {
+  ((e[t] = o), makePropertyNonEnumerable(e, t));
+}
+function defineStringTag(e, t) {
+  Object.defineProperty(e, Symbol.toStringTag, { value: t, configurable: !0 });
+}
+function renameFunction(e, t) {
+  Object.defineProperty(e, "name", { value: t });
+}
+function asciiLowerCase(e) {
+  return e.replace(/[A-Z]/g, (e) => e.toLowerCase());
+}
+function asciiUpperCase(e) {
+  return e.replace(/[a-z]/g, (e) => e.toUpperCase());
+}
+function toZeroPaddedDecimalString(e, t) {
+  return toString(e).padStart(t, "0");
+}
+function normalizeEpochNanoseconds(e, t) {
+  return [e + divFloor(t, k), modFloor(t, k)];
+}
+function createEpochNanosecondsFromBigInt(e) {
+  return normalizeEpochNanoseconds(Number(e / BigInt(k)), Number(e % BigInt(k)));
+}
+function createEpochNanosecondsFromEpochMilliseconds(e) {
+  return normalizeEpochNanoseconds(divFloor(e, z), 1e6 * modFloor(e, z));
+}
+function createEpochNanosecondsFromEpochSeconds(e) {
+  return createEpochNanosecondsFromEpochMilliseconds(1e3 * e);
+}
+function convertEpochNanosecondsToBigInt(e) {
+  return BigInt(e[0]) * BigInt(k) + BigInt(e[1]);
+}
+function compareEpochNanoseconds(e, t) {
+  return compare(e[0], t[0]) || compare(e[1], t[1]);
+}
+function epochMilliseconds(e) {
+  return e[0] * z + divFloor(e[1], C);
+}
+function epochSeconds(e) {
+  return divFloor(epochMilliseconds(e), 1e3);
+}
+function addNanosecondsToEpochSeconds(e, t) {
+  return normalizeEpochNanoseconds(e[0], e[1] + t);
+}
+function differenceEpochNanoseconds(e, t) {
+  return normalize(t[0] - e[0], t[1] - e[1]);
+}
+function addTimeDurationToEpochNanoseconds(e, t) {
+  return normalizeEpochNanoseconds(e[0] + t[0], e[1] + t[1]);
+}
+function normalize(e, t) {
+  const [o, n] = normalizeEpochNanoseconds(e, t);
+  return o < 0 && n > 0 ? [o + 1, n - k] : [o, n];
+}
+function createTimeDurationFromSeconds(e) {
+  return normalize(divTrunc(e, W), (e % W) * 1e9);
+}
+function addTimeDuration(e, t) {
+  return normalize(e[0] + t[0], e[1] + t[1]);
+}
+function absTimeDuration(e) {
+  return normalize(Math.abs(e[0]), Math.abs(e[1]));
+}
+function negateTimeDuration(e) {
+  return normalize(-e[0], -e[1]);
+}
+function signTimeDuration(e) {
+  return Ee(e, [0, 0]);
+}
+function timeDurationToSubsecondsNumber(e, t, o) {
+  const n = signTimeDuration(e);
+  return (
+    (e = absTimeDuration(e)),
+    n *
+      ye(
+        `${864 * e[0] + divTrunc(e[1], 1e11)}${toZeroPaddedDecimalString(divTrunc(e[1] % 1e11, 10 ** (9 + t)), 2 - t)}.${o ? toZeroPaddedDecimalString(e[1] % 10 ** (9 + t), 9 + t) : "0"}`,
+      ) +
+      0
+  );
+}
+function roundTimeDurationByDays(e, t, o) {
+  return normalize(
+    roundNumberToIncrement(
+      e[0] + signTimeDuration(e) * (e[1] ? 0.2 * compare(Math.abs(e[1] / k), 0.5) + 0.5 : 0),
+      t,
+      o,
+    ),
+    0,
+  );
+}
+function divideTimeDurationToFloatingPoint(e, t) {
+  return t <= 1e9
+    ? timeDurationToSubsecondsNumber(e, -9 + Math.log10(t), !0)
+    : (k / t) * e[0] + e[1] / t;
+}
+function interpretISODateTimeOffset(e, t, o, n, r, a, i, l) {
+  if (void 0 === t) return getStartOfDay(r, e);
+  const c = combineIsoDateAndTimeRecord(e, t);
+  if (o === g || (o === p && i == u)) return getEpochNanosecondsFor(r, c, a);
+  if (o === h || (o === p && "use" == i))
+    return validateEpochNanoseconds(
+      getUtcEpochNanoseconds(
+        balanceIsoDateTime(c.o.t, c.o.u, c.o.T, c.p.D, c.p.I, c.p.O, c.p.S, c.p.F, c.p.v - n),
+      ),
+    );
+  ((e) => {
+    Math.abs(isoDateToEpochDays(e.t, e.u - 1, e.T)) > 1e8 && throwRangeError(pe);
+  })(e);
+  const s = getPossibleEpochNanoseconds(r, c);
+  for (const e of s) {
+    const t = getOffsetNanosecondsFor(r, e);
+    if (t === n) return e;
+    if (!l && roundNumberToIncrement(t, Y, v) === n) return e;
+  }
+  return (
+    i === D && throwRangeError("time zone offset mismatch"),
+    disambiguatePossibleEpochNanoseconds(s, r, c, a)
+  );
+}
+function toTemporalZonedDateTime(e, t) {
+  let o,
+    n,
+    r,
+    a,
+    i,
+    l,
+    s,
+    d = !1,
+    m = !0;
+  if (isObject(e)) {
+    if (isZonedDateTime(e)) {
+      const o = getOptionsObject(t);
+      return (
+        getTemporalDisambiguationOption(o),
+        getTemporalOffsetOption(o, c),
+        getTemporalOverflowOption(o),
+        createTemporalZonedDateTimeFromSlot(getInternalSlotOrThrowForZonedDateTime(e))
+      );
+    }
+    i = getTemporalCalendarIdentifierWithIsoDefault(e);
+    const d = prepareCalendarFields(
+      i,
+      e,
+      [pt.t, pt.u, pt.P, pt.T, pt.D, pt.I, pt.O, pt.S, pt.F, pt.v, pt.R, pt.$],
+      [pt.$],
+    );
+    ((o = d.timeZone), (n = d.offset));
+    const m = getOptionsObject(t);
+    ((r = getTemporalDisambiguationOption(m)), (a = getTemporalOffsetOption(m, c)));
+    const T = interpretTemporalDateTimeFields(i, d, getTemporalOverflowOption(m));
+    ((l = T.o), (s = T.p));
+  } else {
+    validateString(e);
+    const T = parseIsoDateTime(e, [Qe]);
+    ((o = toTemporalTimeZoneIdentifier(T.$.Z)),
+      (n = T.$.N),
+      (d = T.$.M),
+      (i = canonicalizeCalendar(T.U || "iso8601")),
+      (m = !1),
+      void 0 !== n && (m = hasUtcOffsetSubMinuteParts(n)));
+    const u = getOptionsObject(t);
+    ((r = getTemporalDisambiguationOption(u)),
+      (a = getTemporalOffsetOption(u, c)),
+      getTemporalOverflowOption(u),
+      (l = createIsoDateRecord(T.t, T.u, T.T)),
+      (s = T.p));
+  }
+  const T = d ? h : void 0 === n ? g : p;
+  return createTemporalZonedDateTime(
+    interpretISODateTimeOffset(l, s, T, T === p ? parseDateTimeUtcOffset(n) : 0, o, r, a, m),
+    o,
+    i,
+  );
+}
+function createTemporalZonedDateTime(e, t, o, n = Object.create(be.prototype)) {
+  return createTemporalZonedDateTimeFromSlot(
+    createZonedDateTimeSlot(
+      e,
+      t,
+      o,
+      ((e, t) => Ze[e] && Ze[e].C(clampEpochSecond(t)))(t, epochSeconds(e)),
+    ),
+    n,
+  );
+}
+function createZonedDateTimeSlot(e, t, o, n) {
+  return { Y: e, $: t, U: o, A: n };
+}
+function temporalZonedDateTimeToString(e, t, o, n, r, a = 1, i = Q, l = S) {
+  const c = roundTemporalInstant(e.Y, a, i, l),
+    s =
+      epochSeconds(c) === epochSeconds(e.Y)
+        ? getOffsetNanosecondsForZonedDateTimeSlot(e)
+        : getOffsetNanosecondsFor(e.$, c);
+  return `${isoDateTimeToString(getIsoDateTimeFromOffsetNanoseconds(c, s), "iso8601", t, R)}${r === M ? "" : formatDateTimeUtcOffsetRounded(s)}${n === j ? "" : `[${n === $ ? "!" : ""}${e.$}]`}${formatCalendarAnnotation(e.U, o)}`;
+}
+function addZonedDateTime(e, t, o) {
+  if (0 === dateDurationSign(t.W)) return addInstant(e.Y, t.p);
+  const n = getIsoDateTimeForZonedDateTimeSlot(e);
+  return addInstant(
+    getEpochNanosecondsFor(
+      e.$,
+      validateIsoDateTime(combineIsoDateAndTimeRecord(calendarDateAdd(e.U, n.o, t.W, o), n.p)),
+      s,
+    ),
+    t.p,
+  );
+}
+function differenceZonedDateTime(e, t, o) {
+  const n = compareEpochNanoseconds(e.Y, t.Y);
+  if (!n) return combineDateAndTimeDuration(zeroDateDuration(), createTimeDurationFromSeconds(0));
+  const r = getIsoDateTimeForZonedDateTimeSlot(e),
+    a = getIsoDateTimeForZonedDateTimeSlot(t);
+  if (!compareIsoDate(r.o, a.o))
+    return combineDateAndTimeDuration(
+      zeroDateDuration(),
+      timeDurationFromEpochNanosecondsDifference(t.Y, e.Y),
+    );
+  let i,
+    l = differenceTime(r.p, a.p);
+  for (
+    let o = St(l) === n ? 1 : 0;
+    o <= (3 - n) / 2 &&
+    ((i = combineIsoDateAndTimeRecord(addDaysToIsoDate(a.o, o * n), r.p)),
+    (l = timeDurationFromEpochNanosecondsDifference(t.Y, getEpochNanosecondsFor(e.$, i, s))),
+    St(l) === n);
+    o++
+  );
+  return combineDateAndTimeDuration(
+    calendarDateUntil(e.U, r.o, i.o, largerOfTwoTemporalUnits(o, q)),
+    l,
+  );
+}
+function differenceZonedDateTimeWithRounding(e, t, o, n, r, a) {
+  if (!isDateUnit(o)) return differenceInstant(e.Y, t.Y, n, r, a);
+  const i = differenceZonedDateTime(e, t, o);
+  return r === Q && 1 === n
+    ? i
+    : roundRelativeDuration(
+        i,
+        e.Y,
+        t.Y,
+        getIsoDateTimeForZonedDateTimeSlot(e),
+        e.$,
+        e.U,
+        o,
+        n,
+        r,
+        a,
+      );
+}
+function differenceTemporalZonedDateTime(e, t, n, r) {
+  const a = getInternalSlotOrThrowForZonedDateTime(toTemporalZonedDateTime(n));
+  calendarEquals(t.U, a.U) || throwRangeError(fe);
+  const i = getDifferenceSettings(e, getOptionsObject(r), o, [], Q, J);
+  return isDateUnit(i.V)
+    ? (timeZoneEquals(t.$, a.$) || throwRangeError("time zone mismatch"),
+      compareEpochNanoseconds(t.Y, a.Y)
+        ? createTemporalDuration(
+            applySignToDurationSlot(
+              temporalDurationFromInternal(
+                differenceZonedDateTimeWithRounding(t, a, i.V, i.H, i.L, i.B),
+                J,
+              ),
+              e,
+            ),
+          )
+        : createTemporalDuration(createTemporalDurationSlot(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)))
+    : createTemporalDuration(
+        applySignToDurationSlot(
+          temporalDurationFromInternal(differenceInstant(t.Y, a.Y, i.H, i.L, i.B), i.V),
+          e,
+        ),
+      );
+}
+function addDurationToZonedDateTime(e, t, o, n) {
+  return createTemporalZonedDateTime(
+    addZonedDateTime(
+      t,
+      toInternalDurationRecord(applySignToDurationSlot(toTemporalDuration(o), e)),
+      getTemporalOverflowOption(getOptionsObject(n)),
+    ),
+    t.$,
+    t.U,
+  );
+}
+function getOffsetNanosecondsForZonedDateTimeSlot(e) {
+  return (e.A ??= getOffsetNanosecondsFor(e.$, e.Y));
+}
+function getIsoDateTimeForZonedDateTimeSlot(e) {
+  return getIsoDateTimeFromOffsetNanoseconds(e.Y, getOffsetNanosecondsForZonedDateTimeSlot(e));
+}
+function createTemporalZonedDateTimeFromSlot(e, t = Object.create(be.prototype)) {
+  return (Pe.set(t, e), t);
+}
+function calendarIsoToDateForZonedDateTimeSlot(e) {
+  return calendarIsoToDate(e.U, getIsoDateTimeForZonedDateTimeSlot(e).o);
+}
+function getInternalSlotForZonedDateTime(e) {
+  return Pe.get(e);
+}
+function getInternalSlotOrThrowForZonedDateTime(e) {
+  const t = getInternalSlotForZonedDateTime(e);
+  return (t || throwTypeError(Ie), t);
+}
+function isZonedDateTime(e) {
+  return !!getInternalSlotForZonedDateTime(e);
+}
+function utcEpochMilliseconds(e, t, o, n = 0, r = 0, a = 0, i = 0) {
+  return isoDateToEpochDays(e, t - 1, o) * z + Date.UTC(1970, 0, 1, n, r, a, i);
+}
+function clampEpochSecond(e) {
+  return clamp(e, -1e10, 1 / 0);
+}
+function getNamedTimeZoneOffsetNanosecondsForEpochSecond(e, t, o) {
+  if ("UTC" === e) return 0;
+  const n = clampEpochSecond(t),
+    r = (Ze[e] ||= (() => {
+      const e = new Map();
+      return {
+        C(t) {
+          if (e.has(t)) {
+            const o = e.get(t);
+            return (e.delete(t), e.set(t, o), o);
+          }
+        },
+        q(t, o) {
+          (e.size >= 5e3 && e.delete(e.keys().next().value), e.set(t, o));
+        },
+      };
+    })()),
+    a = r.C(n);
+  if (void 0 !== a) return a;
+  const i = getFormatterForTimeZone(e).formatToParts(1e3 * n),
+    l =
+      (utcEpochMilliseconds(
+        ...["year", "month", "day", "hour", "minute", "second"].map((e) =>
+          toIntegerIfIntegral(i.find((t) => t.type === e).value),
+        ),
+      ) -
+        1e3 * n) *
+      C;
+  return (o || r.q(n, l), l);
+}
+function getFormatterForTimeZone(e) {
+  return (Re[e] ||= new yt("en-u-hc-h23", {
+    timeZone: e,
+    year: "numeric",
+    month: "numeric",
+    day: "numeric",
+    hour: "numeric",
+    minute: "numeric",
+    second: "numeric",
+  }));
+}
+function bisectOffsetTransition(e, t, o) {
+  const n = getNamedTimeZoneOffsetNanosecondsForEpochSecond(e, t);
+  let r = t,
+    a = o;
+  for (; a - r > 1; ) {
+    const t = Math.floor((a + r) / 2);
+    getNamedTimeZoneOffsetNanosecondsForEpochSecond(e, t, a - r > 3) === n ? (r = t) : (a = t);
+  }
+  return a;
+}
+function adjustWindowForEpoch(e) {
+  return e < -85e7 ? 1814400 : e > -77e7 && e < 96e7 ? 1382400 : 561600;
+}
+function searchTimeZoneTransition(e, t, o, n) {
+  o = clamp(o, -864e10, 864e10);
+  for (
+    let r = 172800 * n, a = t, i = t + r;
+    (o - i) * n > 0;
+    r = adjustWindowForEpoch(a) * n, a = i, i = clamp(i + r, -864e10, 864e10)
+  )
+    if (
+      getNamedTimeZoneOffsetNanosecondsForEpochSecond(e, a, !0) !==
+      getNamedTimeZoneOffsetNanosecondsForEpochSecond(e, i, !0)
+    )
+      return createEpochNanosecondsFromEpochSeconds(
+        n > 0 ? bisectOffsetTransition(e, a, i) : bisectOffsetTransition(e, i, a),
+      );
+  return null;
+}
+function getAvailableNamedTimeZoneIdentifier(e) {
+  return (
+    ((e) => {
+      /^(?![cemw]et|[emh]st|prc|ro[ck]|uct|utc|gmt)[a-z]{3}$|systemv|^us.*w$/i.test(e) &&
+        throwRangeError(invalidTimeZone(e));
+    })(
+      (e = asciiLowerCase(e).replace(/[^/]+/g, (e) =>
+        /^(?!etc|yap).{1,3}$|\d/.test(e)
+          ? asciiUpperCase(e)
+          : e.replace(/baja|mc|comod|[a-z]+/g, (e) => {
+              return /^(su|gb|nz|in|chat)$/.test(e)
+                ? asciiUpperCase(e)
+                : /^(of|au|es)$/.test(e)
+                  ? e
+                  : ((t = e), t.replace(/^[a-z]/, (e) => e.toUpperCase())).replace(
+                      /du(?=r)|n(?=or)|i(?=slan)/,
+                      asciiUpperCase,
+                    );
+              var t;
+            }),
+      )),
+    ),
+    getFormatterForTimeZone(e),
+    e
+  );
+}
+function formatOffsetTimeZoneIdentifier(e) {
+  const t = Math.abs(e);
+  return `${e < 0 ? "-" : "+"}${formatTimeString(divFloor(t, 60), modFloor(t, 60), 0, 0, i)}`;
+}
+function formatUtcOffsetNanoseconds(e) {
+  const t = Math.abs(e),
+    o = modFloor(divFloor(t, 1e9), 60),
+    n = modFloor(t, 1e9);
+  return `${e < 0 ? "-" : "+"}${formatTimeString(divFloor(t, A), modFloor(divFloor(t, Y), 60), o, n, 0 === o && 0 === n ? i : void 0)}`;
+}
+function formatDateTimeUtcOffsetRounded(e) {
+  return formatOffsetTimeZoneIdentifier(roundNumberToIncrement(e, Y, v) / Y);
+}
+function toTemporalTimeZoneIdentifier(e) {
+  if (isZonedDateTime(e)) return getInternalSlotOrThrowForZonedDateTime(e).$;
+  validateString(e);
+  const t = ((e) => {
+    if (isTimeZoneIdentifier(e)) return parseTimeZoneIdentifier(e);
+    const t = parseIsoDateTime(e, [Qe, et, tt, ot, nt, rt]).$,
+      o = t.Z || (t.M && "UTC") || t.N;
+    return (o || throwRangeError(invalidTimeZone(e)), parseTimeZoneIdentifier(o));
+  })(e);
+  return t.J ? getAvailableNamedTimeZoneIdentifier(t.J) : formatOffsetTimeZoneIdentifier(t.G);
+}
+function getOffsetNanosecondsFor(e, t) {
+  return isOffsetTimeZoneIdentifier(e)
+    ? parseDateTimeUtcOffset(e)
+    : getNamedTimeZoneOffsetNanosecondsForEpochSecond(e, epochSeconds(t));
+}
+function getEpochNanosecondsFor(e, t, o) {
+  return disambiguatePossibleEpochNanoseconds(getPossibleEpochNanoseconds(e, t), e, t, o);
+}
+function disambiguatePossibleEpochNanoseconds(e, t, o, n) {
+  if (1 === e.length) return e[0];
+  n === m && throwRangeError("ambiguity / gaps in local time");
+  const r = 0 === e.length;
+  return (
+    (e = getNamedTimeZoneEpochCandidates(t, o).map((e) => validateEpochNanoseconds(e))),
+    n === s ? (r ? e[1] : e[0]) : n === d ? e[1] : e[0]
+  );
+}
+function getPossibleEpochNanoseconds(e, t) {
+  return isOffsetTimeZoneIdentifier(e)
+    ? [
+        validateEpochNanoseconds(
+          getUtcEpochNanoseconds(
+            balanceIsoDateTime(
+              t.o.t,
+              t.o.u,
+              t.o.T,
+              t.p.D,
+              t.p.I,
+              t.p.O,
+              t.p.S,
+              t.p.F,
+              t.p.v - parseDateTimeUtcOffset(e),
+            ),
+          ),
+        ),
+      ]
+    : ((e, t) => {
+        const o = getUtcEpochNanoseconds(t);
+        return getNamedTimeZoneEpochCandidates(e, t).filter(
+          (t) =>
+            !compareEpochNanoseconds(
+              addNanosecondsToEpochSeconds(t, getOffsetNanosecondsFor(e, t)),
+              o,
+            ),
+        );
+      })(e, t).map(validateEpochNanoseconds);
+}
+function getStartOfDay(e, t) {
+  const o = combineIsoDateAndTimeRecord(t, midnightTimeRecord());
+  return (
+    getPossibleEpochNanoseconds(e, o)[0] ||
+    createEpochNanosecondsFromEpochSeconds(
+      bisectOffsetTransition(e, ...getNamedTimeZoneEpochCandidates(e, o).map(epochSeconds)),
+    )
+  );
+}
+function timeZoneEquals(e, t) {
+  return (
+    e === t ||
+    (!isOffsetTimeZoneIdentifier(e) &&
+      !isOffsetTimeZoneIdentifier(t) &&
+      getFormatterForTimeZone(e).resolvedOptions().timeZone ===
+        getFormatterForTimeZone(t).resolvedOptions().timeZone)
+  );
+}
+function parseTimeZoneIdentifier(e) {
+  return (
+    isTimeZoneIdentifier(e) || throwRangeError(invalidTimeZone(e)),
+    createNullPrototypeObject(
+      isOffsetTimeZoneIdentifier(e) ? { G: parseDateTimeUtcOffset(e) / Y } : { J: e },
+    )
+  );
+}
+function isOffsetTimeZoneIdentifier(e) {
+  return /^[+-]/.test(e);
+}
+function getNamedTimeZoneEpochCandidates(e, t) {
+  const o = getUtcEpochNanoseconds(t);
+  if ("UTC" === e) return [o];
+  const n = getOffsetNanosecondsFor(
+      e,
+      clampEpochNanoseconds(addNanosecondsToEpochSeconds(o, -864e11)),
+    ),
+    r = getOffsetNanosecondsFor(e, clampEpochNanoseconds(addNanosecondsToEpochSeconds(o, 864e11))),
+    a = addNanosecondsToEpochSeconds(o, -n),
+    i = addNanosecondsToEpochSeconds(o, -r);
+  return n === r ? [a] : [a, i].sort(compareEpochNanoseconds);
+}
+function getIsoDateTimeFromOffsetNanoseconds(e, t) {
+  return ((e) => {
+    const [t, o] = e;
+    return combineIsoDateAndTimeRecord(epochDaysToIsoDate(t), balanceTime(0, 0, 0, 0, 0, o));
+  })(addNanosecondsToEpochSeconds(e, t));
+}
+function combineIsoDateAndTimeRecord(e, t) {
+  return { o: e, p: t };
+}
+function interpretTemporalDateTimeFields(e, t, o) {
+  return combineIsoDateAndTimeRecord(
+    calendarDateFromFields(e, t, o),
+    regulateTime(t[pt.D], t[pt.I], t[pt.O], t[pt.S], t[pt.F], t[pt.v], o),
+  );
+}
+function toTemporalDateTime(e, t) {
+  if (isObject(e)) {
+    if (isPlainDateTime(e)) {
+      getTemporalOverflowOption(getOptionsObject(t));
+      const o = getInternalSlotOrThrowForPlainDateTime(e);
+      return createTemporalDateTime(o._, o.U);
+    }
+    if (isZonedDateTime(e)) {
+      const o = getInternalSlotOrThrowForZonedDateTime(e);
+      return (
+        getTemporalOverflowOption(getOptionsObject(t)),
+        createTemporalDateTime(getIsoDateTimeForZonedDateTimeSlot(o), o.U)
+      );
+    }
+    if (isPlainDate(e)) {
+      getTemporalOverflowOption(getOptionsObject(t));
+      const o = getInternalSlotOrThrowForPlainDate(e);
+      return createTemporalDateTime(combineIsoDateAndTimeRecord(o.o, midnightTimeRecord()), o.U);
+    }
+    const o = getTemporalCalendarIdentifierWithIsoDefault(e);
+    return createTemporalDateTime(
+      interpretTemporalDateTimeFields(
+        o,
+        prepareCalendarFields(
+          o,
+          e,
+          [pt.t, pt.u, pt.P, pt.T, pt.D, pt.I, pt.O, pt.S, pt.F, pt.v],
+          [],
+        ),
+        getTemporalOverflowOption(getOptionsObject(t)),
+      ),
+      o,
+    );
+  }
+  validateString(e);
+  const o = parseIsoDateTime(e, [et]),
+    n = canonicalizeCalendar(o.U || "iso8601");
+  return (
+    getTemporalOverflowOption(getOptionsObject(t)),
+    createTemporalDateTime(
+      combineIsoDateAndTimeRecord(createIsoDateRecord(o.t, o.u, o.T), o.p || midnightTimeRecord()),
+      n,
+    )
+  );
+}
+function balanceIsoDateTime(e, t, o, n, r, a, i, l, c) {
+  const s = balanceTime(n, r, a, i, l, c);
+  return combineIsoDateAndTimeRecord(addDaysToIsoDate(createIsoDateRecord(e, t, o), s.K), s);
+}
+function createTemporalDateTime(e, t, o = Object.create(Me.prototype)) {
+  const n = ((e, t) => ({ _: e, U: t }))(validateIsoDateTime(e), t);
+  return (Ne.set(o, n), o);
+}
+function isoDateTimeToString(e, t, o, n) {
+  return `${padIsoYear(e.o.t)}-${toZeroPaddedDecimalString(e.o.u, 2)}-${toZeroPaddedDecimalString(e.o.T, 2)}T${formatTimeString(e.p.D, e.p.I, e.p.O, 1e6 * e.p.S + 1e3 * e.p.F + e.p.v, o)}${formatCalendarAnnotation(t, n)}`;
+}
+function compareIsoDateTime(e, t) {
+  return compareIsoDate(e.o, t.o) || compareTimeRecord(e.p, t.p);
+}
+function roundIsoDateTime(e, t, o, n) {
+  const r = roundTime(e.p, t, o, n);
+  return combineIsoDateAndTimeRecord(addDaysToIsoDate(e.o, r.K), r);
+}
+function differenceISODateTime(e, t, o, n) {
+  let r = differenceTime(e.p, t.p);
+  const a = St(r);
+  let i = t.o;
+  a === compareIsoDate(e.o, t.o) &&
+    ((i = addDaysToIsoDate(i, a)), (r = add24HourDaysToTimeDuration(r, -a)));
+  const l = largerOfTwoTemporalUnits(q, n),
+    c = calendarDateUntil(o, e.o, i, l);
+  return (
+    n !== l && ((r = add24HourDaysToTimeDuration(r, c.K)), (c.K = 0)),
+    combineDateAndTimeDuration(c, r)
+  );
+}
+function differencePlainDateTimeWithRounding(e, t, o, n, r, a, i) {
+  if (!compareIsoDateTime(e, t))
+    return combineDateAndTimeDuration(zeroDateDuration(), createTimeDurationFromSeconds(0));
+  (validateIsoDateTime(e), validateIsoDateTime(t));
+  const l = differenceISODateTime(e, t, o, n);
+  return a === Q && 1 === r
+    ? l
+    : roundRelativeDuration(
+        l,
+        getUtcEpochNanoseconds(e),
+        getUtcEpochNanoseconds(t),
+        e,
+        void 0,
+        o,
+        n,
+        r,
+        a,
+        i,
+      );
+}
+function differenceTemporalPlainDateTime(e, t, n, r) {
+  const a = getInternalSlotOrThrowForPlainDateTime(toTemporalDateTime(n));
+  calendarEquals(t.U, a.U) || throwRangeError(fe);
+  const i = getDifferenceSettings(e, getOptionsObject(r), o, [], Q, q);
+  return compareIsoDateTime(t._, a._)
+    ? createTemporalDuration(
+        applySignToDurationSlot(
+          temporalDurationFromInternal(
+            differencePlainDateTimeWithRounding(t._, a._, t.U, i.V, i.H, i.L, i.B),
+            i.V,
+          ),
+          e,
+        ),
+      )
+    : createTemporalDuration(createTemporalDurationSlot(0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
+}
+function addDurationToDateTime(e, t, o, n) {
+  const r = applySignToDurationSlot(toTemporalDuration(o), e),
+    a = getTemporalOverflowOption(getOptionsObject(n)),
+    i = toInternalDurationRecordWith24HourDays(r),
+    l = addTime(t._.p, i.p);
+  return createTemporalDateTime(
+    combineIsoDateAndTimeRecord(
+      calendarDateAdd(t.U, t._.o, adjustDateDurationRecord(i.W, l.K), a),
+      l,
+    ),
+    t.U,
+  );
+}
+function validateIsoDateTime(e) {
+  return (
+    ((e) => {
+      const t = isoDateRecordToEpochDays(e.o);
+      return (
+        Math.abs(t) <= 1e8 || (-100000001 === t && !!compareTimeRecord(e.p, midnightTimeRecord()))
+      );
+    })(e) || throwRangeError(pe),
+    e
+  );
+}
+function getInternalSlotForPlainDateTime(e) {
+  return Ne.get(e);
+}
+function getInternalSlotOrThrowForPlainDateTime(e) {
+  const t = getInternalSlotForPlainDateTime(e);
+  return (t || throwTypeError(Ie), t);
+}
+function isPlainDateTime(e) {
+  return !!getInternalSlotForPlainDateTime(e);
+}
+function createTimeRecord(e, t, o, n, r, a, i = 0) {
+  return { D: e, I: t, O: o, S: n, F: r, v: a, K: i };
+}
+function midnightTimeRecord() {
+  return createTimeRecord(0, 0, 0, 0, 0, 0);
+}
+function differenceTime(e, t) {
+  return timeDurationFromComponents(
+    t.D - e.D,
+    t.I - e.I,
+    t.O - e.O,
+    t.S - e.S,
+    t.F - e.F,
+    t.v - e.v,
+  );
+}
+function toTemporalTime(e, t) {
+  if (isObject(e))
+    return isPlainTime(e)
+      ? (getTemporalOverflowOption(getOptionsObject(t)),
+        createTemporalTime(getInternalSlotOrThrowForPlainTime(e)))
+      : isPlainDateTime(e)
+        ? (getTemporalOverflowOption(getOptionsObject(t)),
+          createTemporalTime(getInternalSlotOrThrowForPlainDateTime(e)._.p))
+        : isZonedDateTime(e)
+          ? (getTemporalOverflowOption(getOptionsObject(t)),
+            createTemporalTime(
+              getIsoDateTimeForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(e)).p,
+            ))
+          : createTemporalTime(
+              regulateTime(
+                ...toTemporalTimeRecord(e),
+                getTemporalOverflowOption(getOptionsObject(t)),
+              ),
+            );
+  validateString(e);
+  const o = parseIsoDateTime(e, [ot]);
+  return (getTemporalOverflowOption(getOptionsObject(t)), createTemporalTime(o.p));
+}
+function toTimeRecordOrMidnight(e) {
+  return void 0 === e
+    ? midnightTimeRecord()
+    : getInternalSlotOrThrowForPlainTime(toTemporalTime(e));
+}
+function regulateTime(e, t, o, n, r, a, i) {
+  return i === l
+    ? createTimeRecord(
+        clamp(e, 0, 23),
+        clamp(t, 0, 59),
+        clamp(o, 0, 59),
+        clamp(n, 0, 999),
+        clamp(r, 0, 999),
+        clamp(a, 0, 999),
+      )
+    : (isValidTime(e, t, o, n, r, a) || throwRangeError(De), createTimeRecord(e, t, o, n, r, a));
+}
+function isValidTime(e, t, o, n, r, a) {
+  return (
+    isWithin(e, 0, 23) &&
+    isWithin(t, 0, 59) &&
+    isWithin(o, 0, 59) &&
+    isWithin(n, 0, 999) &&
+    isWithin(r, 0, 999) &&
+    isWithin(a, 0, 999)
+  );
+}
+function balanceTime(e, t, o, n, r, a) {
+  return (
+    (r += divFloor(a, 1e3)),
+    (n += divFloor(r, 1e3)),
+    (o += divFloor(n, 1e3)),
+    (t += divFloor(o, 60)),
+    {
+      D: modFloor((e += divFloor(t, 60)), 24),
+      I: modFloor(t, 60),
+      O: modFloor(o, 60),
+      S: modFloor(n, 1e3),
+      F: modFloor(r, 1e3),
+      v: modFloor(a, 1e3),
+      K: divFloor(e, 24),
+    }
+  );
+}
+function createTemporalTime(e, t = Object.create(je.prototype)) {
+  return (Ue.set(t, e), t);
+}
+function toTemporalTimeRecord(e, t = !1) {
+  let o = !1;
+  const n = [pt.D, pt.F, pt.S, pt.I, pt.v, pt.O].map((n) => {
+    const r = e[n];
+    return void 0 !== r ? ((o = !0), toIntegerWithTruncation(r)) : t ? void 0 : 0;
+  });
+  return (o || throwTypeError(Fe), [0, 3, 5, 2, 1, 4].map((e) => n[e]));
+}
+function timeRecordToString(e, t) {
+  return formatTimeString(e.D, e.I, e.O, 1e6 * e.S + 1e3 * e.F + e.v, t);
+}
+function compareTimeRecord(e, t) {
+  return (
+    compare(e.D, t.D) ||
+    compare(e.I, t.I) ||
+    compare(e.O, t.O) ||
+    compare(e.S, t.S) ||
+    compare(e.F, t.F) ||
+    compare(e.v, t.v)
+  );
+}
+function addTime(e, t) {
+  const o = t,
+    n = balanceTime(e.D, e.I, e.O, e.S, e.F, e.v + o[1]);
+  return ((n.K += o[0]), n);
+}
+function roundTime(e, t, o, n) {
+  const r = o,
+    a = [e.D, e.I, e.O, e.S, e.F, e.v];
+  let i = 0;
+  for (let e = r === ne ? re : r; e <= se; e++) i += Te[e - 3] * a[e - 4];
+  const l = Te[r - 3],
+    c = roundNumberToIncrement(i, t * l, n) / l;
+  return r === ne
+    ? createTimeRecord(0, 0, 0, 0, 0, 0, c)
+    : balanceTime(...a.slice(0, r - re), c, ...Array.from({ length: se - r }, () => 0));
+}
+function differenceTemporalPlainTime(e, o, n, r) {
+  const a = getInternalSlotOrThrowForPlainTime(toTemporalTime(n)),
+    i = getDifferenceSettings(e, getOptionsObject(r), t, [], Q, J);
+  return createTemporalDuration(
+    applySignToDurationSlot(
+      temporalDurationFromInternal(
+        combineDateAndTimeDuration(
+          zeroDateDuration(),
+          roundTimeDuration(differenceTime(o, a), i.H, i.L, i.B),
+        ),
+        i.V,
+      ),
+      e,
+    ),
+  );
+}
+function addDurationToTime(e, t, o) {
+  return createTemporalTime(
+    addTime(t, toInternalDurationRecord(applySignToDurationSlot(toTemporalDuration(o), e)).p),
+  );
+}
+function getInternalSlotOrThrowForPlainTime(e) {
+  const t = Ue.get(e);
+  return (t || throwTypeError(Ie), t);
+}
+function isPlainTime(e) {
+  return Ue.has(e);
+}
+function optionalChain(e) {
+  return e.reduceRight((e, t) => `${t}(?:${e})?`);
+}
+function join(e, t) {
+  return `${e}(?:${t}${e})*`;
+}
+function createRegExp(e) {
+  return RegExp(`^(?:${e})$`);
+}
+function isAmbiguousTemporalTimeString(e) {
+  for (const t of at) {
+    const o = e.match(t);
+    if (o && isSemanticallyValid(o.groups)) return !0;
+  }
+  return !1;
+}
+function isTimeZoneIdentifier(e) {
+  return it.test(e);
+}
+function parseAnnotationsAndGetCalendar(e) {
+  let t,
+    o = !1;
+  for (const n of e.matchAll(Xe)) {
+    const e = !!n[1];
+    "u-ca" === n[2]
+      ? void 0 === t
+        ? ((t = n[3]), e && (o = !0))
+        : (e || o) && throwRangeError(ue)
+      : e && throwRangeError(ue);
+  }
+  return t;
+}
+function getTimeRecordFromMatchedGroups(e) {
+  const t = (e.g || "").padEnd(9, "0");
+  return createTimeRecord(
+    ye(e.d || 0),
+    ye(e.e || 0),
+    clamp(ye(e.f || 0), 0, 59),
+    ye(t.slice(0, 3)),
+    ye(t.slice(3, 6)),
+    ye(t.slice(6)),
+  );
+}
+function isSemanticallyValid(e) {
+  return (
+    "-000000" !== (e.a || e.l) &&
+    (!e.a || isValidIsoDate(ye(e.a), ye(e.b), ye(e.c))) &&
+    (!e.n || isValidIsoDate(1972, ye(e.m), ye(e.n)))
+  );
+}
+function parseIsoDateTime(e, t) {
+  let o, n;
+  for (const r of t) {
+    const t = e.match(r);
+    if (t && isSemanticallyValid(t.groups) && (r !== ot || !isAmbiguousTemporalTimeString(e))) {
+      ((o = t.groups),
+        (n = parseAnnotationsAndGetCalendar(o.k || "")),
+        o.m && void 0 !== n && "iso8601" !== asciiLowerCase(n) && throwRangeError(ue));
+      break;
+    }
+  }
+  return (
+    o || throwRangeError(ue),
+    {
+      t: mapUnlessUndefined(o.a || o.l, ye),
+      u: ye(o.b || o.m || 1),
+      T: ye(o.c || o.n || 1),
+      p: o.d ? getTimeRecordFromMatchedGroups(o) : void 0,
+      $: { M: !!o.i, N: o.h, Z: o.j },
+      U: n,
+    }
+  );
+}
+function parseDateTimeUtcOffset(e) {
+  const t = e.match(ct);
+  return (
+    t || throwRangeError(ue),
+    ye(`${t[1]}1`) *
+      (36e11 * ye(t[2]) +
+        ye(t[4] || "") * Y +
+        1e9 * ye(t[5] || "") +
+        ye((t[6] || "").padEnd(9, "0")) +
+        0)
+  );
+}
+function hasUtcOffsetSubMinuteParts(e) {
+  const t = e.match(ct);
+  return !(!t || !t[5]);
+}
+function toTemporalMonthDay(e, t) {
+  if (isObject(e)) {
+    const o = getInternalSlotForPlainMonthDay(e);
+    if (o)
+      return (getTemporalOverflowOption(getOptionsObject(t)), createTemporalMonthDay(o.o, o.U));
+    const n = getTemporalCalendarIdentifierWithIsoDefault(e);
+    return createTemporalMonthDay(
+      calendarMonthDayFromFields(
+        n,
+        prepareCalendarFields(n, e, [pt.t, pt.u, pt.P, pt.T], []),
+        getTemporalOverflowOption(getOptionsObject(t)),
+      ),
+      n,
+    );
+  }
+  validateString(e);
+  const o = parseIsoDateTime(e, [nt]),
+    n = canonicalizeCalendar(o.U || "iso8601");
+  return (
+    getTemporalOverflowOption(getOptionsObject(t)),
+    createTemporalMonthDay(
+      "iso8601" === n
+        ? createIsoDateRecord(1972, o.u, o.T)
+        : calendarMonthDayFromFields(
+            n,
+            isoDateToFields(n, validateIsoDate(createIsoDateRecord(o.t, o.u, o.T)), r),
+            l,
+          ),
+      n,
+    )
+  );
+}
+function createTemporalMonthDay(e, t, o = Object.create(dt.prototype)) {
+  return (st.set(o, ((e, t) => ({ o: e, U: t }))(validateIsoDate(e), t)), o);
+}
+function temporalMonthDayToString(e, t) {
+  return `${t === b || t === Z || "iso8601" !== e.U ? `${padIsoYear(e.o.t)}-` : ""}${toZeroPaddedDecimalString(e.o.u, 2)}-${toZeroPaddedDecimalString(e.o.T, 2)}${formatCalendarAnnotation(e.U, t)}`;
+}
+function getInternalSlotForPlainMonthDay(e) {
+  return st.get(e);
+}
+function getInternalSlotOrThrowForPlainMonthDay(e) {
+  const t = getInternalSlotForPlainMonthDay(e);
+  return (t || throwTypeError(Ie), t);
+}
+function isPlainMonthDay(e) {
+  return !!getInternalSlotForPlainMonthDay(e);
+}
+function toTemporalYearMonth(e, t) {
+  if (isObject(e)) {
+    const o = getInternalSlotForPlainYearMonth(e);
+    if (o)
+      return (getTemporalOverflowOption(getOptionsObject(t)), createTemporalYearMonth(o.o, o.U));
+    const n = getTemporalCalendarIdentifierWithIsoDefault(e);
+    return createTemporalYearMonth(
+      calendarYearMonthFromFields(
+        n,
+        prepareCalendarFields(n, e, [pt.t, pt.u, pt.P], []),
+        getTemporalOverflowOption(getOptionsObject(t)),
+      ),
+      n,
+    );
+  }
+  validateString(e);
+  const o = parseIsoDateTime(e, [rt]),
+    r = canonicalizeCalendar(o.U || "iso8601");
+  return (
+    getTemporalOverflowOption(getOptionsObject(t)),
+    createTemporalYearMonth(
+      calendarYearMonthFromFields(
+        r,
+        isoDateToFields(r, validateIsoYearMonth(createIsoDateRecord(o.t, o.u, o.T)), n),
+        l,
+      ),
+      r,
+    )
+  );
+}
+function balanceIsoYearMonth(e, t) {
+  return { t: e + divFloor(t - 1, 12), u: modFloor(t - 1, 12) + 1 };
+}
+function createTemporalYearMonth(e, t, o = Object.create(Tt.prototype)) {
+  return (mt.set(o, ((e, t) => ({ o: e, U: t }))(validateIsoYearMonth(e), t)), o);
+}
+function temporalYearMonthToString(e, t) {
+  return `${padIsoYear(e.o.t)}-${toZeroPaddedDecimalString(e.o.u, 2)}${t === b || t === Z || "iso8601" !== e.U ? `-${toZeroPaddedDecimalString(e.o.T, 2)}` : ""}${formatCalendarAnnotation(e.U, t)}`;
+}
+function differenceTemporalPlainYearMonth(t, o, r, a) {
+  const i = getInternalSlotOrThrowForPlainYearMonth(toTemporalYearMonth(r));
+  calendarEquals(o.U, i.U) || throwRangeError(fe);
+  const c = getDifferenceSettings(t, getOptionsObject(a), e, [B, q], L, x);
+  if (!compareIsoDate(o.o, i.o))
+    return createTemporalDuration(createTemporalDurationSlot(0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
+  const s = calendarDateFromFields(
+      o.U,
+      createNullPrototypeObject({ ...isoDateToFields(o.U, o.o, n), [pt.T]: 1 }),
+      l,
+    ),
+    d = calendarDateFromFields(
+      o.U,
+      createNullPrototypeObject({ ...isoDateToFields(o.U, i.o, n), [pt.T]: 1 }),
+      l,
+    );
+  let m = combineDateAndTimeDuration(
+    adjustDateDurationRecord(calendarDateUntil(o.U, s, d, c.V), 0, 0),
+    createTimeDurationFromSeconds(0),
+  );
+  if (c.L !== L || 1 !== c.H) {
+    const e = combineIsoDateAndTimeRecord(s, midnightTimeRecord());
+    m = roundRelativeDuration(
+      m,
+      getUtcEpochNanoseconds(e),
+      getUtcEpochNanoseconds(combineIsoDateAndTimeRecord(d, midnightTimeRecord())),
+      e,
+      void 0,
+      o.U,
+      c.V,
+      c.H,
+      c.L,
+      c.B,
+    );
+  }
+  return createTemporalDuration(applySignToDurationSlot(temporalDurationFromInternal(m, q), t));
+}
+function addDurationToYearMonth(e, t, o, r) {
+  const a = toInternalDurationRecord(applySignToDurationSlot(toTemporalDuration(o), e)),
+    i = getTemporalOverflowOption(getOptionsObject(r));
+  return (
+    (a.W.X || a.W.K || signTimeDuration(a.p)) &&
+      throwRangeError("duration can contain only years and months"),
+    createTemporalYearMonth(
+      calendarYearMonthFromFields(
+        t.U,
+        isoDateToFields(
+          t.U,
+          calendarDateAdd(
+            t.U,
+            calendarDateFromFields(
+              t.U,
+              createNullPrototypeObject({ ...isoDateToFields(t.U, t.o, n), [pt.T]: 1 }),
+              l,
+            ),
+            a.W,
+            i,
+          ),
+          n,
+        ),
+        i,
+      ),
+      t.U,
+    )
+  );
+}
+function validateIsoYearMonth(e) {
+  return (((e) => isWithin(12 * e.t + e.u, -3261848, 3309129))(e) || throwRangeError(pe), e);
+}
+function getInternalSlotForPlainYearMonth(e) {
+  return mt.get(e);
+}
+function getInternalSlotOrThrowForPlainYearMonth(e) {
+  const t = getInternalSlotForPlainYearMonth(e);
+  return (t || throwTypeError(Ie), t);
+}
+function isPlainYearMonth(e) {
+  return !!getInternalSlotForPlainYearMonth(e);
+}
+function createIsoDateRecord(e, t, o) {
+  return { t: e, u: t, T: o };
+}
+function createTemporalDate(e, t, o = Object.create(Dt.prototype)) {
+  const n = ((e, t) => ({ o: e, U: t }))(validateIsoDate(e), t);
+  return (ut.set(o, n), o);
+}
+function toTemporalDate(e, t) {
+  if (isObject(e)) {
+    if (isPlainDate(e)) {
+      getTemporalOverflowOption(getOptionsObject(t));
+      const o = getInternalSlotOrThrowForPlainDate(e);
+      return createTemporalDate(o.o, o.U);
+    }
+    if (isZonedDateTime(e)) {
+      getTemporalOverflowOption(getOptionsObject(t));
+      const o = getInternalSlotOrThrowForZonedDateTime(e);
+      return createTemporalDate(getIsoDateTimeForZonedDateTimeSlot(o).o, o.U);
+    }
+    if (isPlainDateTime(e)) {
+      getTemporalOverflowOption(getOptionsObject(t));
+      const o = getInternalSlotOrThrowForPlainDateTime(e);
+      return createTemporalDate(o._.o, o.U);
+    }
+    const o = getTemporalCalendarIdentifierWithIsoDefault(e);
+    return createTemporalDate(
+      calendarDateFromFields(
+        o,
+        prepareCalendarFields(o, e, [pt.t, pt.u, pt.P, pt.T], []),
+        getTemporalOverflowOption(getOptionsObject(t)),
+      ),
+      o,
+    );
+  }
+  validateString(e);
+  const o = parseIsoDateTime(e, [et]),
+    n = canonicalizeCalendar(o.U || "iso8601");
+  return (
+    getTemporalOverflowOption(getOptionsObject(t)),
+    createTemporalDate(createIsoDateRecord(o.t, o.u, o.T), n)
+  );
+}
+function regulateIsoDate(e, t, o, n) {
+  return n === l
+    ? createIsoDateRecord(e, (t = clamp(t, 1, 12)), clamp(o, 1, isoDaysInMonth(e, t)))
+    : (isValidIsoDate(e, t, o) || throwRangeError(pe), createIsoDateRecord(e, t, o));
+}
+function isValidIsoDate(e, t, o) {
+  return isWithin(t, 1, 12) && isWithin(o, 1, isoDaysInMonth(e, t));
+}
+function addDaysToIsoDate(e, t) {
+  return epochDaysToIsoDate(isoDateToEpochDays(e.t, e.u - 1, e.T + t));
+}
+function padIsoYear(e) {
+  return isWithin(e, 0, 9999)
+    ? toZeroPaddedDecimalString(e, 4)
+    : `${e < 0 ? "-" : "+"}${toZeroPaddedDecimalString(Math.abs(e), 6)}`;
+}
+function temporalDateToString(e, t) {
+  return `${padIsoYear(e.o.t)}-${toZeroPaddedDecimalString(e.o.u, 2)}-${toZeroPaddedDecimalString(e.o.T, 2)}${formatCalendarAnnotation(e.U, t)}`;
+}
+function compareIsoDate(e, t) {
+  return compare(isoDateRecordToEpochDays(e), isoDateRecordToEpochDays(t));
+}
+function differenceTemporalPlainDate(t, o, n, r) {
+  const a = getInternalSlotOrThrowForPlainDate(toTemporalDate(n));
+  calendarEquals(o.U, a.U) || throwRangeError(fe);
+  const i = getDifferenceSettings(t, getOptionsObject(r), e, [], q, q);
+  if (!compareIsoDate(o.o, a.o))
+    return createTemporalDuration(createTemporalDurationSlot(0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
+  let l = combineDateAndTimeDuration(
+    calendarDateUntil(o.U, o.o, a.o, i.V),
+    createTimeDurationFromSeconds(0),
+  );
+  if (i.L !== q || 1 !== i.H) {
+    const e = combineIsoDateAndTimeRecord(o.o, midnightTimeRecord());
+    l = roundRelativeDuration(
+      l,
+      getUtcEpochNanoseconds(e),
+      getUtcEpochNanoseconds(combineIsoDateAndTimeRecord(a.o, midnightTimeRecord())),
+      e,
+      void 0,
+      o.U,
+      i.V,
+      i.H,
+      i.L,
+      i.B,
+    );
+  }
+  return createTemporalDuration(applySignToDurationSlot(temporalDurationFromInternal(l, q), t));
+}
+function addDurationToDate(e, t, o, n) {
+  return createTemporalDate(
+    calendarDateAdd(
+      t.U,
+      t.o,
+      ((e) => {
+        const t = toInternalDurationRecordWith24HourDays(e);
+        return createDateDurationRecord(t.W.ee, t.W.te, t.W.X, t.p[0]);
+      })(applySignToDurationSlot(toTemporalDuration(o), e)),
+      getTemporalOverflowOption(getOptionsObject(n)),
+    ),
+    t.U,
+  );
+}
+function getInternalSlotForPlainDate(e) {
+  return ut.get(e);
+}
+function getInternalSlotOrThrowForPlainDate(e) {
+  const t = getInternalSlotForPlainDate(e);
+  return (t || throwTypeError(Ie), t);
+}
+function isPlainDate(e) {
+  return !!getInternalSlotForPlainDate(e);
+}
+function validateIsoDate(e) {
+  return (
+    validateIsoDateTime(combineIsoDateAndTimeRecord(e, createTimeRecord(12, 0, 0, 0, 0, 0))), e
+  );
+}
+function canonicalizeCalendar(e) {
+  return (
+    (e = asciiLowerCase(e)),
+    ["iso8601", "gregory"].includes(e) ||
+      throwRangeError(((e) => `calendar not supported in this polyfill: ${e}`)(e)),
+    e
+  );
+}
+function parseMonthCode(e) {
+  const t = toPrimitive(e);
+  validateString(t);
+  const o = t.match(/M(\d\d)(L?)/);
+  return ((o && "M00" !== t) || throwRangeError(`invalid month code:${t}`), [ye(o[1]), !!o[2]]);
+}
+function createMonthCode(e, t = !1) {
+  return `M${toZeroPaddedDecimalString(e, 2)}${t ? "L" : ""}`;
+}
+function prepareCalendarFields(e, t, o, n) {
+  o = [...o, ...calendarExtraFields(e, o)].sort();
+  const r = createEmptyCalendarFieldsRecord();
+  let a = !1;
+  for (const e of o) {
+    const o = t[e];
+    void 0 !== o
+      ? ((a = !0), (r[e] = gt[e][0](o)))
+      : n && (n.includes(e) && throwTypeError(missingField(e)), (r[e] = gt[e][1]));
+  }
+  return (n || a || throwTypeError(Fe), r);
+}
+function calendarFieldKeysPresent(e) {
+  return ht.filter((t) => void 0 !== e[t]);
+}
+function calendarMergeFields(e, t, o) {
+  const n = calendarFieldKeysPresent(o),
+    r = ((e, t) => {
+      const o = [];
+      for (const n of t)
+        (n === pt.u && o.push(pt.P),
+          n === pt.P && o.push(pt.u),
+          calendarSupportsEra(e) && [pt.oe, pt.ne, pt.t].includes(n) && o.push(pt.oe, pt.ne, pt.t));
+      return o;
+    })(e, n),
+    a = createEmptyCalendarFieldsRecord(),
+    i = calendarFieldKeysPresent(t);
+  for (const e of ht)
+    (i.includes(e) && !r.includes(e) && (a[e] = t[e]), n.includes(e) && (a[e] = o[e]));
+  return a;
+}
+function calendarDateAdd(e, t, o, n) {
+  const r = balanceIsoYearMonth(t.t + o.ee, t.u + o.te);
+  return validateIsoDate(addDaysToIsoDate(regulateIsoDate(r.t, r.u, t.T, n), 7 * o.X + o.K));
+}
+function calendarDateUntil(e, t, o, n) {
+  const r = compareIsoDate(o, t);
+  if (!r) return zeroDateDuration();
+  if (n === B || n === q) {
+    const e = isoDateToEpochDays(o.t, o.u - 1, o.T) - isoDateToEpochDays(t.t, t.u - 1, t.T);
+    return n === B
+      ? createDateDurationRecord(0, 0, divTrunc(e, 7) + 0, (e % 7) + 0)
+      : createDateDurationRecord(0, 0, 0, e);
+  }
+  const a = 12 * o.t + o.u - 12 * t.t - t.u - (r * (t.T - o.T) > 0 ? r : 0),
+    i = balanceIsoYearMonth(t.t, t.u + a),
+    c = isoDateRecordToEpochDays(o) - isoDateRecordToEpochDays(regulateIsoDate(i.t, i.u, t.T, l));
+  return n === x
+    ? createDateDurationRecord(divTrunc(a, 12), (a % 12) + 0, 0, c)
+    : createDateDurationRecord(0, a, 0, c);
+}
+function toTemporalCalendarIdentifier(e) {
+  const t =
+    getInternalSlotForPlainDate(e) ||
+    getInternalSlotForPlainDateTime(e) ||
+    getInternalSlotForPlainMonthDay(e) ||
+    getInternalSlotForPlainYearMonth(e) ||
+    getInternalSlotForZonedDateTime(e);
+  return t
+    ? t.U
+    : (validateString(e),
+      canonicalizeCalendar(
+        ((e) => {
+          try {
+            return parseIsoDateTime(e, [Qe, et, tt, ot, nt, rt]).U || "iso8601";
+          } catch {
+            return (lt.test(e) || throwRangeError(ue), e);
+          }
+        })(e),
+      ));
+}
+function getTemporalCalendarIdentifierWithIsoDefault(e) {
+  const t =
+    getInternalSlotForPlainDate(e) ||
+    getInternalSlotForPlainDateTime(e) ||
+    getInternalSlotForPlainMonthDay(e) ||
+    getInternalSlotForPlainYearMonth(e) ||
+    getInternalSlotForZonedDateTime(e);
+  if (t) return t.U;
+  const o = e.calendar;
+  return void 0 === o ? "iso8601" : toTemporalCalendarIdentifier(o);
+}
+function calendarDateFromFields(e, t, o) {
+  return (calendarResolveFields(e, t), validateIsoDate(calendarDateToISO(e, t, o)));
+}
+function calendarYearMonthFromFields(e, t, o) {
+  return (
+    (t.day = 1), calendarResolveFields(e, t, n), validateIsoYearMonth(calendarDateToISO(e, t, o))
+  );
+}
+function calendarMonthDayFromFields(e, t, o) {
+  return (
+    calendarResolveFields(e, t, r),
+    ((e, t, o) => {
+      const n = regulateIsoDate(t[pt.t] ?? 1972, t[pt.u], t[pt.T], o);
+      return createIsoDateRecord(1972, n.u, n.T);
+    })(0, t, o)
+  );
+}
+function formatCalendarAnnotation(e, t) {
+  return t === R || (t === P && "iso8601" === e) ? "" : `[${t === Z ? "!" : ""}u-ca=${e}]`;
+}
+function calendarEquals(e, t) {
+  return e === t;
+}
+function isoDaysInMonth(e, t) {
+  return isoDateToEpochDays(e, t, 1) - isoDateToEpochDays(e, t - 1, 1);
+}
+function isoWeeksInYear(e) {
+  return 4 === isoDayOfWeek(createIsoDateRecord(e, 1, 1)) ||
+    4 === isoDayOfWeek(createIsoDateRecord(e, 12, 31))
+    ? 53
+    : 52;
+}
+function isoWeekOfYear(e) {
+  const t = e.t,
+    o = divFloor(isoDayOfYear(e) + 10 - isoDayOfWeek(e), 7);
+  return o < 1
+    ? { t: t - 1, re: isoWeeksInYear(t - 1) }
+    : o > isoWeeksInYear(t)
+      ? { t: t + 1, re: 1 }
+      : { t: t, re: o };
+}
+function isoDayOfYear(e) {
+  return isoDateRecordToEpochDays(e) - isoDateToEpochDays(e.t, 0, 0);
+}
+function isoDayOfWeek(e) {
+  return modFloor(isoDateRecordToEpochDays(e) + 3, 7) + 1;
+}
+function calendarDateToISO(e, t, o) {
+  return regulateIsoDate(t[pt.t], t[pt.u], t[pt.T], o);
+}
+function isoCalendarIsoToDate(e) {
+  return {
+    t: e.t,
+    u: e.u,
+    P: createMonthCode(e.u),
+    T: e.T,
+    ae: isoDayOfWeek(e),
+    ie: isoDayOfYear(e),
+    le: isoWeekOfYear(e),
+    ce: 7,
+    se: isoDaysInMonth(e.t, e.u),
+    de: ((t = e.t), 365 + mathematicalInLeapYear(t)),
+    me: 12,
+    ue: !!mathematicalInLeapYear(e.t),
+  };
+  var t;
+}
+function calendarIsoToDate(e, t) {
+  return "iso8601" === e
+    ? isoCalendarIsoToDate(t)
+    : ((e, t) => ({
+        oe: t.t > 0 ? "ce" : "bce",
+        ne: t.t > 0 ? t.t : 1 - t.t,
+        ...isoCalendarIsoToDate(t),
+        le: { t: void 0, re: void 0 },
+      }))(0, t);
+}
+function calendarExtraFields(e, t) {
+  return calendarSupportsEra(e) && t.includes("year") ? ["era", "eraYear"] : [];
+}
+function isoResolveFields(e, t) {
+  (t !== r && void 0 === e[pt.t] && throwTypeError(missingField(pt.t)),
+    t !== n && void 0 === e[pt.T] && throwTypeError(missingField(pt.T)),
+    void 0 === e[pt.P] && void 0 === e[pt.u] && throwTypeError(missingField("month, monthCode")));
+  const o = mapUnlessUndefined(e[pt.P], parseMonthCode);
+  o &&
+    ((o[0] > 12 || o[1] || (void 0 !== e[pt.u] && o[0] !== e[pt.u])) &&
+      throwRangeError("mismatch of `month` and `monthCode`"),
+    (e[pt.u] = o[0]));
+}
+function nonIsoResolveFields(t, o, a = e) {
+  const i = o[pt.oe],
+    l = o[pt.ne],
+    c = o[pt.t],
+    s = o[pt.P],
+    d = o[pt.u],
+    m = o[pt.T];
+  if (
+    ((a === r && void 0 !== s && void 0 === d) ||
+      void 0 !== c ||
+      (calendarSupportsEra(t) && void 0 !== i && void 0 !== l) ||
+      throwTypeError(missingField("year, era, eraYear")),
+    calendarSupportsEra(t) && (void 0 === i) != (void 0 === l) && throwTypeError(),
+    a !== n && void 0 === m && throwTypeError(missingField("day")),
+    d === s && throwTypeError(missingField("month, monthCode")),
+    calendarSupportsEra(t) && void 0 !== l)
+  ) {
+    const e = ((e, t, o) => ("ce" === canonicalizeEraInCalendar(e, t) ? o : 1 - o))(
+      t,
+      canonicalizeEraInCalendar(t, i),
+      l,
+    );
+    (void 0 !== c && c !== e && throwRangeError("mismatch of `year`, `era` and `eraYear`"),
+      (o[pt.t] = e));
+  }
+  return ((o[pt.oe] = o[pt.ne] = void 0), isoResolveFields(o, a));
+}
+function calendarResolveFields(t, o, n = e) {
+  "iso8601" === t ? isoResolveFields(o, n) : nonIsoResolveFields(t, o, n);
+}
+function calendarSupportsEra(e) {
+  return "gregory" === e;
+}
+function canonicalizeEraInCalendar(e, t) {
+  return "ad" === t || "ce" === t
+    ? "ce"
+    : "bc" === t || "bce" === t
+      ? "bce"
+      : void throwRangeError(((e) => `invalid era: ${e}`)(t));
+}
+function createEmptyCalendarFieldsRecord() {
+  return createNullPrototypeObject({});
+}
+function zeroDateDuration() {
+  return createDateDurationRecord(0, 0, 0, 0);
+}
+function toInternalDurationRecord(e) {
+  return combineDateAndTimeDuration(
+    createDateDurationRecord(e[ee], e[te], e[oe], e[ne]),
+    timeDurationFromComponents(e[re], e[ae], e[ie], e[le], e[ce], e[se]),
+  );
+}
+function toInternalDurationRecordWith24HourDays([e, t, o, n, ...r]) {
+  return combineDateAndTimeDuration(
+    createDateDurationRecord(e, t, o, 0),
+    add24HourDaysToTimeDuration(timeDurationFromComponents(...r), n),
+  );
+}
+function temporalDurationFromInternal(e, t) {
+  const [o, ...n] = balanceTimeDuration(e.p, t);
+  return createTemporalDurationSlot(e.W.ee, e.W.te, e.W.X, e.W.K + o, ...n);
+}
+function createDateDurationRecord(e, t, o, n) {
+  return (validateDuration(e, t, o, n, 0, 0, 0, 0, 0, 0), { ee: e, te: t, X: o, K: n });
+}
+function adjustDateDurationRecord(e, t, o = e.X, n = e.te) {
+  return createDateDurationRecord(e.ee, n, o, t);
+}
+function combineDateAndTimeDuration(e, t) {
+  return { W: e, p: t };
+}
+function toTemporalDuration(e) {
+  return (
+    (t = e),
+    Ot.has(t)
+      ? getInternalSlotOrThrowForDuration(e)
+      : isObject(e)
+        ? createTemporalDurationSlot(...toTemporalPartialDurationRecord(e).map((e) => e || 0))
+        : (validateString(e),
+          ((e) => {
+            const t = (e = asciiLowerCase(e)).match(
+              /^([+-]?)p(?:(\d+)y)?(?:(\d+)m)?(?:(\d+)w)?(?:(\d+)d)?(?:t(?:(\d+)(?:[.,](\d{1,9}))?h)?(?:(\d+)(?:[.,](\d{1,9}))?m)?(?:(\d+)(?:[.,](\d{1,9}))?s)?)?$/,
+            );
+            (t && !/[pt]$|[.,](\d{1,9})[hms]./.test(e)) || throwRangeError(ue);
+            const o = balanceTime(
+              0,
+              0,
+              0,
+              0,
+              0,
+              3600 * toIntegerWithTruncation((t[7] || "").padEnd(9, "0")) +
+                60 * toIntegerWithTruncation((t[9] || "").padEnd(9, "0")) +
+                toIntegerWithTruncation((t[11] || "").padEnd(9, "0")),
+            );
+            return applySignToDurationSlot(
+              createTemporalDurationSlot(
+                toIntegerWithTruncation(t[2] || ""),
+                toIntegerWithTruncation(t[3] || ""),
+                toIntegerWithTruncation(t[4] || ""),
+                toIntegerWithTruncation(t[5] || ""),
+                toIntegerWithTruncation(t[6] || ""),
+                toIntegerWithTruncation(t[8] || "") + o.I,
+                toIntegerWithTruncation(t[10] || "") + o.O,
+                o.S,
+                o.F,
+                o.v,
+              ),
+              toIntegerWithTruncation(`${t[1]}1`),
+            );
+          })(e))
+  );
+  var t;
+}
+function durationSign(e) {
+  return sign(e.find((e) => 0 !== e) || 0);
+}
+function dateDurationSign(e) {
+  return sign(e.ee || e.te || e.X || e.K);
+}
+function internalDurationSign(e) {
+  return dateDurationSign(e.W) || St(e.p);
+}
+function validateDuration(...e) {
+  (e.some((e) => e < 0) && e.some((e) => e > 0) && throwRangeError("invalid duration"),
+    (e.every((e) => Math.abs(e) < 1e25) &&
+      Math.abs(e[ee]) < 2 ** 32 &&
+      Math.abs(e[te]) < 2 ** 32 &&
+      Math.abs(e[oe]) < 2 ** 32) ||
+      throwRangeError(he),
+    validateTimeDurationRange(
+      timeDurationFromComponents(24 * e[ne] + e[re], e[ae], e[ie], e[le], e[ce], e[se]),
+    ));
+}
+function defaultTemporalLargestUnit(e) {
+  return (e.findIndex((e) => 0 !== e) + 10) % 10;
+}
+function toTemporalPartialDurationRecord(e) {
+  isObject(e) || throwTypeError(notObject(e));
+  const t = [3, 4, 8, 7, 5, 1, 9, 6, 2, 0].map((t) =>
+    mapUnlessUndefined(e[me[t]], toIntegerIfIntegral),
+  );
+  return (
+    t.every((e) => void 0 === e) && throwTypeError(Fe),
+    [9, 5, 8, 0, 1, 4, 7, 3, 2, 6].map((e) => t[e])
+  );
+}
+function createTemporalDurationSlot(...e) {
+  return (validateDuration(...e), e);
+}
+function createTemporalDuration(e, t = Object.create(Ft.prototype)) {
+  return (Ot.set(t, e), t);
+}
+function timeDurationFromComponents(e, t, o, n, r, a) {
+  return addTimeDuration(
+    addTimeDuration(
+      addTimeDuration(
+        createTimeDurationFromSeconds(3600 * e + 60 * t + o),
+        normalize(divTrunc((c = n), z), (c % z) * 1e6),
+      ),
+      ((l = r), normalize(Math.round((l - (l % V)) / V), (l % V) * 1e3)),
+    ),
+    ((i = a), normalize(Math.round((i - (i % k)) / k), i % k)),
+  );
+  var i, l, c;
+}
+function add24HourDaysToTimeDuration(e, t) {
+  return validateTimeDurationRange(((e, t) => normalize(e[0] + t, e[1]))(e, t));
+}
+function timeDurationFromEpochNanosecondsDifference(e, t) {
+  return differenceEpochNanoseconds(t, e);
+}
+function roundTimeDurationToIncrement(e, t, o) {
+  return validateTimeDurationRange(
+    ((e, t, o) => normalize(e[0], roundNumberToIncrement(e[1], t, o)))(e, t, o),
+  );
+}
+function dateDurationDays(e, t) {
+  const o = adjustDateDurationRecord(e, 0);
+  return dateDurationSign(e)
+    ? e.K +
+        isoDateRecordToEpochDays(calendarDateAdd(t.U, t.o, o, l)) -
+        isoDateRecordToEpochDays(t.o)
+    : e.K;
+}
+function roundTimeDuration(e, t, o, n) {
+  return roundTimeDurationToIncrement(e, nanosecondsForTimeUnit(o) * t, n);
+}
+function totalTimeDuration(e, t) {
+  return divideTimeDurationToFloatingPoint(e, nanosecondsForTimeUnit(t));
+}
+function computeNudgeWindow(e, t, o, n, r, a, i, c, d) {
+  let m, T, u, D, p;
+  if (c === x)
+    ((m = roundNumberToIncrement(t.W.ee, i, S) + (d ? i * e : 0)),
+      (T = m + i * e),
+      (u = createDateDurationRecord(m, 0, 0, 0)),
+      (D = createDateDurationRecord(T, 0, 0, 0)));
+  else if (c === L)
+    ((m = roundNumberToIncrement(t.W.te, i, S) + (d ? i * e : 0)),
+      (T = m + i * e),
+      (u = adjustDateDurationRecord(t.W, 0, 0, m)),
+      (D = adjustDateDurationRecord(t.W, 0, 0, T)));
+  else if (c === B) {
+    const o = calendarDateAdd(0, n.o, adjustDateDurationRecord(t.W, 0, 0), l);
+    ((m = roundNumberToIncrement(
+      t.W.X + calendarDateUntil(0, o, addDaysToIsoDate(o, t.W.K), B).X,
+      i,
+      S,
+    )),
+      (T = m + i * e),
+      (u = adjustDateDurationRecord(t.W, 0, m)),
+      (D = adjustDateDurationRecord(t.W, 0, T)));
+  } else
+    ((m = roundNumberToIncrement(t.W.K, i, S)),
+      (T = m + i * e),
+      (u = adjustDateDurationRecord(t.W, m)),
+      (D = adjustDateDurationRecord(t.W, T)));
+  if (0 === m) p = o;
+  else {
+    const e = combineIsoDateAndTimeRecord(calendarDateAdd(0, n.o, u, l), n.p);
+    p = r ? getEpochNanosecondsFor(r, e, s) : getUtcEpochNanoseconds(e);
+  }
+  const h = combineIsoDateAndTimeRecord(calendarDateAdd(0, n.o, D, l), n.p);
+  return {
+    Te: m,
+    De: T,
+    pe: p,
+    he: r ? getEpochNanosecondsFor(r, h, s) : getUtcEpochNanoseconds(h),
+    ge: u,
+    fe: D,
+  };
+}
+function nudgeToCalendarUnit(e, t, o, n, r, a, i, l, c, s) {
+  let d = !1,
+    m = computeNudgeWindow(e, t, o, r, a, 0, l, c, !1);
+  compareEpochNanoseconds(m.pe, n) * compareEpochNanoseconds(m.he, n) > 0 &&
+    ((m = computeNudgeWindow(e, t, o, r, a, 0, l, c, !0)), (d = !0));
+  const T = differenceEpochNanoseconds(m.pe, n),
+    u = differenceEpochNanoseconds(m.pe, m.he);
+  let D = m.ge,
+    p = m.pe;
+  return (
+    roundNumberToIncrement(
+      m.Te +
+        ((e, t, o) =>
+          signTimeDuration(e) ? (Ee(e, t) ? (Ee(addTimeDuration(e, e), t) * o) / 5 + 0.5 : 1) : 0)(
+          T,
+          u,
+          e,
+        ) *
+          l *
+          e,
+      l,
+      s,
+    ) === m.De && ((d = !0), (D = m.fe), (p = m.he)),
+    {
+      Ie: { Oe: combineDateAndTimeDuration(D, createTimeDurationFromSeconds(0)), Se: p, Fe: d },
+      we:
+        m.Te +
+        (divideTimeDurationToFloatingPoint(T, 1e9) / divideTimeDurationToFloatingPoint(u, 1e9)) *
+          l *
+          e,
+    }
+  );
+}
+function roundRelativeDuration(e, t, o, n, r, a, i, c, d, m) {
+  const T = internalDurationSign(e) || 1,
+    u =
+      isCalendarUnit(d) || (r && d === q)
+        ? nudgeToCalendarUnit(T, e, t, o, n, r, 0, c, d, m).Ie
+        : r
+          ? ((e, t, o, n, r, a, i, c) => {
+              const d = calendarDateAdd(0, o.o, t.W, l),
+                m = combineIsoDateAndTimeRecord(d, o.p),
+                T = combineIsoDateAndTimeRecord(addDaysToIsoDate(d, e), o.p),
+                u = getEpochNanosecondsFor(n, m, s),
+                D = getEpochNanosecondsFor(n, T, s),
+                p = timeDurationFromEpochNanosecondsDifference(D, u),
+                h = nanosecondsForTimeUnit(i);
+              let g = roundTimeDurationToIncrement(t.p, a * h, c);
+              const f = addTimeDuration(g, negateTimeDuration(p));
+              let I,
+                O = !1,
+                S = 0;
+              return (
+                St(f) !== -e
+                  ? ((O = !0),
+                    (S = e),
+                    (g = roundTimeDurationToIncrement(f, a * h, c)),
+                    (I = addTimeDurationToEpochNanoseconds(D, g)))
+                  : (I = addTimeDurationToEpochNanoseconds(D, g)),
+                {
+                  Oe: combineDateAndTimeDuration(adjustDateDurationRecord(t.W, t.W.K + S), g),
+                  Se: I,
+                  Fe: O,
+                }
+              );
+            })(T, e, n, r, 0, c, d, m)
+          : (function (e, t, o, n, r, a) {
+              const i = add24HourDaysToTimeDuration(e.p, e.W.K),
+                l =
+                  r === q
+                    ? roundTimeDurationByDays(i, n, a)
+                    : roundTimeDurationToIncrement(i, nanosecondsForTimeUnit(r) * n, a),
+                c = l[0],
+                [s, d] = isDateUnit(o)
+                  ? [c, addTimeDuration(l, timeDurationFromComponents(24 * -c, 0, 0, 0, 0, 0))]
+                  : [0, l];
+              return {
+                Oe: combineDateAndTimeDuration(adjustDateDurationRecord(e.W, s), d),
+                Se: addTimeDurationToEpochNanoseconds(t, addTimeDuration(l, negateTimeDuration(i))),
+                Fe: sign(c - i[0]) === St(i),
+              };
+            })(e, o, i, c, d, m);
+  return u.Fe && d !== B
+    ? ((e, t, o, n, r, a, i, c) => {
+        if (c === i) return t;
+        const d = i;
+        let m;
+        for (let a = c - 1; a >= d; a--)
+          if (a !== oe || d === oe) {
+            m =
+              a === ee
+                ? createDateDurationRecord(t.W.ee + e, 0, 0, 0)
+                : a === te
+                  ? adjustDateDurationRecord(t.W, 0, 0, t.W.te + e)
+                  : adjustDateDurationRecord(t.W, 0, t.W.X + e);
+            const i = combineIsoDateAndTimeRecord(calendarDateAdd(0, n.o, m, l), n.p);
+            if (
+              St(
+                differenceEpochNanoseconds(
+                  r ? getEpochNanosecondsFor(r, i, s) : getUtcEpochNanoseconds(i),
+                  o,
+                ),
+              ) === -e
+            )
+              break;
+            t = combineDateAndTimeDuration(m, createTimeDurationFromSeconds(0));
+          }
+        return t;
+      })(T, u.Oe, u.Se, n, r, 0, i, largerOfTwoTemporalUnits(d, q))
+    : u.Oe;
+}
+function totalRelativeDuration(e, t, o, n, r, a, i) {
+  return isCalendarUnit(i) || (r && i === q)
+    ? nudgeToCalendarUnit(internalDurationSign(e) || 1, e, t, o, n, r, 0, 1, i, S).we
+    : totalTimeDuration(add24HourDaysToTimeDuration(e.p, e.W.K), i);
+}
+function temporalDurationToString(e, t) {
+  const o = durationSign(e),
+    n = timeDurationFromComponents(
+      0,
+      0,
+      (e = applySignToDurationSlot(e, o))[ie],
+      e[le],
+      e[ce],
+      e[se],
+    ),
+    [, , , r, a, i, l] = balanceTimeDuration(n, G),
+    [c, s, d, m, T, u] = ["Y", "M", "W", "D", "H", "M"].map((t, o) => (e[o] ? `${e[o]}${t}` : "")),
+    D = `${T}${u}${St(n) || largerOfTwoTemporalUnits(defaultTemporalLargestUnit(e), G) === G || void 0 !== t ? `${toString(r)}${formatFractionalSeconds(1e6 * a + 1e3 * i + l, t)}S` : ""}`;
+  return `${o < 0 ? "-" : ""}P${c}${s}${d}${m}${D && `T${D}`}`;
+}
+function addDurations(e, t, o) {
+  const n = applySignToDurationSlot(toTemporalDuration(o), e),
+    r = largerOfTwoTemporalUnits(defaultTemporalLargestUnit(t), defaultTemporalLargestUnit(n));
+  return (
+    isCalendarUnit(r) && throwRangeError(durationWithDateUnit(r)),
+    createTemporalDuration(
+      temporalDurationFromInternal(
+        combineDateAndTimeDuration(
+          zeroDateDuration(),
+          addTimeDuration(
+            toInternalDurationRecordWith24HourDays(t).p,
+            toInternalDurationRecordWith24HourDays(n).p,
+          ),
+        ),
+        r,
+      ),
+    )
+  );
+}
+function getInternalSlotOrThrowForDuration(e) {
+  const t = Ot.get(e);
+  return (t || throwTypeError(Ie), t);
+}
+function applySignToDurationSlot(e, t) {
+  return createTemporalDurationSlot(...e.map((e) => e * t + 0));
+}
+function validateTimeDurationRange(e) {
+  return (((e) => 1 !== Ee(absTimeDuration(e), ft))(e) || throwRangeError(he), e);
+}
+function balanceTimeDuration(e, t) {
+  const o = e[1],
+    n = (o % 1e3) + 0,
+    r = (divTrunc(o, 1e3) % 1e3) + 0,
+    a = (divTrunc(o, 1e6) % 1e3) + 0,
+    i = (l = e)[0] * W + divTrunc(l[1], 1e9);
+  var l;
+  const c = (i % 60) + 0,
+    s = divTrunc(i, 60),
+    d = (s % 60) + 0,
+    m = divTrunc(s, 60),
+    T = (m % 24) + 0,
+    u = divTrunc(m, 24);
+  return t === Q
+    ? [0, 0, 0, 0, 0, 0, timeDurationToSubsecondsNumber(e, -9)]
+    : t === X
+      ? [0, 0, 0, 0, 0, timeDurationToSubsecondsNumber(e, -6), n]
+      : t === _
+        ? [0, 0, 0, 0, timeDurationToSubsecondsNumber(e, -3), r, n]
+        : t === G
+          ? [0, 0, 0, i, a, r, n]
+          : t === K
+            ? [0, 0, s, c, a, r, n]
+            : t === J
+              ? [0, m, d, c, a, r, n]
+              : [u, T, d, c, a, r, n];
+}
+function isIntegerAndHalf(e) {
+  return Math.abs(e) % 1 == 0.5;
+}
+function roundExpand(e) {
+  return (e < 0 ? Math.floor(e) : Math.ceil(e)) + 0;
+}
+function roundHalfCeil(e) {
+  return (isIntegerAndHalf(e) ? Math.ceil(e) : Math.round(e)) + 0;
+}
+function roundHalfFloor(e) {
+  return (isIntegerAndHalf(e) ? Math.floor(e) : Math.round(e)) + 0;
+}
+function roundHalfEven(e) {
+  return (isIntegerAndHalf(e) ? (e = Math.trunc(e)) + (e % 2) : Math.round(e)) + 0;
+}
+function isoDateToEpochDays(e, t, o) {
+  const n = balanceIsoYearMonth(e, t + 1);
+  return Date.UTC((n.t % 400) - 400, n.u - 1, 0) / z + (divTrunc(n.t, 400) + 1) * H + o;
+}
+function isoDateRecordToEpochDays(e) {
+  return isoDateToEpochDays(e.t, e.u - 1, e.T);
+}
+function mathematicalInLeapYear(e) {
+  return +!(e % (e % 25 ? 4 : 16));
+}
+function getTemporalOverflowOption(e) {
+  return getOption(e, "overflow", [l, c], l);
+}
+function getTemporalDisambiguationOption(e) {
+  return getOption(e, "disambiguation", [s, "earlier", d, m], s);
+}
+function negateRoundingMode(e) {
+  return e === f ? I : e === I ? f : e === F ? w : e === w ? F : e;
+}
+function getTemporalOffsetOption(e, t) {
+  return getOption(e, "offset", [T, "use", u, D], t);
+}
+function getTemporalShowCalendarNameOption(e) {
+  return getOption(e, "calendarName", [P, b, R, Z], P);
+}
+function validateTemporalRoundingIncrement(e, t, o) {
+  (e > (o ? t : t - 1) || t % e !== 0) && throwRangeError(invalidField("roundingIncrement"));
+}
+function getTemporalFractionalSecondDigitsOption(e) {
+  const t = "fractionalSecondDigits",
+    o = e[t];
+  if (void 0 === o) return;
+  if ("number" != typeof o)
+    return void ("auto" !== toString(o) && throwRangeError(invalidField(t)));
+  (!isNaN(o) && isFinite(o)) || throwRangeError(invalidField(t));
+  const n = Math.floor(o);
+  return ((n < 0 || n > 9) && throwRangeError(invalidField(t)), n);
+}
+function toSecondsStringPrecisionRecord(e, t) {
+  return void 0 !== e
+    ? { ve: e === K ? i : e === G ? 0 : e === _ ? 3 : e === X ? 6 : 9, ye: e, Ee: 1 }
+    : void 0 === t
+      ? { ve: void 0, ye: Q, Ee: 1 }
+      : 0 === t
+        ? { ve: 0, ye: G, Ee: 1 }
+        : isWithin(t, 1, 3)
+          ? { ve: t, ye: _, Ee: 10 ** (3 - t) }
+          : isWithin(t, 4, 6)
+            ? { ve: t, ye: X, Ee: 10 ** (6 - t) }
+            : { ve: t, ye: Q, Ee: 10 ** (9 - t) };
+}
+function getTemporalUnitValuedOption(e, t, o) {
+  return mapUnlessUndefined(getOption(e, t, [...de, ...me, "auto"], o), (e) => {
+    return "auto" === e ? "auto" : ((t = e.replace(/s$/, "")), de.indexOf(t));
+    var t;
+  });
+}
+function validateTemporalUnitValue(o, n, r = []) {
+  void 0 === o ||
+    r.includes(o) ||
+    ("auto" === o && throwRangeError(disallowedUnit(o)),
+    ((o <= q && n === t) || (o > q && n === e)) && throwRangeError(disallowedUnit(o)));
+}
+function getTemporalRelativeToOption(e) {
+  const t = e.relativeTo;
+  if (void 0 === t) return createNullPrototypeObject({});
+  let o,
+    n,
+    r,
+    a,
+    i,
+    c = !0,
+    d = p;
+  if (isObject(t)) {
+    if (isZonedDateTime(t))
+      return createNullPrototypeObject({ Pe: getInternalSlotOrThrowForZonedDateTime(t) });
+    if (isPlainDate(t))
+      return createNullPrototypeObject({ be: getInternalSlotOrThrowForPlainDate(t) });
+    const e = getInternalSlotForPlainDateTime(t);
+    if (e)
+      return createNullPrototypeObject({
+        be: getInternalSlotOrThrowForPlainDate(createTemporalDate(e._.o, e.U)),
+      });
+    r = getTemporalCalendarIdentifierWithIsoDefault(t);
+    const c = prepareCalendarFields(
+        r,
+        t,
+        [pt.t, pt.u, pt.P, pt.T, pt.D, pt.I, pt.O, pt.S, pt.F, pt.v, pt.R, pt.$],
+        [],
+      ),
+      s = interpretTemporalDateTimeFields(r, c, l);
+    ((a = s.o), (i = s.p), (o = c.timeZone), (n = c.offset), (d = n ? p : g));
+  } else {
+    validateString(t);
+    const e = parseIsoDateTime(t, [Qe, et]);
+    ((n = e.$.N),
+      e.$.Z
+        ? ((o = toTemporalTimeZoneIdentifier(e.$.Z)),
+          (d = e.$.M ? h : n ? p : g),
+          (c = void 0 !== n && hasUtcOffsetSubMinuteParts(n)))
+        : (o = void 0),
+      (r = canonicalizeCalendar(e.U || "iso8601")),
+      (a = createIsoDateRecord(e.t, e.u, e.T)),
+      (i = e.p));
+  }
+  return createNullPrototypeObject(
+    o
+      ? {
+          Pe: getInternalSlotOrThrowForZonedDateTime(
+            createTemporalZonedDateTime(
+              interpretISODateTimeOffset(
+                a,
+                i,
+                d,
+                d === p ? parseDateTimeUtcOffset(n) : 0,
+                o,
+                s,
+                D,
+                c,
+              ),
+              o,
+              r,
+            ),
+          ),
+        }
+      : { be: getInternalSlotOrThrowForPlainDate(createTemporalDate(a, r)) },
+  );
+}
+function largerOfTwoTemporalUnits(e, t) {
+  return e < t ? e : t;
+}
+function isCalendarUnit(e) {
+  return e < q;
+}
+function isDateUnit(e) {
+  return e <= q;
+}
+function maximumTemporalDurationRoundingIncrement(e) {
+  return [void 0, void 0, void 0, void 0, 24, 60, 60, 1e3, 1e3, 1e3][e];
+}
+function validatePartialTemporalObject(e) {
+  (!isObject(e) ||
+    isPlainDate(e) ||
+    isPlainDateTime(e) ||
+    isPlainMonthDay(e) ||
+    isPlainTime(e) ||
+    isPlainYearMonth(e) ||
+    isZonedDateTime(e) ||
+    void 0 !== e.calendar ||
+    void 0 !== e.timeZone) &&
+    throwTypeError("invalid argument for `with` method");
+}
+function formatFractionalSeconds(e, t) {
+  const o = toZeroPaddedDecimalString(e, 9);
+  return void 0 === t
+    ? 0 === e
+      ? ""
+      : `.${o.replace(/0*$/, "")}`
+    : 0 === t
+      ? ""
+      : `.${o.slice(0, t)}`;
+}
+function formatTimeString(e, t, o, n, r) {
+  const a = toZeroPaddedDecimalString(e, 2),
+    l = toZeroPaddedDecimalString(t, 2);
+  return r === i
+    ? `${a}:${l}`
+    : `${a}:${l}:${toZeroPaddedDecimalString(o, 2)}${formatFractionalSeconds(n, r)}`;
+}
+function roundNumberToIncrement(e, t, o) {
+  return wt[o](e / t) * t;
+}
+function getRoundingModeOption(e, t) {
+  return getOption(e, "roundingMode", [f, I, O, S, F, w, v, y, E], t);
+}
+function getRoundingIncrementOption(e) {
+  const t = "roundingIncrement",
+    o = e[t],
+    n = void 0 === o ? 1 : toIntegerWithTruncation(o);
+  return ((n < 1 || n > 1e9) && throwRangeError(invalidField(t)), n);
+}
+function isoDateToFields(e, t, o) {
+  const a = calendarIsoToDate(e, t);
+  return createNullPrototypeObject({
+    [pt.t]: o === r ? void 0 : a.t,
+    [pt.P]: a.P,
+    [pt.T]: o === n ? void 0 : a.T,
+  });
+}
+function getDifferenceSettings(e, t, o, n, r, a) {
+  let i = getTemporalUnitValuedOption(t, "largestUnit", void 0) ?? "auto";
+  const l = getRoundingIncrementOption(t),
+    c = getRoundingModeOption(t, S),
+    s = getTemporalUnitValuedOption(t, "smallestUnit", void 0) ?? r;
+  return (
+    validateTemporalUnitValue(i, o, ["auto"]),
+    n.includes(i) && throwRangeError(disallowedUnit(i)),
+    validateTemporalUnitValue(s, o),
+    n.includes(s) && throwRangeError(disallowedUnit(s)),
+    "auto" === i && (i = largerOfTwoTemporalUnits(a, s)),
+    largerOfTwoTemporalUnits(i, s) !== i && throwRangeError(Oe),
+    isDateUnit(s) ||
+      validateTemporalRoundingIncrement(l, maximumTemporalDurationRoundingIncrement(s), !1),
+    { L: s, V: i, B: -1 === e ? negateRoundingMode(c) : c, H: l }
+  );
+}
+function getUtcEpochNanoseconds(e) {
+  return addNanosecondsToEpochSeconds(
+    createEpochNanosecondsFromEpochMilliseconds(
+      utcEpochMilliseconds(e.o.t, e.o.u, e.o.T, e.p.D, e.p.I, e.p.O, e.p.S),
+    ),
+    1e3 * e.p.F + e.p.v,
+  );
+}
+function epochDaysToIsoDate(e) {
+  const t = new Date(modFloor(e, H) * z);
+  return {
+    t: t.getUTCFullYear() + 400 * divFloor(e, H),
+    u: t.getUTCMonth() + 1,
+    T: t.getUTCDate(),
+  };
+}
+function isoDateTimeToFields(t, o) {
+  return createNullPrototypeObject({
+    ...isoDateToFields(t, o.o, e),
+    [pt.D]: o.p.D,
+    [pt.I]: o.p.I,
+    [pt.O]: o.p.O,
+    [pt.S]: o.p.S,
+    [pt.F]: o.p.F,
+    [pt.v]: o.p.v,
+  });
+}
+function getInternalSlotOrThrowForDateTimeFormat(e) {
+  const t = Pt.get(e);
+  return (t || throwTypeError(Ie), t);
+}
+function formatDateTime(e, t) {
+  const [o, n] = handleDateTimeValue(getInternalSlotOrThrowForDateTimeFormat(e), t);
+  return o.format(n);
+}
+function removeDateTimeFormatOptions(e, t) {
+  for (const o of t) e[o] = void 0;
+}
+function dateStyleToMonthStyle(e) {
+  return "short" === e ? "numeric" : "medium" === e ? "short" : "long";
+}
+function amendOptionsForPlainDate(e) {
+  const t = createNullPrototypeObject(e);
+  return (
+    hasAnyOptions(e, bt) ||
+      (hasAnyOptions(e, Rt) && throwTypeError(ge), (t.year = t.month = t.day = "numeric")),
+    removeDateTimeFormatOptions(t, [...Rt, "timeZoneName"]),
+    (t.timeZone = "UTC"),
+    t
+  );
+}
+function amendOptionsForPlainTime(e) {
+  const t = createNullPrototypeObject(e);
+  return (
+    hasAnyOptions(e, Rt) ||
+      (hasAnyOptions(e, bt) && throwTypeError(ge), (t.hour = t.minute = t.second = "numeric")),
+    ("long" !== e.timeStyle && "full" !== e.timeStyle) ||
+      (removeDateTimeFormatOptions(t, ["timeStyle"]), (t.hour = t.minute = t.second = "numeric")),
+    removeDateTimeFormatOptions(t, [...bt, "era", "timeZoneName"]),
+    (t.timeZone = "UTC"),
+    t
+  );
+}
+function amendOptionsForPlainDateTime(e) {
+  const t = createNullPrototypeObject(e);
+  return (
+    ("long" !== e.timeStyle && "full" !== e.timeStyle) ||
+      (removeDateTimeFormatOptions(t, ["timeStyle"]),
+      (t.hour = t.minute = t.second = "numeric"),
+      e.dateStyle &&
+        (removeDateTimeFormatOptions(t, ["dateStyle"]),
+        (t.year = t.day = "numeric"),
+        (t.month = dateStyleToMonthStyle(e.dateStyle)),
+        (t.weekday = "full" === e.dateStyle ? "long" : void 0))),
+    hasAnyOptions(e, [...bt, ...Rt]) ||
+      (t.year = t.month = t.day = t.hour = t.minute = t.second = "numeric"),
+    removeDateTimeFormatOptions(t, ["timeZoneName"]),
+    (t.timeZone = "UTC"),
+    t
+  );
+}
+function amendOptionsForPlainYearMonth(e) {
+  const t = createNullPrototypeObject(e);
+  return (
+    e.dateStyle &&
+      (removeDateTimeFormatOptions(t, ["dateStyle"]),
+      (t.year = "short" === e.dateStyle ? "2-digit" : "numeric"),
+      (t.month = dateStyleToMonthStyle(e.dateStyle))),
+    hasAnyOptions(e, ["year", "month", "dateStyle"]) ||
+      (hasAnyOptions(e, [...bt, ...Rt]) && throwTypeError(ge), (t.year = t.month = "numeric")),
+    removeDateTimeFormatOptions(t, [...Rt, "day", "weekday", "timeZoneName"]),
+    (t.timeZone = "UTC"),
+    t
+  );
+}
+function amendOptionsForPlainMonthDay(e) {
+  const t = createNullPrototypeObject(e);
+  return (
+    e.dateStyle &&
+      (removeDateTimeFormatOptions(t, ["dateStyle"]),
+      (t.month = dateStyleToMonthStyle(e.dateStyle)),
+      (t.day = "numeric")),
+    hasAnyOptions(e, ["month", "day", "dateStyle"]) ||
+      (hasAnyOptions(e, [...bt, ...Rt]) && throwTypeError(ge), (t.month = t.day = "numeric")),
+    removeDateTimeFormatOptions(t, [...Rt, "era", "year", "weekday", "timeZoneName"]),
+    (t.timeZone = "UTC"),
+    t
+  );
+}
+function amendOptionsForInstant(e) {
+  const t = createNullPrototypeObject(e);
+  return (
+    hasAnyOptions(e, [...bt, ...Rt]) ||
+      (t.year = t.month = t.day = t.hour = t.minute = t.second = "numeric"),
+    t
+  );
+}
+function hasAnyOptions(e, t) {
+  return t.some((t) => void 0 !== e[t]);
+}
+function createDateTimeFormat(
+  o,
+  n = createNullPrototypeObject({}),
+  r,
+  a,
+  i = Object.create(Nt.prototype),
+) {
+  null === n && throwTypeError(ge);
+  const l = ((e, t) => {
+    const o = createNullPrototypeObject({});
+    for (const n of t) o[n] = e[n];
+    return o;
+  })(Object(n), Et);
+  ((l.hour12 = mapUnlessUndefined(l.hour12, toBoolean)),
+    (l.hourCycle = mapUnlessUndefined(l.hourCycle, toString)),
+    (l.formatMatcher = mapUnlessUndefined(l.formatMatcher, toString)),
+    void 0 !== a &&
+      (void 0 !== l.timeZone && throwTypeError("disallowed field: timeZone"),
+      (l.timeZone = a),
+      hasAnyOptions(l, [...bt, ...Rt, "timeZoneName"]) || (l.timeZoneName = "short")));
+  const c = new yt(o, l),
+    s = c.resolvedOptions(),
+    d = createNullPrototypeObject(s);
+  for (const e of Object.keys(d)) void 0 === l[e] && (d[e] = void 0);
+  var m;
+  return (
+    (d.hour12 = l.hour12),
+    (d.hourCycle = l.hourCycle),
+    (d.formatMatcher = l.formatMatcher),
+    (d.timeZone = s.timeZone),
+    (d.calendar = s.calendar),
+    ((r === e && d.timeStyle) || (r === t && d.dateStyle)) && throwTypeError(ge),
+    Pt.set(i, createNullPrototypeObject({ Re: (m = c), $e: d, Ze: m.resolvedOptions().locale })),
+    i
+  );
+}
+function validateSameTemporalType(e, t) {
+  [
+    isPlainDate,
+    isPlainTime,
+    isPlainDateTime,
+    isZonedDateTime,
+    isInstant,
+    isPlainYearMonth,
+    isPlainMonthDay,
+  ].some((o) => o(e) !== o(t)) && throwTypeError("Temporal type mismatch");
+}
+function toDateTimeFormattable(e) {
+  return ((e) =>
+    isObject(e) &&
+    (isPlainDate(e) ||
+      isPlainTime(e) ||
+      isPlainDateTime(e) ||
+      isZonedDateTime(e) ||
+      isPlainYearMonth(e) ||
+      isPlainMonthDay(e) ||
+      isInstant(e)))(e)
+    ? e
+    : ye(e);
+}
+function handleDateTimeValue(e, t) {
+  const o = getInternalSlotForPlainDate(t),
+    n = getInternalSlotForPlainDateTime(t),
+    r = getInternalSlotForPlainYearMonth(t),
+    a = getInternalSlotForPlainMonthDay(t);
+  return isPlainTime(t)
+    ? [
+        (e.Ne ||= new yt(e.Ze, amendOptionsForPlainTime(e.$e))),
+        epochMilliseconds(
+          getUtcEpochNanoseconds(
+            combineIsoDateAndTimeRecord(
+              createIsoDateRecord(1970, 1, 1),
+              getInternalSlotOrThrowForPlainTime(t),
+            ),
+          ),
+        ),
+      ]
+    : o
+      ? (o.U !== e.$e.calendar && "iso8601" !== o.U && throwRangeError(fe),
+        [
+          (e.Me ||= new yt(e.Ze, amendOptionsForPlainDate(e.$e))),
+          epochMilliseconds(
+            getUtcEpochNanoseconds(combineIsoDateAndTimeRecord(o.o, midnightTimeRecord())),
+          ),
+        ])
+      : n
+        ? (n.U !== e.$e.calendar && "iso8601" !== n.U && throwRangeError(fe),
+          [
+            (e.Ue ||= new yt(e.Ze, amendOptionsForPlainDateTime(e.$e))),
+            epochMilliseconds(getUtcEpochNanoseconds(n._)),
+          ])
+        : r
+          ? (r.U !== e.$e.calendar && throwRangeError(fe),
+            [
+              (e.je ||= new yt(e.Ze, amendOptionsForPlainYearMonth(e.$e))),
+              epochMilliseconds(
+                getUtcEpochNanoseconds(combineIsoDateAndTimeRecord(r.o, midnightTimeRecord())),
+              ),
+            ])
+          : a
+            ? (a.U !== e.$e.calendar && throwRangeError(fe),
+              [
+                (e.Ce ||= new yt(e.Ze, amendOptionsForPlainMonthDay(e.$e))),
+                epochMilliseconds(
+                  getUtcEpochNanoseconds(combineIsoDateAndTimeRecord(a.o, midnightTimeRecord())),
+                ),
+              ])
+            : isInstant(t)
+              ? [
+                  (e.Ye ||= new yt(e.Ze, amendOptionsForInstant(e.$e))),
+                  epochMilliseconds(getInternalSlotOrThrowForInstant(t).Y),
+                ]
+              : (isZonedDateTime(t) && throwTypeError(Se), [e.Re, t]);
+}
+function DateTimeFormat(e, t) {
+  return new Nt(e, t);
+}
+function createTemporalInstant(e, t = Object.create(Ct.prototype)) {
+  const o = { Y: e };
+  return ($t.set(t, o), t);
+}
+function toTemporalInstant$1(e) {
+  if (isObject(e)) {
+    const t = getInternalSlotForInstant(e) || getInternalSlotForZonedDateTime(e);
+    if (t) return createTemporalInstant(t.Y);
+    e = toPrimitive(e);
+  }
+  validateString(e);
+  const t = parseIsoDateTime(e, [tt]),
+    o = t.$.M ? 0 : parseDateTimeUtcOffset(t.$.N),
+    n = t.p;
+  return createTemporalInstant(
+    validateEpochNanoseconds(
+      getUtcEpochNanoseconds(balanceIsoDateTime(t.t, t.u, t.T, n.D, n.I, n.O, n.S, n.F, n.v - o)),
+    ),
+  );
+}
+function addInstant(e, t) {
+  return validateEpochNanoseconds(addTimeDurationToEpochNanoseconds(e, t));
+}
+function differenceInstant(e, t, o, n, r) {
+  return combineDateAndTimeDuration(
+    zeroDateDuration(),
+    roundTimeDuration(timeDurationFromEpochNanosecondsDifference(t, e), o, n, r),
+  );
+}
+function roundTemporalInstant(e, t, o, n) {
+  return (function (e, t, o) {
+    return normalizeEpochNanoseconds(e[0], ((e, t, o) => vt[o](e / t) * t)(e[1], t, o));
+  })(e, t * nanosecondsForTimeUnit(o), n);
+}
+function temporalInstantToString(e, t, o) {
+  const n = getOffsetNanosecondsFor(void 0 === t ? "UTC" : t, e);
+  return `${isoDateTimeToString(getIsoDateTimeFromOffsetNanoseconds(e, n), "iso8601", o, R)}${void 0 === t ? "Z" : formatDateTimeUtcOffsetRounded(n)}`;
+}
+function differenceTemporalInstant(e, o, n, r) {
+  const a = getInternalSlotOrThrowForInstant(toTemporalInstant$1(n)),
+    i = getDifferenceSettings(e, getOptionsObject(r), t, [], Q, G);
+  return createTemporalDuration(
+    applySignToDurationSlot(
+      temporalDurationFromInternal(differenceInstant(o.Y, a.Y, i.H, i.L, i.B), i.V),
+      e,
+    ),
+  );
+}
+function addDurationToInstant(e, t, o) {
+  const n = applySignToDurationSlot(toTemporalDuration(o), e);
+  return (
+    isDateUnit(defaultTemporalLargestUnit(n)) &&
+      throwRangeError(durationWithDateUnit(defaultTemporalLargestUnit(n))),
+    createTemporalInstant(addInstant(t.Y, toInternalDurationRecordWith24HourDays(n).p))
+  );
+}
+function validateEpochNanoseconds(e) {
+  return (
+    ((e) => compareEpochNanoseconds(Ut, e) * compareEpochNanoseconds(jt, e) <= 0)(e) ||
+      throwRangeError(pe),
+    e
+  );
+}
+function getInternalSlotForInstant(e) {
+  return $t.get(e);
+}
+function getInternalSlotOrThrowForInstant(e) {
+  const t = getInternalSlotForInstant(e);
+  return (t || throwTypeError(Ie), t);
+}
+function isInstant(e) {
+  return $t.has(e);
+}
+function clampEpochNanoseconds(e) {
+  return compareEpochNanoseconds(e, jt) > 0 ? jt : compareEpochNanoseconds(e, Ut) < 0 ? Ut : e;
+}
+function systemTimeZoneIdentifier() {
+  return new yt().resolvedOptions().timeZone;
+}
+function systemUtcEpochNanoseconds() {
+  return createEpochNanosecondsFromEpochMilliseconds(Date.now());
+}
+function systemDateTime(e) {
+  return getIsoDateTimeForZonedDateTimeSlot(
+    createZonedDateTimeSlot(
+      systemUtcEpochNanoseconds(),
+      void 0 === e ? systemTimeZoneIdentifier() : toTemporalTimeZoneIdentifier(e),
+      "iso8601",
+    ),
+  );
+}
+const e = Symbol(),
+  t = Symbol(),
+  o = Symbol(),
+  n = Symbol(),
+  r = Symbol(),
+  a = Symbol(),
+  i = Symbol(),
+  l = "constrain",
+  c = "reject",
+  s = "compatible",
+  d = "later",
+  m = "reject",
+  T = "prefer",
+  u = "ignore",
+  D = "reject",
+  p = Symbol(),
+  h = Symbol(),
+  g = Symbol(),
+  f = "ceil",
+  I = "floor",
+  O = "expand",
+  S = "trunc",
+  F = "halfCeil",
+  w = "halfFloor",
+  v = "halfExpand",
+  y = "halfTrunc",
+  E = "halfEven",
+  P = "auto",
+  b = "always",
+  R = "never",
+  Z = "critical",
+  N = "auto",
+  M = "never",
+  U = "auto",
+  j = "never",
+  $ = "critical",
+  C = 1e6,
+  Y = 6e10,
+  A = 36e11,
+  W = 86400,
+  z = 864e5,
+  V = 864e8,
+  k = 864e11,
+  H = 146097,
+  x = 0,
+  L = 1,
+  B = 2,
+  q = 3,
+  J = 4,
+  K = 5,
+  G = 6,
+  _ = 7,
+  X = 8,
+  Q = 9,
+  ee = 0,
+  te = 1,
+  oe = 2,
+  ne = 3,
+  re = 4,
+  ae = 5,
+  ie = 6,
+  le = 7,
+  ce = 8,
+  se = 9,
+  de = [
+    "year",
+    "month",
+    "week",
+    "day",
+    "hour",
+    "minute",
+    "second",
+    "millisecond",
+    "microsecond",
+    "nanosecond",
+  ],
+  me = de.map((e) => `${e}s`),
+  Te = [864e11, 36e11, Y, 1e9, 1e6, 1e3, 1],
+  missingField = (e) => `missing field: ${e}`,
+  invalidField = (e) => `invalid field: ${e}`,
+  ue = "parse error",
+  De = "invalid date / time",
+  pe = "out-of-bounds date",
+  he = "out-of-bounds duration",
+  ge = "invalid formatting options",
+  fe = "calendar mismatch",
+  disallowedUnit = (e) => `disallowed unit: ${"auto" === e ? e : getNameFromUnit(e)}`,
+  invalidNumber = (e) => `invalid number: ${e}`,
+  invalidTimeZone = (e) => `invalid time zone: ${e}`,
+  Ie = "invalid method call",
+  durationWithDateUnit = (e) => `duration has a date unit: ${getNameFromUnit(e)}`,
+  Oe = "invalid `largestUnit` and `smallestUnit` options",
+  Se = "value is not formattable",
+  notObject = (e) => `not object: ${e}`,
+  Fe = "empty fields",
+  we = "can't convert Temporal classes to number",
+  ve = "argument is undefined",
+  ye = Math.max,
+  Ee = compareEpochNanoseconds,
+  Pe = new WeakMap();
+var be = class {
+  constructor(e, t, o = "iso8601") {
+    const n = validateEpochNanoseconds(createEpochNanosecondsFromBigInt(toBigInt(e)));
+    validateString(t);
+    const r = parseTimeZoneIdentifier(t),
+      a = r.J ? getAvailableNamedTimeZoneIdentifier(r.J) : formatOffsetTimeZoneIdentifier(r.G);
+    (validateString(o), createTemporalZonedDateTime(n, a, canonicalizeCalendar(o), this));
+  }
+  static from(e, t = void 0) {
+    return toTemporalZonedDateTime(e, t);
+  }
+  static compare(e, t) {
+    return compareEpochNanoseconds(
+      getInternalSlotOrThrowForZonedDateTime(toTemporalZonedDateTime(e)).Y,
+      getInternalSlotOrThrowForZonedDateTime(toTemporalZonedDateTime(t)).Y,
+    );
+  }
+  get calendarId() {
+    return getInternalSlotOrThrowForZonedDateTime(this).U;
+  }
+  get timeZoneId() {
+    return getInternalSlotOrThrowForZonedDateTime(this).$;
+  }
+  get era() {
+    return calendarIsoToDateForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).oe;
+  }
+  get eraYear() {
+    return calendarIsoToDateForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).ne;
+  }
+  get year() {
+    return calendarIsoToDateForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).t;
+  }
+  get month() {
+    return calendarIsoToDateForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).u;
+  }
+  get monthCode() {
+    return calendarIsoToDateForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).P;
+  }
+  get day() {
+    return calendarIsoToDateForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).T;
+  }
+  get hour() {
+    return getIsoDateTimeForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).p.D;
+  }
+  get minute() {
+    return getIsoDateTimeForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).p.I;
+  }
+  get second() {
+    return getIsoDateTimeForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).p.O;
+  }
+  get millisecond() {
+    return getIsoDateTimeForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).p.S;
+  }
+  get microsecond() {
+    return getIsoDateTimeForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).p.F;
+  }
+  get nanosecond() {
+    return getIsoDateTimeForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).p.v;
+  }
+  get epochMilliseconds() {
+    return epochMilliseconds(getInternalSlotOrThrowForZonedDateTime(this).Y);
+  }
+  get epochNanoseconds() {
+    return convertEpochNanosecondsToBigInt(getInternalSlotOrThrowForZonedDateTime(this).Y);
+  }
+  get dayOfWeek() {
+    return calendarIsoToDateForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).ae;
+  }
+  get dayOfYear() {
+    return calendarIsoToDateForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).ie;
+  }
+  get weekOfYear() {
+    return calendarIsoToDateForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).le
+      .re;
+  }
+  get yearOfWeek() {
+    return calendarIsoToDateForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).le.t;
+  }
+  get hoursInDay() {
+    const e = getInternalSlotOrThrowForZonedDateTime(this),
+      t = getIsoDateTimeForZonedDateTimeSlot(e).o;
+    return (
+      timeDurationToSubsecondsNumber(
+        differenceEpochNanoseconds(
+          getStartOfDay(e.$, t),
+          getStartOfDay(e.$, addDaysToIsoDate(t, 1)),
+        ),
+        -9,
+      ) / A
+    );
+  }
+  get daysInWeek() {
+    return calendarIsoToDateForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).ce;
+  }
+  get daysInMonth() {
+    return calendarIsoToDateForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).se;
+  }
+  get daysInYear() {
+    return calendarIsoToDateForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).de;
+  }
+  get monthsInYear() {
+    return calendarIsoToDateForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).me;
+  }
+  get inLeapYear() {
+    return calendarIsoToDateForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).ue;
+  }
+  get offsetNanoseconds() {
+    return getOffsetNanosecondsForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this));
+  }
+  get offset() {
+    return formatUtcOffsetNanoseconds(
+      getOffsetNanosecondsForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)),
+    );
+  }
+  with(e, t = void 0) {
+    const o = getInternalSlotOrThrowForZonedDateTime(this);
+    validatePartialTemporalObject(e);
+    const n = getOffsetNanosecondsForZonedDateTimeSlot(o),
+      r = getIsoDateTimeForZonedDateTimeSlot(o),
+      a = calendarMergeFields(
+        o.U,
+        createNullPrototypeObject({
+          ...isoDateTimeToFields(o.U, r),
+          [pt.R]: formatUtcOffsetNanoseconds(n),
+        }),
+        prepareCalendarFields(o.U, e, [
+          pt.t,
+          pt.u,
+          pt.P,
+          pt.T,
+          pt.D,
+          pt.I,
+          pt.O,
+          pt.S,
+          pt.F,
+          pt.v,
+          pt.R,
+        ]),
+      ),
+      i = getOptionsObject(t),
+      l = getTemporalDisambiguationOption(i),
+      c = getTemporalOffsetOption(i, T),
+      s = getTemporalOverflowOption(i),
+      d = interpretTemporalDateTimeFields(o.U, a, s);
+    return createTemporalZonedDateTime(
+      interpretISODateTimeOffset(d.o, d.p, p, parseDateTimeUtcOffset(a[pt.R]), o.$, l, c, !0),
+      o.$,
+      o.U,
+    );
+  }
+  withPlainTime(e = void 0) {
+    const t = getInternalSlotOrThrowForZonedDateTime(this),
+      o = getIsoDateTimeForZonedDateTimeSlot(t);
+    return createTemporalZonedDateTime(
+      void 0 === e
+        ? getStartOfDay(t.$, o.o)
+        : getEpochNanosecondsFor(
+            t.$,
+            combineIsoDateAndTimeRecord(o.o, getInternalSlotOrThrowForPlainTime(toTemporalTime(e))),
+            s,
+          ),
+      t.$,
+      t.U,
+    );
+  }
+  withTimeZone(e) {
+    const t = getInternalSlotOrThrowForZonedDateTime(this);
+    return createTemporalZonedDateTime(t.Y, toTemporalTimeZoneIdentifier(e), t.U);
+  }
+  withCalendar(e) {
+    const t = getInternalSlotOrThrowForZonedDateTime(this);
+    return createTemporalZonedDateTime(t.Y, t.$, toTemporalCalendarIdentifier(e));
+  }
+  add(e, t = void 0) {
+    return addDurationToZonedDateTime(1, getInternalSlotOrThrowForZonedDateTime(this), e, t);
+  }
+  subtract(e, t = void 0) {
+    return addDurationToZonedDateTime(-1, getInternalSlotOrThrowForZonedDateTime(this), e, t);
+  }
+  until(e, t = void 0) {
+    return differenceTemporalZonedDateTime(1, getInternalSlotOrThrowForZonedDateTime(this), e, t);
+  }
+  since(e, t = void 0) {
+    return differenceTemporalZonedDateTime(-1, getInternalSlotOrThrowForZonedDateTime(this), e, t);
+  }
+  round(e) {
+    const o = getInternalSlotOrThrowForZonedDateTime(this),
+      n = getRoundToOptionsObject(e),
+      r = getRoundingIncrementOption(n),
+      i = getRoundingModeOption(n, "halfExpand"),
+      l = getTemporalUnitValuedOption(n, "smallestUnit", a);
+    if (
+      (validateTemporalUnitValue(l, t, [q]),
+      validateTemporalRoundingIncrement(
+        r,
+        l === q ? 1 : maximumTemporalDurationRoundingIncrement(l),
+        l === q,
+      ),
+      l === Q && 1 === r)
+    )
+      return createTemporalZonedDateTimeFromSlot(o);
+    const c = getIsoDateTimeForZonedDateTimeSlot(o);
+    if (l === q) {
+      const e = getStartOfDay(o.$, c.o),
+        t = getStartOfDay(o.$, addDaysToIsoDate(c.o, 1));
+      return createTemporalZonedDateTime(
+        addNanosecondsToEpochSeconds(
+          e,
+          roundNumberToIncrement(
+            timeDurationToSubsecondsNumber(differenceEpochNanoseconds(e, o.Y), -9),
+            timeDurationToSubsecondsNumber(differenceEpochNanoseconds(e, t), -9),
+            i,
+          ),
+        ),
+        o.$,
+        o.U,
+      );
+    }
+    const d = roundIsoDateTime(c, r, l, i),
+      m = getOffsetNanosecondsForZonedDateTimeSlot(o);
+    return createTemporalZonedDateTime(
+      interpretISODateTimeOffset(d.o, d.p, p, m, o.$, s, T, !0),
+      o.$,
+      o.U,
+    );
+  }
+  equals(e) {
+    const t = getInternalSlotOrThrowForZonedDateTime(this),
+      o = getInternalSlotOrThrowForZonedDateTime(toTemporalZonedDateTime(e));
+    return (
+      !compareEpochNanoseconds(t.Y, o.Y) && timeZoneEquals(t.$, o.$) && calendarEquals(t.U, o.U)
+    );
+  }
+  toString(e = void 0) {
+    const o = getInternalSlotOrThrowForZonedDateTime(this),
+      n = getOptionsObject(e),
+      r = getTemporalShowCalendarNameOption(n),
+      a = getTemporalFractionalSecondDigitsOption(n),
+      i = ((e) => getOption(e, "offset", [N, M], N))(n),
+      l = getRoundingModeOption(n, S),
+      c = getTemporalUnitValuedOption(n, "smallestUnit", void 0),
+      s = ((e) => getOption(e, "timeZoneName", [U, j, $], U))(n);
+    (validateTemporalUnitValue(c, t), c === J && throwRangeError(invalidField("smallestUnit")));
+    const d = toSecondsStringPrecisionRecord(c, a);
+    return temporalZonedDateTimeToString(o, d.ve, r, s, i, d.Ee, d.ye, l);
+  }
+  toLocaleString(e = void 0, t = void 0) {
+    const n = getInternalSlotOrThrowForZonedDateTime(this),
+      r = createDateTimeFormat(e, t, o, n.$),
+      a = getInternalSlotOrThrowForDateTimeFormat(r);
+    return (
+      "iso8601" === n.U || calendarEquals(n.U, a.$e.calendar) || throwRangeError(fe),
+      formatDateTime(r, createTemporalInstant(n.Y))
+    );
+  }
+  toJSON() {
+    return temporalZonedDateTimeToString(
+      getInternalSlotOrThrowForZonedDateTime(this),
+      void 0,
+      P,
+      U,
+      N,
+    );
+  }
+  valueOf() {
+    throwTypeError(we);
+  }
+  startOfDay() {
+    const e = getInternalSlotOrThrowForZonedDateTime(this);
+    return createTemporalZonedDateTime(
+      getStartOfDay(e.$, getIsoDateTimeForZonedDateTimeSlot(e).o),
+      e.$,
+      e.U,
+    );
+  }
+  getTimeZoneTransition(e) {
+    const t = getInternalSlotOrThrowForZonedDateTime(this);
+    void 0 === e && throwTypeError(ve);
+    const o = getOption(
+        "string" == typeof e ? { direction: e } : getOptionsObject(e),
+        "direction",
+        ["next", "previous"],
+        a,
+      ),
+      n = ((e, t, o) => {
+        if ("UTC" === e || isOffsetTimeZoneIdentifier(e)) return null;
+        const n = -4e9,
+          r = Math.floor((Date.now() + 31536e7) / 1e3),
+          a = clamp(epochSeconds(addNanosecondsToEpochSeconds(t, o > 0 ? 0 : -1)), n, 1 / 0);
+        return -1 === o
+          ? a === n
+            ? null
+            : a > r
+              ? searchTimeZoneTransition(e, a, a - 31536e3, o) ||
+                searchTimeZoneTransition(e, r, n, o)
+              : searchTimeZoneTransition(e, a, n, o)
+          : searchTimeZoneTransition(e, a, a > r ? a + 31536e3 : r, o);
+      })(t.$, t.Y, "next" === o ? 1 : -1);
+    return null === n ? null : createTemporalZonedDateTime(n, t.$, t.U);
+  }
+  toInstant() {
+    return createTemporalInstant(getInternalSlotOrThrowForZonedDateTime(this).Y);
+  }
+  toPlainDate() {
+    const e = getInternalSlotOrThrowForZonedDateTime(this);
+    return createTemporalDate(getIsoDateTimeForZonedDateTimeSlot(e).o, e.U);
+  }
+  toPlainTime() {
+    return createTemporalTime(
+      getIsoDateTimeForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).p,
+    );
+  }
+  toPlainDateTime() {
+    const e = getInternalSlotOrThrowForZonedDateTime(this);
+    return createTemporalDateTime(getIsoDateTimeForZonedDateTimeSlot(e), e.U);
+  }
+};
+(defineStringTag(be.prototype, "Temporal.ZonedDateTime"), renameFunction(be, "ZonedDateTime"));
+const Re = createNullPrototypeObject({}),
+  Ze = createNullPrototypeObject({}),
+  Ne = new WeakMap();
+var Me = class {
+  constructor(e, t, o, n = 0, r = 0, a = 0, i = 0, l = 0, c = 0, s = "iso8601") {
+    const d = [e, t, o].map(toIntegerWithTruncation),
+      m = [n, r, a, i, l, c].map(toIntegerWithTruncation);
+    validateString(s);
+    const T = canonicalizeCalendar(s);
+    ((isValidIsoDate(...d) && isValidTime(...m)) || throwRangeError(De),
+      createTemporalDateTime(
+        combineIsoDateAndTimeRecord(createIsoDateRecord(...d), createTimeRecord(...m)),
+        T,
+        this,
+      ));
+  }
+  static from(e, t = void 0) {
+    return toTemporalDateTime(e, t);
+  }
+  static compare(e, t) {
+    return compareIsoDateTime(
+      getInternalSlotOrThrowForPlainDateTime(toTemporalDateTime(e))._,
+      getInternalSlotOrThrowForPlainDateTime(toTemporalDateTime(t))._,
+    );
+  }
+  get calendarId() {
+    return getInternalSlotOrThrowForPlainDateTime(this).U;
+  }
+  get era() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.U, e._.o).oe;
+  }
+  get eraYear() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.U, e._.o).ne;
+  }
+  get year() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.U, e._.o).t;
+  }
+  get month() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.U, e._.o).u;
+  }
+  get monthCode() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.U, e._.o).P;
+  }
+  get day() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.U, e._.o).T;
+  }
+  get hour() {
+    return getInternalSlotOrThrowForPlainDateTime(this)._.p.D;
+  }
+  get minute() {
+    return getInternalSlotOrThrowForPlainDateTime(this)._.p.I;
+  }
+  get second() {
+    return getInternalSlotOrThrowForPlainDateTime(this)._.p.O;
+  }
+  get millisecond() {
+    return getInternalSlotOrThrowForPlainDateTime(this)._.p.S;
+  }
+  get microsecond() {
+    return getInternalSlotOrThrowForPlainDateTime(this)._.p.F;
+  }
+  get nanosecond() {
+    return getInternalSlotOrThrowForPlainDateTime(this)._.p.v;
+  }
+  get dayOfWeek() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.U, e._.o).ae;
+  }
+  get dayOfYear() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.U, e._.o).ie;
+  }
+  get weekOfYear() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.U, e._.o).le.re;
+  }
+  get yearOfWeek() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.U, e._.o).le.t;
+  }
+  get daysInWeek() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.U, e._.o).ce;
+  }
+  get daysInMonth() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.U, e._.o).se;
+  }
+  get daysInYear() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.U, e._.o).de;
+  }
+  get monthsInYear() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.U, e._.o).me;
+  }
+  get inLeapYear() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.U, e._.o).ue;
+  }
+  with(e, t = void 0) {
+    const o = getInternalSlotOrThrowForPlainDateTime(this);
+    validatePartialTemporalObject(e);
+    const n = calendarMergeFields(
+      o.U,
+      isoDateTimeToFields(o.U, o._),
+      prepareCalendarFields(o.U, e, [pt.t, pt.u, pt.P, pt.T, pt.D, pt.I, pt.O, pt.S, pt.F, pt.v]),
+    );
+    return createTemporalDateTime(
+      interpretTemporalDateTimeFields(o.U, n, getTemporalOverflowOption(getOptionsObject(t))),
+      o.U,
+    );
+  }
+  withPlainTime(e = void 0) {
+    const t = getInternalSlotOrThrowForPlainDateTime(this);
+    return createTemporalDateTime(
+      combineIsoDateAndTimeRecord(t._.o, toTimeRecordOrMidnight(e)),
+      t.U,
+    );
+  }
+  withCalendar(e) {
+    return createTemporalDateTime(
+      getInternalSlotOrThrowForPlainDateTime(this)._,
+      toTemporalCalendarIdentifier(e),
+    );
+  }
+  add(e, t = void 0) {
+    return addDurationToDateTime(1, getInternalSlotOrThrowForPlainDateTime(this), e, t);
+  }
+  subtract(e, t = void 0) {
+    return addDurationToDateTime(-1, getInternalSlotOrThrowForPlainDateTime(this), e, t);
+  }
+  until(e, t = void 0) {
+    return differenceTemporalPlainDateTime(1, getInternalSlotOrThrowForPlainDateTime(this), e, t);
+  }
+  since(e, t = void 0) {
+    return differenceTemporalPlainDateTime(-1, getInternalSlotOrThrowForPlainDateTime(this), e, t);
+  }
+  round(e) {
+    const o = getInternalSlotOrThrowForPlainDateTime(this),
+      n = getRoundToOptionsObject(e),
+      r = getRoundingIncrementOption(n),
+      i = getRoundingModeOption(n, "halfExpand"),
+      l = getTemporalUnitValuedOption(n, "smallestUnit", a);
+    return (
+      validateTemporalUnitValue(l, t, [q]),
+      validateTemporalRoundingIncrement(
+        r,
+        l === q ? 1 : maximumTemporalDurationRoundingIncrement(l),
+        l === q,
+      ),
+      createTemporalDateTime(roundIsoDateTime(o._, r, l, i), o.U)
+    );
+  }
+  equals(e) {
+    const t = getInternalSlotOrThrowForPlainDateTime(this),
+      o = getInternalSlotOrThrowForPlainDateTime(toTemporalDateTime(e));
+    return !compareIsoDateTime(t._, o._) && calendarEquals(t.U, o.U);
+  }
+  toString(e = void 0) {
+    const o = getInternalSlotOrThrowForPlainDateTime(this),
+      n = getOptionsObject(e),
+      r = getTemporalShowCalendarNameOption(n),
+      a = getTemporalFractionalSecondDigitsOption(n),
+      i = getRoundingModeOption(n, S),
+      l = getTemporalUnitValuedOption(n, "smallestUnit", void 0);
+    (validateTemporalUnitValue(l, t), l === J && throwRangeError(invalidField("smallestUnit")));
+    const c = toSecondsStringPrecisionRecord(l, a);
+    return isoDateTimeToString(
+      validateIsoDateTime(roundIsoDateTime(o._, c.Ee, c.ye, i)),
+      o.U,
+      c.ve,
+      r,
+    );
+  }
+  toLocaleString(e = void 0, t = void 0) {
+    return (
+      getInternalSlotOrThrowForPlainDateTime(this),
+      formatDateTime(createDateTimeFormat(e, t, o), this)
+    );
+  }
+  toJSON() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return isoDateTimeToString(e._, e.U, void 0, P);
+  }
+  valueOf() {
+    throwTypeError(we);
+  }
+  toZonedDateTime(e, t = void 0) {
+    const o = getInternalSlotOrThrowForPlainDateTime(this),
+      n = toTemporalTimeZoneIdentifier(e),
+      r = getTemporalDisambiguationOption(getOptionsObject(t));
+    return createTemporalZonedDateTime(getEpochNanosecondsFor(n, o._, r), n, o.U);
+  }
+  toPlainDate() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return createTemporalDate(e._.o, e.U);
+  }
+  toPlainTime() {
+    return createTemporalTime(getInternalSlotOrThrowForPlainDateTime(this)._.p);
+  }
+};
+(defineStringTag(Me.prototype, "Temporal.PlainDateTime"), renameFunction(Me, "PlainDateTime"));
+const Ue = new WeakMap();
+var je = class {
+  constructor(e = 0, t = 0, o = 0, n = 0, r = 0, a = 0) {
+    const i = [e, t, o, n, r, a].map(toIntegerWithTruncation);
+    (isValidTime(...i) || throwRangeError(De), createTemporalTime(createTimeRecord(...i), this));
+  }
+  static from(e, t = void 0) {
+    return toTemporalTime(e, t);
+  }
+  static compare(e, t) {
+    return compareTimeRecord(
+      getInternalSlotOrThrowForPlainTime(toTemporalTime(e)),
+      getInternalSlotOrThrowForPlainTime(toTemporalTime(t)),
+    );
+  }
+  get hour() {
+    return getInternalSlotOrThrowForPlainTime(this).D;
+  }
+  get minute() {
+    return getInternalSlotOrThrowForPlainTime(this).I;
+  }
+  get second() {
+    return getInternalSlotOrThrowForPlainTime(this).O;
+  }
+  get millisecond() {
+    return getInternalSlotOrThrowForPlainTime(this).S;
+  }
+  get microsecond() {
+    return getInternalSlotOrThrowForPlainTime(this).F;
+  }
+  get nanosecond() {
+    return getInternalSlotOrThrowForPlainTime(this).v;
+  }
+  add(e) {
+    return addDurationToTime(1, getInternalSlotOrThrowForPlainTime(this), e);
+  }
+  subtract(e) {
+    return addDurationToTime(-1, getInternalSlotOrThrowForPlainTime(this), e);
+  }
+  with(e, t = void 0) {
+    const o = getInternalSlotOrThrowForPlainTime(this);
+    return (
+      validatePartialTemporalObject(e),
+      createTemporalTime(
+        regulateTime(
+          ...withArray(toTemporalTimeRecord(e, !0), [o.D, o.I, o.O, o.S, o.F, o.v]),
+          getTemporalOverflowOption(getOptionsObject(t)),
+        ),
+      )
+    );
+  }
+  until(e, t = void 0) {
+    return differenceTemporalPlainTime(1, getInternalSlotOrThrowForPlainTime(this), e, t);
+  }
+  since(e, t = void 0) {
+    return differenceTemporalPlainTime(-1, getInternalSlotOrThrowForPlainTime(this), e, t);
+  }
+  round(e) {
+    const o = getInternalSlotOrThrowForPlainTime(this),
+      n = getRoundToOptionsObject(e),
+      r = getRoundingIncrementOption(n),
+      i = getRoundingModeOption(n, v),
+      l = getTemporalUnitValuedOption(n, "smallestUnit", a);
+    return (
+      validateTemporalUnitValue(l, t),
+      validateTemporalRoundingIncrement(r, maximumTemporalDurationRoundingIncrement(l), !1),
+      createTemporalTime(roundTime(o, r, l, i))
+    );
+  }
+  equals(e) {
+    return !compareTimeRecord(
+      getInternalSlotOrThrowForPlainTime(this),
+      getInternalSlotOrThrowForPlainTime(toTemporalTime(e)),
+    );
+  }
+  toString(e = void 0) {
+    const o = getInternalSlotOrThrowForPlainTime(this),
+      n = getOptionsObject(e),
+      r = getTemporalFractionalSecondDigitsOption(n),
+      a = getRoundingModeOption(n, S),
+      i = getTemporalUnitValuedOption(n, "smallestUnit", void 0);
+    (validateTemporalUnitValue(i, t), i === J && throwRangeError(invalidField("smallestUnit")));
+    const l = toSecondsStringPrecisionRecord(i, r);
+    return timeRecordToString(roundTime(o, l.Ee, l.ye, a), l.ve);
+  }
+  toLocaleString(e = void 0, o = void 0) {
+    return (
+      getInternalSlotOrThrowForPlainTime(this), formatDateTime(createDateTimeFormat(e, o, t), this)
+    );
+  }
+  toJSON() {
+    return timeRecordToString(getInternalSlotOrThrowForPlainTime(this), void 0);
+  }
+  valueOf() {
+    throwTypeError(we);
+  }
+};
+(defineStringTag(je.prototype, "Temporal.PlainTime"), renameFunction(je, "PlainTime"));
+const $e = "\\d{4}|[-+]\\d{6}",
+  Ce = "0[1-9]|1[0-2]",
+  Ye = "0[1-9]|[12]\\d|30|31",
+  Ae = "[01]\\d|2[0-3]",
+  We = "[0-5]\\d",
+  ze = `(?<a>${$e})(?<x>-?)(?<b>${Ce})\\k<x>(?<c>${Ye})`,
+  Ve = optionalChain([
+    `(?<d>${Ae})`,
+    `(?<y>:?)(?<e>${We})`,
+    "\\k<y>(?<f>[0-5]\\d|60)",
+    "[.,](?<g>\\d{1,9})",
+  ]),
+  ke = optionalChain([`([+-])(${Ae})`, `(?<z>:?)(${We})`, `\\k<z>(${We})`, "[.,](\\d{1,9})"]),
+  He = optionalChain([ze, `[ tT]${Ve}`, `(?<h>${ke})`]),
+  xe = `(?<l>${$e})-?(?<m>${Ce})`,
+  Le = `(?:--)?(?<m>${Ce})-?(?<n>${Ye})`,
+  Be = `(?<h>${ke})|(?<i>[zZ])`,
+  qe = `([+-])(${Ae})(?::?(${We}))?|${join("[a-zA-Z._][a-zA-Z._+-\\d]*", "\\/")}`,
+  Je = `\\[!?(?<j>${qe})\\]`,
+  Ke = join("[a-zA-Z\\d]+", "-"),
+  Ge = `\\[(!)?([a-z_][a-z\\d_-]*)=(${Ke})\\]`,
+  _e = `(?<k>(${Ge})*)`,
+  Xe = RegExp(Ge, "g"),
+  Qe = createRegExp(`${optionalChain([ze, `[ tT]${Ve}`, Be])}${Je}${_e}`),
+  et = createRegExp(`${He}(?:${Je})?${_e}`),
+  tt = createRegExp(`${ze}[ tT]${Ve}(?:${Be})(?:${Je})?${_e}`),
+  ot = createRegExp(`(${ze}[ tT]|[tT]?)${Ve}(?<h>${ke})?(?:${Je})?${_e}`),
+  nt = createRegExp(`(${He}|${Le})(?:${Je})?${_e}`),
+  rt = createRegExp(`(${He}|${xe})(?:${Je})?${_e}`),
+  at = [createRegExp(`${Le}(${Je})?(${Ge})*`), createRegExp(`${xe}(${Je})?(${Ge})*`)],
+  it = createRegExp(qe),
+  lt = createRegExp(Ke),
+  ct = createRegExp(ke),
+  st = new WeakMap();
+var dt = class {
+  constructor(e, t, o = "iso8601", n = 1972) {
+    const r = toIntegerWithTruncation(e),
+      a = toIntegerWithTruncation(t);
+    validateString(o);
+    const i = canonicalizeCalendar(o),
+      l = toIntegerWithTruncation(n);
+    (isValidIsoDate(l, r, a) || throwRangeError(De),
+      createTemporalMonthDay(createIsoDateRecord(l, r, a), i, this));
+  }
+  static from(e, t = void 0) {
+    return toTemporalMonthDay(e, t);
+  }
+  get calendarId() {
+    return getInternalSlotOrThrowForPlainMonthDay(this).U;
+  }
+  get monthCode() {
+    const e = getInternalSlotOrThrowForPlainMonthDay(this);
+    return calendarIsoToDate(e.U, e.o).P;
+  }
+  get day() {
+    const e = getInternalSlotOrThrowForPlainMonthDay(this);
+    return calendarIsoToDate(e.U, e.o).T;
+  }
+  with(e, t = void 0) {
+    const o = getInternalSlotOrThrowForPlainMonthDay(this);
+    return (
+      validatePartialTemporalObject(e),
+      createTemporalMonthDay(
+        calendarMonthDayFromFields(
+          o.U,
+          calendarMergeFields(
+            o.U,
+            isoDateToFields(o.U, o.o, r),
+            prepareCalendarFields(o.U, e, [pt.t, pt.u, pt.P, pt.T]),
+          ),
+          getTemporalOverflowOption(getOptionsObject(t)),
+        ),
+        o.U,
+      )
+    );
+  }
+  equals(e) {
+    const t = getInternalSlotOrThrowForPlainMonthDay(this),
+      o = getInternalSlotOrThrowForPlainMonthDay(toTemporalMonthDay(e));
+    return 0 === compareIsoDate(t.o, o.o) && calendarEquals(t.U, o.U);
+  }
+  toString(e = void 0) {
+    return temporalMonthDayToString(
+      getInternalSlotOrThrowForPlainMonthDay(this),
+      getTemporalShowCalendarNameOption(getOptionsObject(e)),
+    );
+  }
+  toLocaleString(t = void 0, o = void 0) {
+    return (
+      getInternalSlotOrThrowForPlainMonthDay(this),
+      formatDateTime(createDateTimeFormat(t, o, e), this)
+    );
+  }
+  toJSON() {
+    return temporalMonthDayToString(getInternalSlotOrThrowForPlainMonthDay(this), P);
+  }
+  valueOf() {
+    throwTypeError(we);
+  }
+  toPlainDate(e) {
+    const t = getInternalSlotOrThrowForPlainMonthDay(this);
+    return (
+      isObject(e) || throwTypeError(notObject(e)),
+      createTemporalDate(
+        calendarDateFromFields(
+          t.U,
+          calendarMergeFields(
+            t.U,
+            isoDateToFields(t.U, t.o, r),
+            prepareCalendarFields(t.U, e, [pt.t], []),
+          ),
+          l,
+        ),
+        t.U,
+      )
+    );
+  }
+};
+(defineStringTag(dt.prototype, "Temporal.PlainMonthDay"), renameFunction(dt, "PlainMonthDay"));
+const mt = new WeakMap();
+var Tt = class {
+  constructor(e, t, o = "iso8601", n = 1) {
+    const r = toIntegerWithTruncation(e),
+      a = toIntegerWithTruncation(t);
+    validateString(o);
+    const i = canonicalizeCalendar(o),
+      l = toIntegerWithTruncation(n);
+    (isValidIsoDate(r, a, l) || throwRangeError(De),
+      createTemporalYearMonth(createIsoDateRecord(r, a, l), i, this));
+  }
+  static from(e, t = void 0) {
+    return toTemporalYearMonth(e, t);
+  }
+  static compare(e, t) {
+    return compareIsoDate(
+      getInternalSlotOrThrowForPlainYearMonth(toTemporalYearMonth(e)).o,
+      getInternalSlotOrThrowForPlainYearMonth(toTemporalYearMonth(t)).o,
+    );
+  }
+  get calendarId() {
+    return getInternalSlotOrThrowForPlainYearMonth(this).U;
+  }
+  get era() {
+    const e = getInternalSlotOrThrowForPlainYearMonth(this);
+    return calendarIsoToDate(e.U, e.o).oe;
+  }
+  get eraYear() {
+    const e = getInternalSlotOrThrowForPlainYearMonth(this);
+    return calendarIsoToDate(e.U, e.o).ne;
+  }
+  get year() {
+    const e = getInternalSlotOrThrowForPlainYearMonth(this);
+    return calendarIsoToDate(e.U, e.o).t;
+  }
+  get month() {
+    const e = getInternalSlotOrThrowForPlainYearMonth(this);
+    return calendarIsoToDate(e.U, e.o).u;
+  }
+  get monthCode() {
+    const e = getInternalSlotOrThrowForPlainYearMonth(this);
+    return calendarIsoToDate(e.U, e.o).P;
+  }
+  get daysInYear() {
+    const e = getInternalSlotOrThrowForPlainYearMonth(this);
+    return calendarIsoToDate(e.U, e.o).de;
+  }
+  get daysInMonth() {
+    const e = getInternalSlotOrThrowForPlainYearMonth(this);
+    return calendarIsoToDate(e.U, e.o).se;
+  }
+  get monthsInYear() {
+    const e = getInternalSlotOrThrowForPlainYearMonth(this);
+    return calendarIsoToDate(e.U, e.o).me;
+  }
+  get inLeapYear() {
+    const e = getInternalSlotOrThrowForPlainYearMonth(this);
+    return calendarIsoToDate(e.U, e.o).ue;
+  }
+  with(e, t = void 0) {
+    const o = getInternalSlotOrThrowForPlainYearMonth(this);
+    validatePartialTemporalObject(e);
+    const r = calendarMergeFields(
+      o.U,
+      isoDateToFields(o.U, o.o, n),
+      prepareCalendarFields(o.U, e, [pt.t, pt.u, pt.P]),
+    );
+    return createTemporalYearMonth(
+      calendarYearMonthFromFields(o.U, r, getTemporalOverflowOption(getOptionsObject(t))),
+      o.U,
+    );
+  }
+  add(e, t = void 0) {
+    return addDurationToYearMonth(1, getInternalSlotOrThrowForPlainYearMonth(this), e, t);
+  }
+  subtract(e, t = void 0) {
+    return addDurationToYearMonth(-1, getInternalSlotOrThrowForPlainYearMonth(this), e, t);
+  }
+  until(e, t = void 0) {
+    return differenceTemporalPlainYearMonth(1, getInternalSlotOrThrowForPlainYearMonth(this), e, t);
+  }
+  since(e, t = void 0) {
+    return differenceTemporalPlainYearMonth(
+      -1,
+      getInternalSlotOrThrowForPlainYearMonth(this),
+      e,
+      t,
+    );
+  }
+  equals(e) {
+    const t = getInternalSlotOrThrowForPlainYearMonth(this),
+      o = getInternalSlotOrThrowForPlainYearMonth(toTemporalYearMonth(e));
+    return 0 === compareIsoDate(t.o, o.o) && t.U === o.U;
+  }
+  toString(e = void 0) {
+    return temporalYearMonthToString(
+      getInternalSlotOrThrowForPlainYearMonth(this),
+      getTemporalShowCalendarNameOption(getOptionsObject(e)),
+    );
+  }
+  toLocaleString(t = void 0, o = void 0) {
+    return (
+      getInternalSlotOrThrowForPlainYearMonth(this),
+      formatDateTime(createDateTimeFormat(t, o, e), this)
+    );
+  }
+  toJSON() {
+    return temporalYearMonthToString(getInternalSlotOrThrowForPlainYearMonth(this), P);
+  }
+  valueOf() {
+    throwTypeError(we);
+  }
+  toPlainDate(e) {
+    const t = getInternalSlotOrThrowForPlainYearMonth(this);
+    return (
+      isObject(e) || throwTypeError(notObject(e)),
+      createTemporalDate(
+        calendarDateFromFields(
+          t.U,
+          calendarMergeFields(
+            t.U,
+            isoDateToFields(t.U, t.o, n),
+            prepareCalendarFields(t.U, e, [pt.T], []),
+          ),
+          l,
+        ),
+        t.U,
+      )
+    );
+  }
+};
+(defineStringTag(Tt.prototype, "Temporal.PlainYearMonth"), renameFunction(Tt, "PlainYearMonth"));
+const ut = new WeakMap();
+var Dt = class {
+  constructor(e, t, o, n = "iso8601") {
+    const r = toIntegerWithTruncation(e),
+      a = toIntegerWithTruncation(t),
+      i = toIntegerWithTruncation(o);
+    validateString(n);
+    const l = canonicalizeCalendar(n);
+    (isValidIsoDate(r, a, i) || throwRangeError(De),
+      createTemporalDate(createIsoDateRecord(r, a, i), l, this));
+  }
+  static from(e, t = void 0) {
+    return toTemporalDate(e, t);
+  }
+  static compare(e, t) {
+    return compareIsoDate(
+      getInternalSlotOrThrowForPlainDate(toTemporalDate(e)).o,
+      getInternalSlotOrThrowForPlainDate(toTemporalDate(t)).o,
+    );
+  }
+  get calendarId() {
+    return getInternalSlotOrThrowForPlainDate(this).U;
+  }
+  get era() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.U, e.o).oe;
+  }
+  get eraYear() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.U, e.o).ne;
+  }
+  get year() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.U, e.o).t;
+  }
+  get month() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.U, e.o).u;
+  }
+  get monthCode() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.U, e.o).P;
+  }
+  get day() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.U, e.o).T;
+  }
+  get dayOfWeek() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.U, e.o).ae;
+  }
+  get dayOfYear() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.U, e.o).ie;
+  }
+  get weekOfYear() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.U, e.o).le.re;
+  }
+  get yearOfWeek() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.U, e.o).le.t;
+  }
+  get daysInWeek() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.U, e.o).ce;
+  }
+  get daysInMonth() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.U, e.o).se;
+  }
+  get daysInYear() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.U, e.o).de;
+  }
+  get monthsInYear() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.U, e.o).me;
+  }
+  get inLeapYear() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.U, e.o).ue;
+  }
+  toPlainYearMonth() {
+    const t = getInternalSlotOrThrowForPlainDate(this);
+    return createTemporalYearMonth(
+      calendarYearMonthFromFields(t.U, isoDateToFields(t.U, t.o, e), l),
+      t.U,
+    );
+  }
+  toPlainMonthDay() {
+    const t = getInternalSlotOrThrowForPlainDate(this);
+    return createTemporalMonthDay(
+      calendarMonthDayFromFields(t.U, isoDateToFields(t.U, t.o, e), l),
+      t.U,
+    );
+  }
+  add(e, t = void 0) {
+    return addDurationToDate(1, getInternalSlotOrThrowForPlainDate(this), e, t);
+  }
+  subtract(e, t = void 0) {
+    return addDurationToDate(-1, getInternalSlotOrThrowForPlainDate(this), e, t);
+  }
+  with(t, o = void 0) {
+    const n = getInternalSlotOrThrowForPlainDate(this);
+    validatePartialTemporalObject(t);
+    const r = calendarMergeFields(
+        n.U,
+        isoDateToFields(n.U, n.o, e),
+        prepareCalendarFields(n.U, t, [pt.t, pt.u, pt.P, pt.T]),
+      ),
+      a = getTemporalOverflowOption(getOptionsObject(o));
+    return createTemporalDate(calendarDateFromFields(n.U, r, a), n.U);
+  }
+  withCalendar(e) {
+    return createTemporalDate(
+      getInternalSlotOrThrowForPlainDate(this).o,
+      toTemporalCalendarIdentifier(e),
+    );
+  }
+  until(e, t = void 0) {
+    return differenceTemporalPlainDate(1, getInternalSlotOrThrowForPlainDate(this), e, t);
+  }
+  since(e, t = void 0) {
+    return differenceTemporalPlainDate(-1, getInternalSlotOrThrowForPlainDate(this), e, t);
+  }
+  equals(e) {
+    const t = getInternalSlotOrThrowForPlainDate(this),
+      o = getInternalSlotOrThrowForPlainDate(toTemporalDate(e));
+    return !compareIsoDate(t.o, o.o) && calendarEquals(t.U, o.U);
+  }
+  toPlainDateTime(e = void 0) {
+    const t = getInternalSlotOrThrowForPlainDate(this);
+    return createTemporalDateTime(combineIsoDateAndTimeRecord(t.o, toTimeRecordOrMidnight(e)), t.U);
+  }
+  toZonedDateTime(e) {
+    const t = getInternalSlotOrThrowForPlainDate(this);
+    let o, n;
+    if (isObject(e)) {
+      const t = e.timeZone;
+      void 0 === t
+        ? ((n = toTemporalTimeZoneIdentifier(e)), (o = void 0))
+        : ((n = toTemporalTimeZoneIdentifier(t)), (o = e.plainTime));
+    } else ((n = toTemporalTimeZoneIdentifier(e)), (o = void 0));
+    return createTemporalZonedDateTime(
+      void 0 === o
+        ? getStartOfDay(n, t.o)
+        : getEpochNanosecondsFor(
+            n,
+            validateIsoDateTime(
+              combineIsoDateAndTimeRecord(
+                t.o,
+                getInternalSlotOrThrowForPlainTime(toTemporalTime(o)),
+              ),
+            ),
+            s,
+          ),
+      n,
+      t.U,
+    );
+  }
+  toString(e = void 0) {
+    return temporalDateToString(
+      getInternalSlotOrThrowForPlainDate(this),
+      getTemporalShowCalendarNameOption(getOptionsObject(e)),
+    );
+  }
+  toLocaleString(t = void 0, o = void 0) {
+    return (
+      getInternalSlotOrThrowForPlainDate(this), formatDateTime(createDateTimeFormat(t, o, e), this)
+    );
+  }
+  toJSON() {
+    return temporalDateToString(getInternalSlotOrThrowForPlainDate(this), P);
+  }
+  valueOf() {
+    throwTypeError(we);
+  }
+};
+(defineStringTag(Dt.prototype, "Temporal.PlainDate"), renameFunction(Dt, "PlainDate"));
+const pt = {
+    oe: "era",
+    ne: "eraYear",
+    t: "year",
+    u: "month",
+    P: "monthCode",
+    T: "day",
+    D: "hour",
+    I: "minute",
+    O: "second",
+    S: "millisecond",
+    F: "microsecond",
+    v: "nanosecond",
+    R: "offset",
+    $: "timeZone",
+  },
+  ht = [pt.oe, pt.ne, pt.t, pt.u, pt.P, pt.T, pt.D, pt.I, pt.O, pt.S, pt.F, pt.v, pt.R, pt.$],
+  gt = {
+    [pt.oe]: [toString],
+    [pt.ne]: [toIntegerWithTruncation],
+    [pt.t]: [toIntegerWithTruncation],
+    [pt.u]: [toPositiveIntegerWithTruncation],
+    [pt.P]: [(e) => createMonthCode(...parseMonthCode(e))],
+    [pt.T]: [toPositiveIntegerWithTruncation],
+    [pt.D]: [toIntegerWithTruncation, 0],
+    [pt.I]: [toIntegerWithTruncation, 0],
+    [pt.O]: [toIntegerWithTruncation, 0],
+    [pt.S]: [toIntegerWithTruncation, 0],
+    [pt.F]: [toIntegerWithTruncation, 0],
+    [pt.v]: [toIntegerWithTruncation, 0],
+    [pt.R]: [
+      (e) => {
+        const t = toPrimitive(e);
+        return (validateString(t), parseDateTimeUtcOffset(t), t);
+      },
+    ],
+    [pt.$]: [toTemporalTimeZoneIdentifier],
+  },
+  ft = normalize((It = createTimeDurationFromSeconds(2 ** 53 - 1))[0], It[1] + 999999999);
+var It;
+const Ot = new WeakMap(),
+  St = signTimeDuration;
+var Ft = class {
+  constructor(e = 0, t = 0, o = 0, n = 0, r = 0, a = 0, i = 0, l = 0, c = 0, s = 0) {
+    createTemporalDuration(
+      createTemporalDurationSlot(...[e, t, o, n, r, a, i, l, c, s].map(toIntegerIfIntegral)),
+      this,
+    );
+  }
+  static from(e) {
+    return createTemporalDuration(toTemporalDuration(e));
+  }
+  static compare(e, t, o = void 0) {
+    const n = toTemporalDuration(e),
+      r = toTemporalDuration(t),
+      a = getTemporalRelativeToOption(getOptionsObject(o));
+    if (n.every((e, t) => r[t] === e)) return 0;
+    const i = defaultTemporalLargestUnit(n),
+      c = defaultTemporalLargestUnit(r),
+      s = toInternalDurationRecord(n),
+      d = toInternalDurationRecord(r);
+    let m, T;
+    return a.Pe && (isDateUnit(i) || isDateUnit(c))
+      ? compareEpochNanoseconds(addZonedDateTime(a.Pe, s, l), addZonedDateTime(a.Pe, d, l))
+      : (isCalendarUnit(i) || isCalendarUnit(c)
+          ? (a.be || throwRangeError(missingField("relativeTo")),
+            (m = dateDurationDays(s.W, a.be)),
+            (T = dateDurationDays(d.W, a.be)))
+          : ((m = n[ne]), (T = r[ne])),
+        Ee(add24HourDaysToTimeDuration(s.p, m), add24HourDaysToTimeDuration(d.p, T)));
+  }
+  get years() {
+    return getInternalSlotOrThrowForDuration(this)[ee];
+  }
+  get months() {
+    return getInternalSlotOrThrowForDuration(this)[te];
+  }
+  get weeks() {
+    return getInternalSlotOrThrowForDuration(this)[oe];
+  }
+  get days() {
+    return getInternalSlotOrThrowForDuration(this)[ne];
+  }
+  get hours() {
+    return getInternalSlotOrThrowForDuration(this)[re];
+  }
+  get minutes() {
+    return getInternalSlotOrThrowForDuration(this)[ae];
+  }
+  get seconds() {
+    return getInternalSlotOrThrowForDuration(this)[ie];
+  }
+  get milliseconds() {
+    return getInternalSlotOrThrowForDuration(this)[le];
+  }
+  get microseconds() {
+    return getInternalSlotOrThrowForDuration(this)[ce];
+  }
+  get nanoseconds() {
+    return getInternalSlotOrThrowForDuration(this)[se];
+  }
+  get sign() {
+    return durationSign(getInternalSlotOrThrowForDuration(this));
+  }
+  get blank() {
+    return 0 === durationSign(getInternalSlotOrThrowForDuration(this));
+  }
+  with(e) {
+    const t = getInternalSlotOrThrowForDuration(this);
+    return createTemporalDuration(
+      createTemporalDurationSlot(...withArray(toTemporalPartialDurationRecord(e), t)),
+    );
+  }
+  negated() {
+    return createTemporalDuration(
+      ((e) => applySignToDurationSlot(e, -1))(getInternalSlotOrThrowForDuration(this)),
+    );
+  }
+  abs() {
+    return createTemporalDuration(
+      createTemporalDurationSlot(...getInternalSlotOrThrowForDuration(this).map(Math.abs)),
+    );
+  }
+  add(e) {
+    return addDurations(1, getInternalSlotOrThrowForDuration(this), e);
+  }
+  subtract(e) {
+    return addDurations(-1, getInternalSlotOrThrowForDuration(this), e);
+  }
+  round(e) {
+    const t = getInternalSlotOrThrowForDuration(this),
+      n = getRoundToOptionsObject(e);
+    let r = getTemporalUnitValuedOption(n, "largestUnit", void 0);
+    const a = getTemporalRelativeToOption(n),
+      i = getRoundingIncrementOption(n),
+      c = getRoundingModeOption(n, v);
+    let s = getTemporalUnitValuedOption(n, "smallestUnit", void 0);
+    validateTemporalUnitValue(s, o);
+    const d = void 0 !== s;
+    s ??= Q;
+    const m = defaultTemporalLargestUnit(t),
+      T = largerOfTwoTemporalUnits(m, s),
+      u = void 0 !== r;
+    if (
+      ((void 0 !== r && "auto" !== r) || (r = T),
+      ((d || u) && largerOfTwoTemporalUnits(r, s) === r) || throwRangeError(Oe),
+      isDateUnit(s) ||
+        validateTemporalRoundingIncrement(i, maximumTemporalDurationRoundingIncrement(s), !1),
+      i > 1 && r !== s && isDateUnit(s) && throwRangeError(Oe),
+      a.Pe)
+    )
+      return createTemporalDuration(
+        temporalDurationFromInternal(
+          differenceZonedDateTimeWithRounding(
+            a.Pe,
+            createZonedDateTimeSlot(
+              addZonedDateTime(a.Pe, toInternalDurationRecord(t), l),
+              a.Pe.$,
+              a.Pe.U,
+            ),
+            r,
+            i,
+            s,
+            c,
+          ),
+          isDateUnit(r) ? J : r,
+        ),
+      );
+    if (a.be) {
+      const e = toInternalDurationRecordWith24HourDays(t),
+        o = addTime(midnightTimeRecord(), e.p);
+      return createTemporalDuration(
+        temporalDurationFromInternal(
+          differencePlainDateTimeWithRounding(
+            combineIsoDateAndTimeRecord(a.be.o, midnightTimeRecord()),
+            combineIsoDateAndTimeRecord(
+              calendarDateAdd(a.be.U, a.be.o, adjustDateDurationRecord(e.W, o.K), l),
+              o,
+            ),
+            a.be.U,
+            r,
+            i,
+            s,
+            c,
+          ),
+          r,
+        ),
+      );
+    }
+    (isCalendarUnit(m) || isCalendarUnit(r)) && throwRangeError(missingField("relativeTo"));
+    const D = toInternalDurationRecordWith24HourDays(t);
+    return createTemporalDuration(
+      temporalDurationFromInternal(
+        s === q
+          ? combineDateAndTimeDuration(
+              createDateDurationRecord(0, 0, 0, roundTimeDurationByDays(D.p, i, c)[0]),
+              createTimeDurationFromSeconds(0),
+            )
+          : combineDateAndTimeDuration(zeroDateDuration(), roundTimeDuration(D.p, i, s, c)),
+        r,
+      ),
+    );
+  }
+  total(e) {
+    const t = getInternalSlotOrThrowForDuration(this);
+    void 0 === e && throwTypeError(ve);
+    const n = "string" == typeof e ? createNullPrototypeObject({ unit: e }) : getOptionsObject(e),
+      r = getTemporalRelativeToOption(n),
+      i = getTemporalUnitValuedOption(n, "unit", a);
+    if ((validateTemporalUnitValue(i, o), r.Pe))
+      return ((e, t, o) =>
+        isDateUnit(o)
+          ? totalRelativeDuration(
+              differenceZonedDateTime(e, t, o),
+              e.Y,
+              t.Y,
+              getIsoDateTimeForZonedDateTimeSlot(e),
+              e.$,
+              e.U,
+              o,
+            )
+          : totalTimeDuration(timeDurationFromEpochNanosecondsDifference(t.Y, e.Y), o))(
+        r.Pe,
+        createZonedDateTimeSlot(
+          addZonedDateTime(r.Pe, toInternalDurationRecord(t), l),
+          r.Pe.$,
+          r.Pe.U,
+        ),
+        i,
+      );
+    if (r.be) {
+      const e = toInternalDurationRecordWith24HourDays(t),
+        o = addTime(midnightTimeRecord(), e.p);
+      return ((e, t, o, n) =>
+        compareIsoDateTime(e, t)
+          ? (validateIsoDateTime(e),
+            validateIsoDateTime(t),
+            totalRelativeDuration(
+              differenceISODateTime(e, t, o, n),
+              getUtcEpochNanoseconds(e),
+              getUtcEpochNanoseconds(t),
+              e,
+              void 0,
+              0,
+              n,
+            ))
+          : 0)(
+        combineIsoDateAndTimeRecord(r.be.o, midnightTimeRecord()),
+        combineIsoDateAndTimeRecord(
+          calendarDateAdd(r.be.U, r.be.o, adjustDateDurationRecord(e.W, o.K), l),
+          o,
+        ),
+        r.be.U,
+        i,
+      );
+    }
+    return (
+      (isCalendarUnit(defaultTemporalLargestUnit(t)) || isCalendarUnit(i)) &&
+        throwRangeError(missingField("relativeTo")),
+      totalTimeDuration(toInternalDurationRecordWith24HourDays(t).p, i)
+    );
+  }
+  toString(e = void 0) {
+    const o = getInternalSlotOrThrowForDuration(this),
+      n = getOptionsObject(e),
+      r = getTemporalFractionalSecondDigitsOption(n),
+      a = getRoundingModeOption(n, S),
+      i = getTemporalUnitValuedOption(n, "smallestUnit", void 0);
+    (validateTemporalUnitValue(i, t), (i !== J && i !== K) || throwRangeError(disallowedUnit(i)));
+    const l = toSecondsStringPrecisionRecord(i, r);
+    if (l.ye === Q && 1 === l.Ee) return temporalDurationToString(o, l.ve);
+    const c = toInternalDurationRecord(o);
+    return temporalDurationToString(
+      temporalDurationFromInternal(
+        combineDateAndTimeDuration(c.W, roundTimeDuration(c.p, l.Ee, l.ye, a)),
+        largerOfTwoTemporalUnits(defaultTemporalLargestUnit(o), G),
+      ),
+      l.ve,
+    );
+  }
+  toJSON() {
+    return temporalDurationToString(getInternalSlotOrThrowForDuration(this));
+  }
+  toLocaleString(e = void 0, t = void 0) {
+    const o = getInternalSlotOrThrowForDuration(this),
+      n = createNullPrototypeObject({});
+    return (
+      me.map((e, t) => {
+        n[e] = o[t];
+      }),
+      new Intl.DurationFormat(e, t).format(n)
+    );
+  }
+  valueOf() {
+    throwTypeError(we);
+  }
+};
+(defineStringTag(Ft.prototype, "Temporal.Duration"), renameFunction(Ft, "Duration"));
+const wt = {
+    [f]: Math.ceil,
+    [I]: Math.floor,
+    [O]: roundExpand,
+    [S]: Math.trunc,
+    [F]: roundHalfCeil,
+    [w]: roundHalfFloor,
+    [v]: (e) => (isIntegerAndHalf(e) ? roundExpand(e) : Math.round(e)) + 0,
+    [y]: (e) => (isIntegerAndHalf(e) ? Math.trunc(e) : Math.round(e)) + 0,
+    [E]: roundHalfEven,
+  },
+  vt = {
+    [f]: Math.ceil,
+    [I]: Math.floor,
+    [O]: Math.ceil,
+    [S]: Math.floor,
+    [F]: roundHalfCeil,
+    [w]: roundHalfFloor,
+    [v]: roundHalfCeil,
+    [y]: roundHalfFloor,
+    [E]: roundHalfEven,
+  },
+  yt = globalThis.Intl.DateTimeFormat,
+  Et = [];
+new yt(
+  void 0,
+  new Proxy(
+    {},
+    {
+      get(e, t) {
+        Et.push(t);
+      },
+    },
+  ),
+);
+const Pt = new WeakMap(),
+  bt = ["year", "month", "day", "weekday", "dateStyle"],
+  Rt = ["hour", "minute", "second", "fractionalSecondDigits", "dayPeriod", "timeStyle"];
+var Zt = class {
+    Ae(e) {
+      return formatDateTime(this, e);
+    }
+  },
+  Nt = class {
+    constructor(e, t) {
+      createDateTimeFormat(e, t, o, void 0, this);
+    }
+    get format() {
+      return Object.defineProperty(
+        (getInternalSlotOrThrowForDateTimeFormat(this).We ||= Zt.prototype.Ae.bind(this)),
+        "name",
+        { value: "" },
+      );
+    }
+    formatToParts(e) {
+      return ((e, t) => {
+        const [o, n] = handleDateTimeValue(getInternalSlotOrThrowForDateTimeFormat(e), t);
+        return o.formatToParts(n);
+      })(this, e);
+    }
+    formatRange(e, t) {
+      return (
+        (void 0 !== e && void 0 !== t) || throwTypeError(Se),
+        ((e, t, o) => {
+          const n = getInternalSlotOrThrowForDateTimeFormat(e);
+          validateSameTemporalType(t, o);
+          const [r, a] = handleDateTimeValue(n, t);
+          return r.formatRange(a, handleDateTimeValue(n, o)[1]);
+        })(this, toDateTimeFormattable(e), toDateTimeFormattable(t))
+      );
+    }
+    formatRangeToParts(e, t) {
+      return (
+        (void 0 !== e && void 0 !== t) || throwTypeError(Se),
+        ((e, t, o) => {
+          const n = getInternalSlotOrThrowForDateTimeFormat(e);
+          validateSameTemporalType(t, o);
+          const [r, a] = handleDateTimeValue(n, t);
+          return r.formatRangeToParts(a, handleDateTimeValue(n, o)[1]);
+        })(this, toDateTimeFormattable(e), toDateTimeFormattable(t))
+      );
+    }
+    resolvedOptions() {
+      return getInternalSlotOrThrowForDateTimeFormat(this).Re.resolvedOptions();
+    }
+  };
+const Mt = Object.getOwnPropertyDescriptors(Intl.DateTimeFormat);
+((Mt.prototype.value = Nt.prototype),
+  Object.defineProperties(DateTimeFormat, Mt),
+  (DateTimeFormat.prototype.constructor = DateTimeFormat),
+  defineStringTag(DateTimeFormat.prototype, "Intl.DateTimeFormat"));
+const Ut = createEpochNanosecondsFromEpochMilliseconds(-864e13),
+  jt = createEpochNanosecondsFromEpochMilliseconds(864e13),
+  $t = new WeakMap();
+var Ct = class {
+  constructor(e) {
+    createTemporalInstant(
+      validateEpochNanoseconds(createEpochNanosecondsFromBigInt(toBigInt(e))),
+      this,
+    );
+  }
+  static from(e) {
+    return toTemporalInstant$1(e);
+  }
+  static fromEpochMilliseconds(e) {
+    return createTemporalInstant(
+      validateEpochNanoseconds(createEpochNanosecondsFromEpochMilliseconds(toIntegerIfIntegral(e))),
+    );
+  }
+  static fromEpochNanoseconds(e) {
+    return createTemporalInstant(
+      validateEpochNanoseconds(createEpochNanosecondsFromBigInt(toBigInt(e))),
+    );
+  }
+  static compare(e, t) {
+    return compareEpochNanoseconds(
+      getInternalSlotOrThrowForInstant(toTemporalInstant$1(e)).Y,
+      getInternalSlotOrThrowForInstant(toTemporalInstant$1(t)).Y,
+    );
+  }
+  get epochMilliseconds() {
+    return epochMilliseconds(getInternalSlotOrThrowForInstant(this).Y);
+  }
+  get epochNanoseconds() {
+    return convertEpochNanosecondsToBigInt(getInternalSlotOrThrowForInstant(this).Y);
+  }
+  add(e) {
+    return addDurationToInstant(1, getInternalSlotOrThrowForInstant(this), e);
+  }
+  subtract(e) {
+    return addDurationToInstant(-1, getInternalSlotOrThrowForInstant(this), e);
+  }
+  until(e, t = void 0) {
+    return differenceTemporalInstant(1, getInternalSlotOrThrowForInstant(this), e, t);
+  }
+  since(e, t = void 0) {
+    return differenceTemporalInstant(-1, getInternalSlotOrThrowForInstant(this), e, t);
+  }
+  round(e) {
+    const o = getInternalSlotOrThrowForInstant(this),
+      n = getRoundToOptionsObject(e),
+      r = getRoundingIncrementOption(n),
+      i = getRoundingModeOption(n, v),
+      l = getTemporalUnitValuedOption(n, "smallestUnit", a);
+    return (
+      validateTemporalUnitValue(l, t),
+      validateTemporalRoundingIncrement(r, Te[0] / nanosecondsForTimeUnit(l), !0),
+      createTemporalInstant(roundTemporalInstant(o.Y, r, l, i))
+    );
+  }
+  equals(e) {
+    return !compareEpochNanoseconds(
+      getInternalSlotOrThrowForInstant(this).Y,
+      getInternalSlotOrThrowForInstant(toTemporalInstant$1(e)).Y,
+    );
+  }
+  toString(e = void 0) {
+    let o;
+    const n = getInternalSlotOrThrowForInstant(this),
+      r = getOptionsObject(e),
+      a = getTemporalFractionalSecondDigitsOption(r),
+      i = getRoundingModeOption(r, S),
+      l = getTemporalUnitValuedOption(r, "smallestUnit", void 0),
+      c = r.timeZone;
+    (validateTemporalUnitValue(l, t),
+      l === J && throwRangeError(invalidField("smallestUnit")),
+      void 0 !== c && (o = toTemporalTimeZoneIdentifier(c)));
+    const s = toSecondsStringPrecisionRecord(l, a);
+    return temporalInstantToString(roundTemporalInstant(n.Y, s.Ee, s.ye, i), o, s.ve);
+  }
+  toLocaleString(e = void 0, t = void 0) {
+    return (
+      getInternalSlotOrThrowForInstant(this), formatDateTime(createDateTimeFormat(e, t, o), this)
+    );
+  }
+  toJSON() {
+    return temporalInstantToString(getInternalSlotOrThrowForInstant(this).Y, void 0);
+  }
+  valueOf() {
+    throwTypeError(we);
+  }
+  toZonedDateTimeISO(e) {
+    return createTemporalZonedDateTime(
+      getInternalSlotOrThrowForInstant(this).Y,
+      toTemporalTimeZoneIdentifier(e),
+      "iso8601",
+    );
+  }
+};
+(defineStringTag(Ct.prototype, "Temporal.Instant"), renameFunction(Ct, "Instant"));
+const Yt = class {
+    toTemporalInstant() {
+      const e = Date.prototype.valueOf.call(this);
+      return (
+        isNaN(e) && throwRangeError("invalid date"),
+        createTemporalInstant(createEpochNanosecondsFromEpochMilliseconds(e))
+      );
+    }
+  }.prototype.toTemporalInstant,
+  At = Object.getOwnPropertyDescriptors(globalThis.Intl);
+At.DateTimeFormat.value = DateTimeFormat;
+const Wt = {};
+Object.defineProperties(Wt, At);
+const zt = {
+  timeZoneId: () => systemTimeZoneIdentifier(),
+  instant: () => createTemporalInstant(systemUtcEpochNanoseconds()),
+  plainDateTimeISO: (e = void 0) => createTemporalDateTime(systemDateTime(e), "iso8601"),
+  zonedDateTimeISO: (e = void 0) =>
+    createTemporalZonedDateTime(
+      systemUtcEpochNanoseconds(),
+      void 0 === e ? systemTimeZoneIdentifier() : toTemporalTimeZoneIdentifier(e),
+      "iso8601",
+    ),
+  plainDateISO: (e = void 0) => createTemporalDate(systemDateTime(e).o, "iso8601"),
+  plainTimeISO: (e = void 0) => createTemporalTime(systemDateTime(e).p),
+};
+(defineStringTag(zt, "Temporal.Now"), makePropertiesNonEnumerable(zt));
+const Vt = {
+  Instant: Ct,
+  PlainDateTime: Me,
+  PlainDate: Dt,
+  PlainTime: je,
+  PlainYearMonth: Tt,
+  PlainMonthDay: dt,
+  Duration: Ft,
+  ZonedDateTime: be,
+  Now: zt,
+};
+(defineStringTag(Vt, "Temporal"), makePropertiesNonEnumerable(Vt));
+export { defineNonEnumerableProperty as i, Wt as n, Yt as r, Vt as t };