temporal-polyfill-lite 0.2.2 → 0.2.3

package/dist/calendars/src-BYgX6wUQ.js

@@ -0,0 +1,4924 @@
+function getNameFromUnit(e) {
+  return se[e];
+}
+function nanosecondsForTimeUnit(e) {
+  return de[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 = we(e);
+  return (Number.isInteger(t) || throwRangeError(invalidNumber(t)), t + 0);
+}
+function toIntegerWithTruncation(e) {
+  const t = we(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 === T && throwRangeError(missingField(t)), n);
+  const a = toString(r);
+  return (o.includes(a) || throwRangeError(invalidField(t)), a);
+}
+function getRoundToOptionsObject(e = throwTypeError(ye)) {
+  return "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 normalizeEpochNanoseconds(e, t) {
+  return [e + divFloor(t, i), modFloor(t, i)];
+}
+function createEpochNanosecondsFromBigInt(e) {
+  return normalizeEpochNanoseconds(Number(e / BigInt(i)), Number(e % BigInt(i)));
+}
+function createEpochNanosecondsFromEpochMilliseconds(e) {
+  return normalizeEpochNanoseconds(divFloor(e, r), 1e6 * modFloor(e, r));
+}
+function createEpochNanosecondsFromEpochSeconds(e) {
+  return createEpochNanosecondsFromEpochMilliseconds(1e3 * e);
+}
+function convertEpochNanosecondsToBigInt(e) {
+  return BigInt(e[0]) * BigInt(i) + BigInt(e[1]);
+}
+function compareEpochNanoseconds(e, t) {
+  return compare(e[0], t[0]) || compare(e[1], t[1]);
+}
+function epochMilliseconds(t) {
+  return t[0] * r + divFloor(t[1], e);
+}
+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 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 normalize(e, t) {
+  const [o, n] = normalizeEpochNanoseconds(e, t);
+  return o < 0 && n > 0 ? [o + 1, n - i] : [o, n];
+}
+function createTimeDurationFromSeconds(e) {
+  return normalize(divTrunc(e, n), (e % n) * 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 Me(e, [0, 0]);
+}
+function timeDurationToSubsecondsNumber(e, t, o) {
+  const n = signTimeDuration(e);
+  return (
+    (e = absTimeDuration(e)),
+    n *
+      we(
+        `${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] / i), 0.5) + 0.5 : 0),
+      t,
+      o,
+    ),
+    0,
+  );
+}
+function divideTimeDurationToFloatingPoint(e, t) {
+  return t <= 1e9
+    ? timeDurationToSubsecondsNumber(e, -9 + Math.log10(t), !0)
+    : (i / t) * e[0] + e[1] / t;
+}
+function interpretISODateTimeOffset(e, o, n, r, a, i, c, s) {
+  if (!o) return getStartOfDay(a, e);
+  const l = combineIsoDateAndTimeRecord(e, o);
+  if (n === v || (n === y && c == F)) return getEpochNanosecondsFor(a, l, i);
+  if (n === w || (n === y && "use" == c))
+    return validateEpochNanoseconds(
+      getUtcEpochNanoseconds(
+        balanceIsoDateTime(l.o.t, l.o.u, l.o.T, l.p.D, l.p.I, l.p.O, l.p.F, l.p.S, l.p.$ - r),
+      ),
+    );
+  ((e) => {
+    Math.abs(isoDateToEpochDays(e.t, e.u - 1, e.T)) > 1e8 && throwRangeError(Te);
+  })(e);
+  const d = getPossibleEpochNanoseconds(a, l);
+  for (const e of d) {
+    const o = getOffsetNanosecondsFor(a, e);
+    if (o === r) return e;
+    if (!s && roundNumberToIncrement(o, t, Z) === r) return e;
+  }
+  return (
+    c === S && throwRangeError("time zone offset mismatch"),
+    disambiguatePossibleEpochNanoseconds(d, a, l, i)
+  );
+}
+function toTemporalZonedDateTime(e, t) {
+  let o,
+    n,
+    r,
+    a,
+    i,
+    c,
+    s,
+    l = !1,
+    d = !0;
+  if (isObject(e)) {
+    if (isZonedDateTime(e)) {
+      const o = getOptionsObject(t);
+      return (
+        getTemporalDisambiguationOption(o),
+        getTemporalOffsetOption(o, p),
+        getTemporalOverflowOption(o),
+        getInternalSlotOrThrowForZonedDateTime(e)
+      );
+    }
+    i = getTemporalCalendarIdentifierWithIsoDefault(e);
+    const l = prepareCalendarFields(
+      i,
+      e,
+      [yt.t, yt.u, yt.v, yt.T, yt.D, yt.I, yt.O, yt.F, yt.S, yt.$, yt.M, yt.P],
+      [yt.P],
+    );
+    ((o = l.timeZone), (n = l.offset));
+    const d = getOptionsObject(t);
+    ((r = getTemporalDisambiguationOption(d)), (a = getTemporalOffsetOption(d, p)));
+    const m = interpretTemporalDateTimeFields(i, l, getTemporalOverflowOption(d));
+    ((c = m.o), (s = m.p));
+  } else {
+    validateString(e);
+    const m = parseIsoDateTime(e, [et]);
+    ((o = toTemporalTimeZoneIdentifier(m.P.R)),
+      (n = m.P.N),
+      (l = m.P.Z),
+      (i = canonicalizeCalendar(m.Y || "iso8601")),
+      (d = !1),
+      n && (d = hasUtcOffsetSubMinuteParts(n)));
+    const u = getOptionsObject(t);
+    ((r = getTemporalDisambiguationOption(u)),
+      (a = getTemporalOffsetOption(u, p)),
+      getTemporalOverflowOption(u),
+      (c = createIsoDateRecord(m.t, m.u, m.T)),
+      (s = m.p));
+  }
+  const m = l ? w : n ? y : v;
+  return createZonedDateTimeSlot(
+    interpretISODateTimeOffset(c, s, m, m === y ? parseDateTimeUtcOffset(n) : 0, o, r, a, d),
+    o,
+    i,
+  );
+}
+function createTemporalZonedDateTime(e, t, o, n) {
+  return createTemporalZonedDateTimeFromSlot(
+    createZonedDateTimeSlot(
+      e,
+      t,
+      o,
+      ((e, t) => Ne[e] && Ne[e].C(clampEpochSecond(t)))(t, epochSeconds(e)),
+    ),
+    n,
+  );
+}
+function createZonedDateTimeSlot(e, t, o, n) {
+  return { U: e, P: t, Y: o, W: n };
+}
+function temporalZonedDateTimeToString(e, t, o, n, r, a = 1, i = K, c = P) {
+  const s = roundTemporalInstant(e.U, a, i, c),
+    l =
+      epochSeconds(s) === epochSeconds(e.U)
+        ? getOffsetNanosecondsForZonedDateTimeSlot(e)
+        : getOffsetNanosecondsFor(e.P, s);
+  return `${isoDateTimeToString(getIsoDateTimeFromOffsetNanoseconds(s, l), "iso8601", t, j)}${r === L ? "" : formatDateTimeUtcOffsetRounded(l)}${n === z ? "" : `[${n === V ? "!" : ""}${e.P}]`}${formatCalendarAnnotation(e.Y, o)}`;
+}
+function addZonedDateTime(e, t, o) {
+  if (0 === dateDurationSign(t.A)) return addInstant(e.U, t.p);
+  const n = getIsoDateTimeForZonedDateTimeSlot(e);
+  return addInstant(
+    getEpochNanosecondsFor(
+      e.P,
+      validateIsoDateTime(combineIsoDateAndTimeRecord(calendarDateAdd(e.Y, n.o, t.A, o), n.p)),
+      g,
+    ),
+    t.p,
+  );
+}
+function differenceZonedDateTime(e, t, o) {
+  const n = compareEpochNanoseconds(e.U, t.U);
+  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.U, e.U),
+    );
+  let i,
+    c = differenceTime(r.p, a.p);
+  for (
+    let o = Mt(c) === n ? 1 : 0;
+    o <= (3 - n) / 2 &&
+    ((i = combineIsoDateAndTimeRecord(addDaysToIsoDate(a.o, o * n), r.p)),
+    (c = timeDurationFromEpochNanosecondsDifference(t.U, getEpochNanosecondsFor(e.P, i, g))),
+    Mt(c) === n);
+    o++
+  );
+  return combineDateAndTimeDuration(
+    calendarDateUntil(e.Y, r.o, i.o, largerOfTwoTemporalUnits(o, B)),
+    c,
+  );
+}
+function differenceZonedDateTimeWithRounding(e, t, o, n, r, a) {
+  if (!isDateUnit(o)) return differenceInstant(e.U, t.U, n, r, a);
+  const i = differenceZonedDateTime(e, t, o);
+  return r === K && 1 === n
+    ? i
+    : roundRelativeDuration(
+        i,
+        e.U,
+        t.U,
+        getIsoDateTimeForZonedDateTimeSlot(e),
+        e.P,
+        e.Y,
+        o,
+        n,
+        r,
+        a,
+      );
+}
+function differenceTemporalZonedDateTime(e, t, o, n) {
+  const r = toTemporalZonedDateTime(o);
+  calendarEquals(t.Y, r.Y) || throwRangeError(pe);
+  const a = getDifferenceSettings(e, getOptionsObject(n), d, [], K, J);
+  return isDateUnit(a.L)
+    ? (timeZoneEquals(t.P, r.P) || throwRangeError("time zone mismatch"),
+      compareEpochNanoseconds(t.U, r.U)
+        ? createTemporalDuration(
+            applySignToDurationSlot(
+              temporalDurationFromInternal(
+                differenceZonedDateTimeWithRounding(t, r, a.L, a.V, a.H, a.q),
+                J,
+              ),
+              e,
+            ),
+          )
+        : createTemporalDuration(createTemporalDurationSlot([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])))
+    : createTemporalDuration(
+        applySignToDurationSlot(
+          temporalDurationFromInternal(differenceInstant(t.U, r.U, a.V, a.H, a.q), a.L),
+          e,
+        ),
+      );
+}
+function addDurationToZonedDateTime(e, t, o, n) {
+  return createTemporalZonedDateTime(
+    addZonedDateTime(
+      t,
+      toInternalDurationRecord(applySignToDurationSlot(toTemporalDuration(o), e)),
+      getTemporalOverflowOption(getOptionsObject(n)),
+    ),
+    t.P,
+    t.Y,
+  );
+}
+function getOffsetNanosecondsForZonedDateTimeSlot(e) {
+  return (e.W ??= getOffsetNanosecondsFor(e.P, e.U));
+}
+function getIsoDateTimeForZonedDateTimeSlot(e) {
+  return getIsoDateTimeFromOffsetNanoseconds(e.U, getOffsetNanosecondsForZonedDateTimeSlot(e));
+}
+function createTemporalZonedDateTimeFromSlot(e, t = Object.create(Pe.prototype)) {
+  return (be.set(t, e), t);
+}
+function calendarIsoToDateForZonedDateTimeSlot(e) {
+  return calendarIsoToDate(e.Y, getIsoDateTimeForZonedDateTimeSlot(e).o);
+}
+function getInternalSlotForZonedDateTime(e) {
+  return be.get(e);
+}
+function getInternalSlotOrThrowForZonedDateTime(e) {
+  const t = getInternalSlotForZonedDateTime(e);
+  return (t || throwTypeError(ge), t);
+}
+function isZonedDateTime(e) {
+  return !!getInternalSlotForZonedDateTime(e);
+}
+function createLruCache(e) {
+  const t = new Map();
+  return {
+    C(e) {
+      if (t.has(e)) {
+        const o = t.get(e);
+        return (t.delete(e), t.set(e, o), o);
+      }
+    },
+    B(o, n) {
+      (t.size >= e && t.delete(t.keys().next().value), t.set(o, n));
+    },
+  };
+}
+function utcEpochMilliseconds(e, t, o, n = 0, a = 0, i = 0, c = 0) {
+  return isoDateToEpochDays(e, t - 1, o) * r + Date.UTC(1970, 0, 1, n, a, i, c);
+}
+function clampEpochSecond(e) {
+  return clamp(e, -1e10, 1 / 0);
+}
+function getNamedTimeZoneOffsetNanosecondsForEpochSecond(t, o, n) {
+  if ("UTC" === t) return 0;
+  const r = clampEpochSecond(o),
+    a = (Ne[t] ||= createLruCache(5e3)),
+    i = a.C(r);
+  if (void 0 !== i) return i;
+  const c = getFormatterForTimeZone(t).formatToParts(1e3 * r),
+    s =
+      (utcEpochMilliseconds(
+        ...["year", "month", "day", "hour", "minute", "second"].map((e) =>
+          toIntegerIfIntegral(c.find((t) => t.type === e).value),
+        ),
+      ) -
+        1e3 * r) *
+      e;
+  return (n || a.B(r, s), s);
+}
+function getFormatterForTimeZone(e) {
+  return (Re[e] ||= new Nt("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) {
+  return formatUtcOffsetNanoseconds(e * t);
+}
+function formatUtcOffsetNanoseconds(e) {
+  const n = Math.abs(e);
+  return `${e < 0 ? "-" : "+"}${formatTimeString(divFloor(n, o), modFloor(divFloor(n, t), 60), modFloor(divFloor(n, 1e9), 60), 0, n % t ? void 0 : D)}`;
+}
+function formatDateTimeUtcOffsetRounded(e) {
+  return formatOffsetTimeZoneIdentifier(roundNumberToIncrement(e, t, Z) / t);
+}
+function toTemporalTimeZoneIdentifier(e) {
+  if (isZonedDateTime(e)) return getInternalSlotOrThrowForZonedDateTime(e).P;
+  validateString(e);
+  const t = ((e) => {
+    if (isTimeZoneIdentifier(e)) return parseTimeZoneIdentifier(e);
+    const t = parseIsoDateTime(e, [et, tt, ot, nt, rt, at]).P,
+      o = t.R || (t.Z && "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) {
+  return 1 === e.length
+    ? e[0]
+    : (n === I && throwRangeError("ambiguity / gaps in local time"),
+      getNamedTimeZoneEpochCandidates(t, o).map(validateEpochNanoseconds)[
+        n === g ? +!e[0] : +(n === f)
+      ]);
+}
+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.F,
+              t.p.S,
+              t.p.$ - parseDateTimeUtcOffset(e),
+            ),
+          ),
+        ),
+      ]
+    : ((e, t) =>
+        getNamedTimeZoneEpochCandidates(e, t).filter(
+          (o) =>
+            !compareEpochNanoseconds(
+              addNanosecondsToEpochSeconds(o, getOffsetNanosecondsFor(e, o)),
+              getUtcEpochNanoseconds(t),
+            ),
+        ))(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) / t } : { 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 = e;
+    return combineIsoDateAndTimeRecord(epochDaysToIsoDate(t[0]), balanceTime(0, 0, 0, 0, 0, t[1]));
+  })(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[yt.D], t[yt.I], t[yt.O], t[yt.F], t[yt.S], t[yt.$], o),
+  );
+}
+function toTemporalDateTime(e, t) {
+  if (isObject(e)) {
+    if (isPlainDateTime(e)) {
+      getTemporalOverflowOption(getOptionsObject(t));
+      const o = getInternalSlotOrThrowForPlainDateTime(e);
+      return createTemporalDateTime(o._, o.Y);
+    }
+    if (isZonedDateTime(e)) {
+      const o = getInternalSlotOrThrowForZonedDateTime(e);
+      return (
+        getTemporalOverflowOption(getOptionsObject(t)),
+        createTemporalDateTime(getIsoDateTimeForZonedDateTimeSlot(o), o.Y)
+      );
+    }
+    if (isPlainDate(e)) {
+      getTemporalOverflowOption(getOptionsObject(t));
+      const o = getInternalSlotOrThrowForPlainDate(e);
+      return createTemporalDateTime(combineIsoDateAndTimeRecord(o.o, midnightTimeRecord()), o.Y);
+    }
+    const o = getTemporalCalendarIdentifierWithIsoDefault(e);
+    return createTemporalDateTime(
+      interpretTemporalDateTimeFields(
+        o,
+        prepareCalendarFields(
+          o,
+          e,
+          [yt.t, yt.u, yt.v, yt.T, yt.D, yt.I, yt.O, yt.F, yt.S, yt.$],
+          [],
+        ),
+        getTemporalOverflowOption(getOptionsObject(t)),
+      ),
+      o,
+    );
+  }
+  validateString(e);
+  const o = parseIsoDateTime(e, [tt]),
+    n = canonicalizeCalendar(o.Y || "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, c, s) {
+  const l = balanceTime(n, r, a, i, c, s);
+  return combineIsoDateAndTimeRecord(addDaysToIsoDate(createIsoDateRecord(e, t, o), l.K), l);
+}
+function createTemporalDateTime(e, t, o = Object.create($e.prototype)) {
+  return (Ze.set(o, { _: validateIsoDateTime(e), Y: t }), 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.F + 1e3 * e.p.S + e.p.$, 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 = Mt(r);
+  let i = t.o;
+  a === compareIsoDate(e.o, t.o) &&
+    ((i = addDaysToIsoDate(i, a)), (r = add24HourDaysToTimeDuration(r, -a)));
+  const c = largerOfTwoTemporalUnits(B, n),
+    s = calendarDateUntil(o, e.o, i, c);
+  return (
+    n !== c && ((r = add24HourDaysToTimeDuration(r, s.K)), (s.K = 0)),
+    combineDateAndTimeDuration(s, r)
+  );
+}
+function differencePlainDateTimeWithRounding(e, t, o, n, r, a, i) {
+  if (!compareIsoDateTime(e, t))
+    return combineDateAndTimeDuration(zeroDateDuration(), createTimeDurationFromSeconds(0));
+  (validateIsoDateTime(e), validateIsoDateTime(t));
+  const c = differenceISODateTime(e, t, o, n);
+  return a === K && 1 === r
+    ? c
+    : roundRelativeDuration(
+        c,
+        getUtcEpochNanoseconds(e),
+        getUtcEpochNanoseconds(t),
+        e,
+        void 0,
+        o,
+        n,
+        r,
+        a,
+        i,
+      );
+}
+function differenceTemporalPlainDateTime(e, t, o, n) {
+  const r = getInternalSlotOrThrowForPlainDateTime(toTemporalDateTime(o));
+  calendarEquals(t.Y, r.Y) || throwRangeError(pe);
+  const a = getDifferenceSettings(e, getOptionsObject(n), d, [], K, B);
+  return compareIsoDateTime(t._, r._)
+    ? createTemporalDuration(
+        applySignToDurationSlot(
+          temporalDurationFromInternal(
+            differencePlainDateTimeWithRounding(t._, r._, t.Y, a.L, a.V, a.H, a.q),
+            a.L,
+          ),
+          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),
+    c = addTime(t._.p, i.p);
+  return createTemporalDateTime(
+    combineIsoDateAndTimeRecord(
+      calendarDateAdd(t.Y, t._.o, adjustDateDurationRecord(i.A, c.K), a),
+      c,
+    ),
+    t.Y,
+  );
+}
+function validateIsoDateTime(e) {
+  return (
+    ((e) => {
+      const t = isoDateRecordToEpochDays(e.o);
+      return (
+        Math.abs(t) <= 1e8 || (-100000001 === t && !!compareTimeRecord(e.p, midnightTimeRecord()))
+      );
+    })(e) || throwRangeError(Te),
+    e
+  );
+}
+function getInternalSlotForPlainDateTime(e) {
+  return Ze.get(e);
+}
+function getInternalSlotOrThrowForPlainDateTime(e) {
+  const t = getInternalSlotForPlainDateTime(e);
+  return (t || throwTypeError(ge), t);
+}
+function isPlainDateTime(e) {
+  return !!getInternalSlotForPlainDateTime(e);
+}
+function createTimeRecord(e, t, o, n, r, a, i = 0) {
+  return { D: e, I: t, O: o, F: n, S: r, $: 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.F - e.F,
+    t.S - e.S,
+    t.$ - e.$,
+  );
+}
+function toTemporalTime(e, t) {
+  if (isObject(e))
+    return isPlainTime(e)
+      ? (getTemporalOverflowOption(getOptionsObject(t)), getInternalSlotOrThrowForPlainTime(e))
+      : isPlainDateTime(e)
+        ? (getTemporalOverflowOption(getOptionsObject(t)),
+          getInternalSlotOrThrowForPlainDateTime(e)._.p)
+        : isZonedDateTime(e)
+          ? (getTemporalOverflowOption(getOptionsObject(t)),
+            getIsoDateTimeForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(e)).p)
+          : regulateTime(
+              ...toTemporalTimeRecord(e),
+              getTemporalOverflowOption(getOptionsObject(t)),
+            );
+  validateString(e);
+  const o = parseIsoDateTime(e, [nt]);
+  return (getTemporalOverflowOption(getOptionsObject(t)), o.p);
+}
+function toTimeRecordOrMidnight(e) {
+  return void 0 === e ? midnightTimeRecord() : toTemporalTime(e);
+}
+function regulateTime(e, t, o, n, r, a, i) {
+  return i === h
+    ? 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(ue), 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),
+      F: modFloor(n, 1e3),
+      S: modFloor(r, 1e3),
+      $: modFloor(a, 1e3),
+      K: divFloor(e, 24),
+    }
+  );
+}
+function createTemporalTime(e, t = Object.create(Ce.prototype)) {
+  return (Ye.set(t, e), t);
+}
+function toTemporalTimeRecord(e, t = !1) {
+  let o = !1;
+  const n = [yt.D, yt.S, yt.F, yt.I, yt.$, yt.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.F + 1e3 * e.S + e.$, t);
+}
+function compareTimeRecord(e, t) {
+  return (
+    compare(e.D, t.D) ||
+    compare(e.I, t.I) ||
+    compare(e.O, t.O) ||
+    compare(e.F, t.F) ||
+    compare(e.S, t.S) ||
+    compare(e.$, t.$)
+  );
+}
+function addTime(e, t) {
+  const o = t,
+    n = balanceTime(e.D, e.I, e.O, e.F, e.S, e.$ + o[1]);
+  return ((n.K += o[0]), n);
+}
+function roundTime(e, n, r, a) {
+  const i = nanosecondsForTimeUnit(clamp(r - 1, 3, 8)),
+    c = e.D * o + e.I * t + 1e9 * e.O + 1e6 * e.F + 1e3 * e.S + e.$;
+  return balanceTime(
+    0,
+    0,
+    0,
+    0,
+    0,
+    divFloor(c, i) * i + roundNumberToIncrement(modFloor(c, i), n * nanosecondsForTimeUnit(r), a),
+  );
+}
+function differenceTemporalPlainTime(e, t, o, n) {
+  const r = toTemporalTime(o),
+    a = getDifferenceSettings(e, getOptionsObject(n), l, [], K, J);
+  return createTemporalDuration(
+    applySignToDurationSlot(
+      temporalDurationFromInternal(
+        combineDateAndTimeDuration(
+          zeroDateDuration(),
+          roundTimeDuration(differenceTime(t, r), a.V, a.H, a.q),
+        ),
+        a.L,
+      ),
+      e,
+    ),
+  );
+}
+function addDurationToTime(e, t, o) {
+  return createTemporalTime(
+    addTime(t, toInternalDurationRecord(applySignToDurationSlot(toTemporalDuration(o), e)).p),
+  );
+}
+function getInternalSlotOrThrowForPlainTime(e) {
+  const t = Ye.get(e);
+  return (t || throwTypeError(ge), t);
+}
+function isPlainTime(e) {
+  return Ye.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) {
+  return it.some((t) => {
+    const o = e.match(t);
+    return o && isSemanticallyValid(o.groups);
+  });
+}
+function isTimeZoneIdentifier(e) {
+  return ct.test(e);
+}
+function parseAnnotationsAndGetCalendar(e) {
+  let t,
+    o = !1;
+  for (const n of e.matchAll(Qe)) {
+    const e = !!n[1];
+    "u-ca" === n[2]
+      ? t
+        ? (e || o) && throwRangeError(me)
+        : ((t = n[3]), e && (o = !0))
+      : e && throwRangeError(me);
+  }
+  return t;
+}
+function getTimeRecordFromMatchedGroups(e) {
+  const t = (e.g || "").padEnd(9, "0");
+  return createTimeRecord(
+    we(e.d || 0),
+    we(e.e || 0),
+    clamp(we(e.f || 0), 0, 59),
+    we(t.slice(0, 3)),
+    we(t.slice(3, 6)),
+    we(t.slice(6)),
+  );
+}
+function isSemanticallyValid(e) {
+  return (
+    "-000000" !== (e.a || e.l) &&
+    (!e.a || isValidIsoDate(we(e.a), we(e.b), we(e.c))) &&
+    (!e.n || isValidIsoDate(1972, we(e.m), we(e.n)))
+  );
+}
+function parseIsoDateTime(e, t) {
+  for (const o of t) {
+    const t = e.match(o);
+    if (!t || !isSemanticallyValid(t.groups) || (o === nt && isAmbiguousTemporalTimeString(e)))
+      continue;
+    const n = t.groups,
+      r = parseAnnotationsAndGetCalendar(n.k || "");
+    return (
+      n.m && r && "iso8601" !== asciiLowerCase(r) && throwRangeError(me),
+      {
+        t: mapUnlessUndefined(n.a || n.l, we),
+        u: we(n.b || n.m || 1),
+        T: we(n.c || n.n || 1),
+        p: n.d ? getTimeRecordFromMatchedGroups(n) : void 0,
+        P: { Z: !!n.i, N: n.h, R: n.j },
+        Y: r,
+      }
+    );
+  }
+  throwRangeError(me);
+}
+function parseDateTimeUtcOffset(e) {
+  const o = e.match(lt);
+  return (
+    o || throwRangeError(me),
+    we(`${o[1]}1`) *
+      (36e11 * we(o[2]) +
+        we(o[4] || "") * t +
+        1e9 * we(o[5] || "") +
+        we((o[6] || "").padEnd(9, "0")) +
+        0)
+  );
+}
+function hasUtcOffsetSubMinuteParts(e) {
+  return !!e.match(lt)[5];
+}
+function toTemporalMonthDay(e, t) {
+  if (isObject(e)) {
+    const o = getInternalSlotForPlainMonthDay(e);
+    if (o)
+      return (getTemporalOverflowOption(getOptionsObject(t)), createTemporalMonthDay(o.o, o.Y));
+    const n = getTemporalCalendarIdentifierWithIsoDefault(e);
+    return createTemporalMonthDay(
+      calendarMonthDayFromFields(
+        n,
+        prepareCalendarFields(n, e, [yt.t, yt.u, yt.v, yt.T], []),
+        getTemporalOverflowOption(getOptionsObject(t)),
+      ),
+      n,
+    );
+  }
+  validateString(e);
+  const o = parseIsoDateTime(e, [rt]),
+    n = canonicalizeCalendar(o.Y || "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)), u),
+            h,
+          ),
+      n,
+    )
+  );
+}
+function createTemporalMonthDay(e, t, o = Object.create(mt.prototype)) {
+  return (dt.set(o, { o: validateIsoDate(e), Y: t }), o);
+}
+function temporalMonthDayToString(e, t) {
+  return `${t === U || t === W || "iso8601" !== e.Y ? `${padIsoYear(e.o.t)}-` : ""}${toZeroPaddedDecimalString(e.o.u, 2)}-${toZeroPaddedDecimalString(e.o.T, 2)}${formatCalendarAnnotation(e.Y, t)}`;
+}
+function getInternalSlotForPlainMonthDay(e) {
+  return dt.get(e);
+}
+function getInternalSlotOrThrowForPlainMonthDay(e) {
+  const t = getInternalSlotForPlainMonthDay(e);
+  return (t || throwTypeError(ge), 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.Y));
+    const n = getTemporalCalendarIdentifierWithIsoDefault(e);
+    return createTemporalYearMonth(
+      calendarYearMonthFromFields(
+        n,
+        prepareCalendarFields(n, e, [yt.t, yt.u, yt.v], []),
+        getTemporalOverflowOption(getOptionsObject(t)),
+      ),
+      n,
+    );
+  }
+  validateString(e);
+  const o = parseIsoDateTime(e, [at]),
+    n = canonicalizeCalendar(o.Y || "iso8601");
+  return (
+    getTemporalOverflowOption(getOptionsObject(t)),
+    createTemporalYearMonth(
+      calendarYearMonthFromFields(
+        n,
+        isoDateToFields(n, validateIsoYearMonth(createIsoDateRecord(o.t, o.u, o.T)), m),
+        h,
+      ),
+      n,
+    )
+  );
+}
+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 (ut.set(o, { o: validateIsoYearMonth(e), Y: t }), o);
+}
+function temporalYearMonthToString(e, t) {
+  return `${padIsoYear(e.o.t)}-${toZeroPaddedDecimalString(e.o.u, 2)}${t === U || t === W || "iso8601" !== e.Y ? `-${toZeroPaddedDecimalString(e.o.T, 2)}` : ""}${formatCalendarAnnotation(e.Y, t)}`;
+}
+function differenceTemporalPlainYearMonth(e, t, o, n) {
+  const r = getInternalSlotOrThrowForPlainYearMonth(toTemporalYearMonth(o));
+  calendarEquals(t.Y, r.Y) || throwRangeError(pe);
+  const a = getDifferenceSettings(e, getOptionsObject(n), s, [q, B], H, x);
+  if (!compareIsoDate(t.o, r.o))
+    return createTemporalDuration(createTemporalDurationSlot([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
+  const i = calendarDateFromFields(
+      t.Y,
+      createNullPrototypeObject({ ...isoDateToFields(t.Y, t.o, m), [yt.T]: 1 }),
+      h,
+    ),
+    c = calendarDateFromFields(
+      t.Y,
+      createNullPrototypeObject({ ...isoDateToFields(t.Y, r.o, m), [yt.T]: 1 }),
+      h,
+    );
+  let l = combineDateAndTimeDuration(
+    adjustDateDurationRecord(calendarDateUntil(t.Y, i, c, a.L), 0, 0),
+    createTimeDurationFromSeconds(0),
+  );
+  if (a.H !== H || 1 !== a.V) {
+    const e = combineIsoDateAndTimeRecord(i, midnightTimeRecord());
+    l = roundRelativeDuration(
+      l,
+      getUtcEpochNanoseconds(e),
+      getUtcEpochNanoseconds(combineIsoDateAndTimeRecord(c, midnightTimeRecord())),
+      e,
+      void 0,
+      t.Y,
+      a.L,
+      a.V,
+      a.H,
+      a.q,
+    );
+  }
+  return createTemporalDuration(applySignToDurationSlot(temporalDurationFromInternal(l, B), e));
+}
+function addDurationToYearMonth(e, t, o, n) {
+  const r = toInternalDurationRecord(applySignToDurationSlot(toTemporalDuration(o), e)),
+    a = getTemporalOverflowOption(getOptionsObject(n));
+  return (
+    (r.A.X || r.A.K || signTimeDuration(r.p)) &&
+      throwRangeError("duration can contain only years and months"),
+    createTemporalYearMonth(
+      calendarYearMonthFromFields(
+        t.Y,
+        isoDateToFields(
+          t.Y,
+          calendarDateAdd(
+            t.Y,
+            calendarDateFromFields(
+              t.Y,
+              createNullPrototypeObject({ ...isoDateToFields(t.Y, t.o, m), [yt.T]: 1 }),
+              h,
+            ),
+            r.A,
+            a,
+          ),
+          m,
+        ),
+        a,
+      ),
+      t.Y,
+    )
+  );
+}
+function validateIsoYearMonth(e) {
+  return (((e) => isWithin(12 * e.t + e.u, -3261848, 3309129))(e) || throwRangeError(Te), e);
+}
+function getInternalSlotForPlainYearMonth(e) {
+  return ut.get(e);
+}
+function getInternalSlotOrThrowForPlainYearMonth(e) {
+  const t = getInternalSlotForPlainYearMonth(e);
+  return (t || throwTypeError(ge), 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(ht.prototype)) {
+  return (Dt.set(o, { o: validateIsoDate(e), Y: t }), o);
+}
+function toTemporalDate(e, t) {
+  if (isObject(e)) {
+    if (isPlainDate(e)) {
+      getTemporalOverflowOption(getOptionsObject(t));
+      const o = getInternalSlotOrThrowForPlainDate(e);
+      return createTemporalDate(o.o, o.Y);
+    }
+    if (isZonedDateTime(e)) {
+      getTemporalOverflowOption(getOptionsObject(t));
+      const o = getInternalSlotOrThrowForZonedDateTime(e);
+      return createTemporalDate(getIsoDateTimeForZonedDateTimeSlot(o).o, o.Y);
+    }
+    if (isPlainDateTime(e)) {
+      getTemporalOverflowOption(getOptionsObject(t));
+      const o = getInternalSlotOrThrowForPlainDateTime(e);
+      return createTemporalDate(o._.o, o.Y);
+    }
+    const o = getTemporalCalendarIdentifierWithIsoDefault(e);
+    return createTemporalDate(
+      calendarDateFromFields(
+        o,
+        prepareCalendarFields(o, e, [yt.t, yt.u, yt.v, yt.T], []),
+        getTemporalOverflowOption(getOptionsObject(t)),
+      ),
+      o,
+    );
+  }
+  validateString(e);
+  const o = parseIsoDateTime(e, [tt]),
+    n = canonicalizeCalendar(o.Y || "iso8601");
+  return (
+    getTemporalOverflowOption(getOptionsObject(t)),
+    createTemporalDate(createIsoDateRecord(o.t, o.u, o.T), n)
+  );
+}
+function regulateIsoDate(e, t, o, n) {
+  return n === h
+    ? createIsoDateRecord(e, (t = clamp(t, 1, 12)), clamp(o, 1, isoDaysInMonth(e, t)))
+    : (isValidIsoDate(e, t, o) || throwRangeError(Te), 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.Y, t)}`;
+}
+function compareIsoDate(e, t) {
+  return compare(isoDateRecordToEpochDays(e), isoDateRecordToEpochDays(t));
+}
+function differenceTemporalPlainDate(e, t, o, n) {
+  const r = getInternalSlotOrThrowForPlainDate(toTemporalDate(o));
+  calendarEquals(t.Y, r.Y) || throwRangeError(pe);
+  const a = getDifferenceSettings(e, getOptionsObject(n), s, [], B, B);
+  if (!compareIsoDate(t.o, r.o))
+    return createTemporalDuration(createTemporalDurationSlot([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
+  let i = combineDateAndTimeDuration(
+    calendarDateUntil(t.Y, t.o, r.o, a.L),
+    createTimeDurationFromSeconds(0),
+  );
+  if (a.H !== B || 1 !== a.V) {
+    const e = combineIsoDateAndTimeRecord(t.o, midnightTimeRecord());
+    i = roundRelativeDuration(
+      i,
+      getUtcEpochNanoseconds(e),
+      getUtcEpochNanoseconds(combineIsoDateAndTimeRecord(r.o, midnightTimeRecord())),
+      e,
+      void 0,
+      t.Y,
+      a.L,
+      a.V,
+      a.H,
+      a.q,
+    );
+  }
+  return createTemporalDuration(applySignToDurationSlot(temporalDurationFromInternal(i, B), e));
+}
+function addDurationToDate(e, t, o, n) {
+  return createTemporalDate(
+    calendarDateAdd(
+      t.Y,
+      t.o,
+      ((e) => {
+        const t = toInternalDurationRecordWith24HourDays(e);
+        return createDateDurationRecord(t.A.ee, t.A.te, t.A.X, t.p[0]);
+      })(applySignToDurationSlot(toTemporalDuration(o), e)),
+      getTemporalOverflowOption(getOptionsObject(n)),
+    ),
+    t.Y,
+  );
+}
+function getInternalSlotForPlainDate(e) {
+  return Dt.get(e);
+}
+function getInternalSlotOrThrowForPlainDate(e) {
+  const t = getInternalSlotForPlainDate(e);
+  return (t || throwTypeError(ge), t);
+}
+function isPlainDate(e) {
+  return !!getInternalSlotForPlainDate(e);
+}
+function validateIsoDate(e) {
+  return (
+    validateIsoDateTime(combineIsoDateAndTimeRecord(e, createTimeRecord(12, 0, 0, 0, 0, 0))), e
+  );
+}
+function formatToParts(e, t) {
+  return (pt[e] ||= new Intl.DateTimeFormat("en", {
+    year: "numeric",
+    month: "numeric",
+    day: "numeric",
+    calendar: e,
+    timeZone: "UTC",
+  })).formatToParts(t * r);
+}
+function extractYearMonthDay(e, t) {
+  const o = formatToParts(e, t),
+    n = ["year", "month", "day"].map((e) => toIntegerIfIntegral(o.find((t) => t.type === e).value));
+  return { t: n[0], u: n[1], T: n[2] };
+}
+function yearMonthDay(e, t) {
+  const o = ft[e].C(t);
+  if (o) return o;
+  const n = ((e, t) => {
+    const o = formatToParts(e, t),
+      n = ["relatedYear", "month", "day"].map((e) => o.find((t) => t.type === e).value);
+    return {
+      t: toIntegerIfIntegral(n[0]),
+      v: createMonthCode(parseInt(n[1]), /bis/.test(n[1])),
+      T: toIntegerIfIntegral(n[2]),
+    };
+  })(e, t);
+  return (ft[e].B(t, n), n);
+}
+function getNewYear(e, t) {
+  let o = gt[e].C(t);
+  if (o) return o;
+  let n = isoDateToEpochDays(
+      t,
+      0,
+      1985 === t ? 53 : Math.floor(modFloor(-10.8822 * t + 16, 29.53)) + 23,
+    ),
+    r = yearMonthDay(e, n);
+  for (let o = 0; "M01" !== r.v; o++) {
+    if (o > 20) throw new Error("unexpected calendar error");
+    ((n += r.t < t ? 31 - r.T : -r.T), (r = yearMonthDay(e, n)));
+  }
+  return (gt[e].B(t, n - r.T + 1), n - r.T + 1);
+}
+function ordinalMonthToMonthCode(e, t, o) {
+  return yearMonthDay(e, getNewYear(e, t) + 30 * (o - 1)).v;
+}
+function calendarIntegersToEpochDays$6(e, t, o, n) {
+  const r = getNewYear(e, t) + 30 * (o - 1);
+  return r - yearMonthDay(e, r).T + n;
+}
+function daysInMonth$5(e, t, o) {
+  return calendarIntegersToEpochDays$6(e, t, o + 1, 1) - calendarIntegersToEpochDays$6(e, t, o, 1);
+}
+function monthsInYear(e, t) {
+  return getNewYear(e, t + 1) - getNewYear(e, t) > 360 ? 13 : 12;
+}
+function epochDaysToDate$6(e, t) {
+  return {
+    oe: void 0,
+    ne: void 0,
+    get t() {
+      return yearMonthDay(e, t).t;
+    },
+    get u() {
+      const o = yearMonthDay(e, t);
+      return Math.round((t - o.T - getNewYear(e, o.t)) / 29.53) + 1;
+    },
+    get v() {
+      return yearMonthDay(e, t).v;
+    },
+    get T() {
+      return yearMonthDay(e, t).T;
+    },
+    re: isoDayOfWeek(epochDaysToIsoDate(t)),
+    get ae() {
+      const o = yearMonthDay(e, t).t;
+      return t - getNewYear(e, o) + 1;
+    },
+    ie: { ce: void 0, t: void 0 },
+    se: 7,
+    get le() {
+      const o = yearMonthDay(e, t);
+      return daysInMonth$5(e, o.t, Math.round((t - o.T - getNewYear(e, o.t)) / 29.53) + 1);
+    },
+    get de() {
+      const o = yearMonthDay(e, t).t;
+      return getNewYear(e, o + 1) - getNewYear(e, o);
+    },
+    get me() {
+      return monthsInYear(e, yearMonthDay(e, t).t);
+    },
+    get ue() {
+      return monthsInYear(e, yearMonthDay(e, t).t) > 12;
+    },
+  };
+}
+function epoch$1(e) {
+  return "coptic" === e ? -615924 : "ethioaa" === e ? -2725608 : -716733;
+}
+function mathematicalInLeapYear$2(e) {
+  return +!((e + 1) % 4);
+}
+function daysInMonth$4(e, t) {
+  return 13 === t ? 5 + mathematicalInLeapYear$2(e) : 30;
+}
+function calendarIntegersToEpochDays$5(e, t, o, n) {
+  return Math.floor(365.25 * t) + 30 * (o - 1) + n + epoch$1(e);
+}
+function isLeapYear$2(e) {
+  return modFloor(7 * e + 1, 19) < 7;
+}
+function monthNumber(e, t) {
+  return divFloor(235 * e - 234, 19) + t;
+}
+function newYearEpochDays(e) {
+  const t = monthNumber(e, 1) - 1,
+    o = modFloor(13753 * t + 5604, 25920);
+  let n = 29 * t - 2092590 + divFloor(13753 * t + 5604, 25920);
+  (o >= 19440 ||
+    (!isLeapYear$2(e) && 5 === modFloor(n, 7) && o >= 9924) ||
+    (isLeapYear$2(e - 1) && 4 === modFloor(n, 7) && o >= 16789)) &&
+    n++;
+  const r = modFloor(n, 7);
+  return ((1 !== r && 3 !== r && 6 !== r) || n++, n);
+}
+function calendarIntegersToEpochDays$4(e, t, o) {
+  const n = ((newYearEpochDays(e + 1) - newYearEpochDays(e)) % 30) - 24;
+  return (
+    newYearEpochDays(e) +
+    (isLeapYear$2(e) ? Math.round(29.53 * (t - 1) + 0.35) : Math.ceil(29.5 * (t - 1))) +
+    (1 === n && t >= 3 ? 1 : -1 === n && t >= 4 ? -1 : 0) +
+    o -
+    1
+  );
+}
+function daysInMonth$3(e, t) {
+  return calendarIntegersToEpochDays$4(e, t + 1, 1) - calendarIntegersToEpochDays$4(e, t, 1);
+}
+function mathematicalInLeapYear$1(e) {
+  return mathematicalInLeapYear(e + 78);
+}
+function firstDayOfYear(e) {
+  return isoDateToEpochDays(e + 78, 2, 22 - mathematicalInLeapYear$1(e));
+}
+function daysInMonth$2(e, t) {
+  return t > 6 || (1 === t && !mathematicalInLeapYear$1(e)) ? 30 : 31;
+}
+function calendarIntegersToEpochDays$3(e, t, o) {
+  return (
+    firstDayOfYear(e) -
+    1 +
+    30 * (t - 1) +
+    o +
+    clamp(t - 1, 0, 6) +
+    (1 === t || mathematicalInLeapYear$1(e) ? 0 : -1)
+  );
+}
+function epoch(e) {
+  return "islamic-civil" === e ? -492148 : -492149;
+}
+function isLeapYear$1(e) {
+  return modFloor(11 * (e + 4), 30) < 11;
+}
+function daysInMonth$1(e, t) {
+  return 12 === t ? (isLeapYear$1(e) ? 30 : 29) : 29 + (t % 2);
+}
+function calendarIntegersToEpochDays$2(e, t, o, n) {
+  return (
+    epoch(e) + 354 * (t - 1) + divFloor(11 * (t + 3), 30) - 1 + Math.ceil(29.5 * (o - 1)) + n - 1
+  );
+}
+function epochDaysToDate$2(e, t) {
+  let o = divFloor(30 * (t - epoch(e)), 10631) + 2;
+  for (; calendarIntegersToEpochDays$2(e, o, 1, 1) > t; o--);
+  let n = 12;
+  for (; calendarIntegersToEpochDays$2(e, o, n, 1) > t; n--);
+  return {
+    oe: o > 0 ? "ah" : "bh",
+    ne: o > 0 ? o : 1 - o,
+    t: o,
+    u: n,
+    v: createMonthCode(n),
+    T: t - calendarIntegersToEpochDays$2(e, o, n, 1) + 1,
+    re: isoDayOfWeek(epochDaysToIsoDate(t)),
+    ae: t - calendarIntegersToEpochDays$2(e, o, 1, 1) + 1,
+    ie: { ce: void 0, t: void 0 },
+    se: 7,
+    le: daysInMonth$1(o, n),
+    de: isLeapYear$1(o) ? 355 : 354,
+    me: 12,
+    ue: isLeapYear$1(o),
+  };
+}
+function getYearMonthDay(e) {
+  const t = It.C(e);
+  if (t) return t;
+  const o = extractYearMonthDay("islamic-umalqura", e);
+  return (It.B(e, o), o);
+}
+function getFirstDayOfMonth(e, t) {
+  const o = balanceIsoYearMonth(e, t),
+    n = calendarIntegersToEpochDays$2("islamic-civil", o.t, o.u, 1);
+  return isWithin(12 * e + t, 15540, 19260) ? n + 14 - getYearMonthDay(n + 14).T + 1 : n;
+}
+function calendarIntegersToEpochDays$1(e, t, o) {
+  return getFirstDayOfMonth(e, t) + o - 1;
+}
+function constrainDay$2(e, t, o) {
+  return o < 30
+    ? o
+    : clamp(o, 1, ((e, t) => getFirstDayOfMonth(e, t + 1) - getFirstDayOfMonth(e, t))(e, t));
+}
+function startOfYear(e) {
+  const t = Ot.C(e);
+  if (t) return t;
+  const o = isoDateToEpochDays(e + 621, 3, 1),
+    n = o - extractYearMonthDay("persian", o).T + 1;
+  return (Ot.B(e, n), n);
+}
+function dayOfYearFromMonthDay(e, t) {
+  return 30 * (e - 1) + t + clamp(e - 1, 0, 6);
+}
+function calendarIntegersToEpochDays(e, t, o) {
+  return startOfYear(e) - 1 + 30 * (t - 1) + o + clamp(t - 1, 0, 6);
+}
+function isLeapYear(e) {
+  return startOfYear(e + 1) - startOfYear(e) > 365;
+}
+function getDate(e) {
+  const t = isoDateRecordToEpochDays(e);
+  let o = 30 * e.u + e.T <= 105 ? e.t - 622 : e.t - 621,
+    n = startOfYear(o);
+  n > t && (o--, (n = startOfYear(o)));
+  const r = ((e) => {
+    const t = e <= 186 ? divFloor(e - 1, 31) + 1 : divFloor(e - 7, 30) + 1;
+    return [t, e - dayOfYearFromMonthDay(t, 1) + 1];
+  })(t - n + 1);
+  return { t: o, u: r[0], T: r[1], ae: t - n + 1 };
+}
+function canonicalizeCalendar(e) {
+  return "islamicc" === (e = asciiLowerCase(e))
+    ? "islamic-civil"
+    : "ethiopic-amete-alem" === e
+      ? "ethioaa"
+      : St[e]
+        ? e
+        : throwRangeError(((e) => `calendar not supported in this polyfill: ${e}`)(e));
+}
+function calendarDateAdd(e, t, o, n) {
+  if (isIsoLikeCalendar(e) || (!o.ee && !o.te))
+    return ((e, t, o) => {
+      const n = balanceIsoYearMonth(e.t + t.ee, e.u + t.te);
+      return validateIsoDate(addDaysToIsoDate(regulateIsoDate(n.t, n.u, e.T, o), 7 * t.X + t.K));
+    })(t, o, n);
+  const r = nonIsoCalendarIsoToDate(e, t),
+    a = r.t + o.ee,
+    i = balanceNonIsoYearMonth(
+      e,
+      a,
+      monthCodeToOrdinal(e, a, constrainMonthCode(e, a, r.v, n)) + o.te,
+    );
+  return validateIsoDate(
+    addDaysToIsoDate(
+      calendarIntegersToIso(e, i.t, i.u, constrainDay(e, i.t, i.u, r.T, n)),
+      7 * o.X + o.K,
+    ),
+  );
+}
+function compareSurpasses(e, t, o, n, r) {
+  return t !== r.t
+    ? e * (t - r.t) > 0
+    : o !== r.u && o !== r.v
+      ? e * ("string" == typeof o ? (o > r.v ? 1 : o < r.v ? -1 : 0) : o - r.u) > 0
+      : e * (n - r.T) > 0;
+}
+function nonIsoDateSurpasses(e, t, o, n, r, a) {
+  if (compareSurpasses(t, o.t + r, o.v, o.T, n)) return { Te: !0 };
+  const i = balanceNonIsoYearMonth(
+    e,
+    o.t + r,
+    monthCodeToOrdinal(e, o.t + r, constrainMonthCode(e, o.t + r, o.v, h)) + a,
+  );
+  return compareSurpasses(t, i.t, i.u, o.T, n) ? { Te: !0 } : { Te: !1, ...i };
+}
+function calendarDateUntil(e, t, o, n) {
+  const r = compareIsoDate(o, t);
+  if (isIsoLikeCalendar(e) || n === q || n === B || !r)
+    return ((e, t, o) => {
+      const n = compareIsoDate(t, e);
+      if (!n) return zeroDateDuration();
+      if (o === q || o === B) {
+        const n = isoDateToEpochDays(t.t, t.u - 1, t.T) - isoDateToEpochDays(e.t, e.u - 1, e.T);
+        return o === q
+          ? createDateDurationRecord(0, 0, divTrunc(n, 7) + 0, (n % 7) + 0)
+          : createDateDurationRecord(0, 0, 0, n);
+      }
+      const r = 12 * t.t + t.u - 12 * e.t - e.u - (n * (e.T - t.T) > 0 ? n : 0),
+        a = balanceIsoYearMonth(e.t, e.u + r),
+        i =
+          isoDateRecordToEpochDays(t) - isoDateRecordToEpochDays(regulateIsoDate(a.t, a.u, e.T, h));
+      return o === x
+        ? createDateDurationRecord(divTrunc(r, 12), (r % 12) + 0, 0, i)
+        : createDateDurationRecord(0, r, 0, i);
+    })(t, o, n);
+  const a = nonIsoCalendarIsoToDate(e, t),
+    i = nonIsoCalendarIsoToDate(e, o);
+  let c,
+    s = 0;
+  if (n === x) for (s = i.t - a.t; (c = nonIsoDateSurpasses(e, r, a, i, s, 0)).Te; s -= r);
+  const l =
+    ("hebrew" === e
+      ? ((d = (c || a).t), (m = (c || a).u), monthNumber(i.t, i.u) - monthNumber(d, m))
+      : "chinese" === e || "dangi" === e
+        ? (function (e, t, o, n, r) {
+            if (t === n) return r - o;
+            const a = calendarIntegersToEpochDays$6(e, t, o, 1),
+              i = calendarIntegersToEpochDays$6(e, n, r, 1),
+              c = sign(i - a);
+            if (Math.abs(i - a) <= 15e6) return Math.round((i - a) / 29.5306);
+            let s = 0,
+              l = a;
+            for (; (i - l) * c > 0; ) {
+              let t = l + clamp(15e6, 1, Math.abs(i - l)) * c;
+              ((t -= yearMonthDay(e, t).T - 1), (s += Math.round((t - l) / 29.5306)), (l = t));
+            }
+            return s;
+          })(e, (c || a).t, (c || a).u, i.t, i.u)
+        : (i.t - (c || a).t) * a.me + i.u - (c || a).u) - (r * (a.T - i.T) > 0 ? r : 0);
+  var d, m;
+  const u = nonIsoDateSurpasses(e, r, a, i, s, l);
+  return createDateDurationRecord(
+    s,
+    l,
+    0,
+    isoDateRecordToEpochDays(o) -
+      isoDateRecordToEpochDays(
+        calendarIntegersToIso(e, u.t, u.u, constrainDay(e, u.t, u.u, a.T, h)),
+      ),
+  );
+}
+function calendarDateToIso(e, t, o) {
+  const n = t[yt.t],
+    r = t[yt.u],
+    a = t[yt.v],
+    i = t[yt.T];
+  if (isIsoLikeCalendar(e))
+    return ((e, t) => regulateIsoDate(e[yt.t], e[yt.u], e[yt.T], t))(
+      { ...t, year: n + ("buddhist" === e ? -543 : "roc" === e ? 1911 : 0) },
+      o,
+    );
+  void 0 !== a && constrainMonthCode(e, n, a, o);
+  const c =
+    "chinese" === e || "dangi" === e
+      ? ((e, t, o) => (isWithin(o, 1, 12) ? o : clamp(o, 1, monthsInYear(e, t))))(e, n, r)
+      : clamp(r, 1, "hebrew" === e ? (isLeapYear$2(n) ? 13 : 12) : isCopticOrEthiopic(e) ? 13 : 12);
+  return (
+    c !== r && o === p && throwRangeError(Te),
+    calendarIntegersToIso(e, n, c, constrainDay(e, n, c, i, o))
+  );
+}
+function nonIsoCalendarIsoToDate(e, t) {
+  const o = isoDateRecordToEpochDays(t);
+  if (isIsoLikeCalendar(e)) {
+    const n = { ...isoCalendarIsoToDate(t), ie: { t: void 0, ce: void 0 } };
+    if ("japanese" === e) {
+      const r =
+          o >= 18017
+            ? "reiwa"
+            : o >= 6947
+              ? "heisei"
+              : o >= -15713
+                ? "showa"
+                : o >= -20974
+                  ? "taisho"
+                  : o >= -35428
+                    ? "meiji"
+                    : t.t > 0
+                      ? "ce"
+                      : "bce",
+        a = St[e].get(r);
+      return { oe: r, ne: "bce" === r ? 1 - t.t : t.t - a + 1, ...n };
+    }
+    return "gregory" === e
+      ? { oe: t.t > 0 ? "ce" : "bce", ne: t.t > 0 ? t.t : 1 - t.t, ...n }
+      : "buddhist" === e
+        ? { oe: "be", ne: t.t + 543, ...n, t: t.t + 543 }
+        : {
+            oe: t.t >= 1912 ? "roc" : "broc",
+            ne: t.t >= 1912 ? t.t - 1911 : 1912 - t.t,
+            ...n,
+            t: t.t - 1911,
+          };
+  }
+  return isCopticOrEthiopic(e)
+    ? ((e, t) => {
+        const o = divFloor(t - epoch$1(e) + 365, 365.25) - 1,
+          n = t - calendarIntegersToEpochDays$5(e, o, 1, 1) + 1,
+          r = divFloor(n - 1, 30) + 1;
+        return {
+          oe: "coptic" === e || ("ethiopic" === e && o > 0) ? "am" : "aa",
+          ne: "ethiopic" === e && o <= 0 ? o + 5500 : o,
+          t: o,
+          u: r,
+          v: createMonthCode(r),
+          T: modFloor(n - 1, 30) + 1,
+          re: isoDayOfWeek(epochDaysToIsoDate(t)),
+          ae: n,
+          ie: { ce: void 0, t: void 0 },
+          se: 7,
+          le: daysInMonth$4(o, r),
+          de: mathematicalInLeapYear$2(o) + 365,
+          me: 13,
+          ue: !!mathematicalInLeapYear$2(o),
+        };
+      })(e, o)
+    : "indian" === e
+      ? ((e) => {
+          const t = epochDaysToIsoDate(e),
+            o = firstDayOfYear(t.t - 78) <= e ? t.t - 78 : t.t - 79,
+            n = mathematicalInLeapYear$1(o),
+            r = e - firstDayOfYear(o) + 1;
+          let a = 0;
+          for (; a < 12 && calendarIntegersToEpochDays$3(o, a + 1, 1) <= e; a++);
+          return {
+            oe: "shaka",
+            ne: o,
+            t: o,
+            u: a,
+            v: createMonthCode(a),
+            T: e - calendarIntegersToEpochDays$3(o, a, 1) + 1,
+            re: isoDayOfWeek(t),
+            ae: r,
+            ie: { ce: void 0, t: void 0 },
+            se: 7,
+            le: daysInMonth$2(o, a),
+            de: 365 + n,
+            me: 12,
+            ue: !!n,
+          };
+        })(o)
+      : "persian" === e
+        ? ((e) => {
+            const t = epochDaysToIsoDate(e);
+            return {
+              oe: "ap",
+              get ne() {
+                return getDate(t).t;
+              },
+              get t() {
+                return getDate(t).t;
+              },
+              get u() {
+                return getDate(t).u;
+              },
+              get v() {
+                return createMonthCode(getDate(t).u);
+              },
+              get T() {
+                return getDate(t).T;
+              },
+              re: isoDayOfWeek(t),
+              get ae() {
+                return getDate(t).ae;
+              },
+              ie: { ce: void 0, t: void 0 },
+              se: 7,
+              get le() {
+                const e = getDate(t);
+                return e.u <= 6 ? 31 : 12 !== e.u || isLeapYear(e.t) ? 30 : 29;
+              },
+              get de() {
+                return isLeapYear(getDate(t).t) ? 366 : 365;
+              },
+              me: 12,
+              get ue() {
+                return isLeapYear(getDate(t).t);
+              },
+            };
+          })(o)
+        : "islamic-civil" === e || "islamic-tbla" === e
+          ? epochDaysToDate$2(e, o)
+          : "islamic-umalqura" === e
+            ? ((e) => {
+                const t = epochDaysToDate$2("islamic-civil", e),
+                  o = epochDaysToIsoDate(e);
+                return e < -33600 || e > 76200
+                  ? t
+                  : {
+                      oe: "ah",
+                      get ne() {
+                        return getYearMonthDay(e).t;
+                      },
+                      get t() {
+                        return getYearMonthDay(e).t;
+                      },
+                      get u() {
+                        return getYearMonthDay(e).u;
+                      },
+                      get v() {
+                        return createMonthCode(getYearMonthDay(e).u);
+                      },
+                      get T() {
+                        return getYearMonthDay(e).T;
+                      },
+                      re: isoDayOfWeek(o),
+                      get ae() {
+                        return e - getFirstDayOfMonth(getYearMonthDay(e).t, 1) + 1;
+                      },
+                      ie: { ce: void 0, t: void 0 },
+                      se: 7,
+                      get le() {
+                        const t = getYearMonthDay(e);
+                        return getFirstDayOfMonth(t.t, t.u + 1) - getFirstDayOfMonth(t.t, t.u);
+                      },
+                      get de() {
+                        const t = getYearMonthDay(e).t;
+                        return getFirstDayOfMonth(t + 1, 1) - getFirstDayOfMonth(t, 1);
+                      },
+                      me: 12,
+                      get ue() {
+                        const t = getYearMonthDay(e).t;
+                        return getFirstDayOfMonth(t + 1, 1) - getFirstDayOfMonth(t, 1) > 354;
+                      },
+                    };
+              })(o)
+            : "hebrew" === e
+              ? ((e) => {
+                  const t = epochDaysToIsoDate(e);
+                  let o = divFloor(e + 2092590, 365.2468222) + 2;
+                  for (; calendarIntegersToEpochDays$4(o, 1, 1) > e; o--);
+                  let n = isLeapYear$2(o) ? 13 : 12;
+                  for (; calendarIntegersToEpochDays$4(o, n, 1) > e; n--);
+                  return {
+                    oe: "am",
+                    ne: o,
+                    t: o,
+                    u: n,
+                    v: isLeapYear$2(o)
+                      ? createMonthCode(n <= 5 ? n : n - 1, 6 === n)
+                      : createMonthCode(n),
+                    T: e - calendarIntegersToEpochDays$4(o, n, 1) + 1,
+                    re: isoDayOfWeek(t),
+                    ae: e - calendarIntegersToEpochDays$4(o, 1, 1) + 1,
+                    ie: { ce: void 0, t: void 0 },
+                    se: 7,
+                    le: daysInMonth$3(o, n),
+                    de:
+                      calendarIntegersToEpochDays$4(o + 1, 1, 1) -
+                      calendarIntegersToEpochDays$4(o, 1, 1),
+                    me: isLeapYear$2(o) ? 13 : 12,
+                    ue: isLeapYear$2(o),
+                  };
+                })(o)
+              : epochDaysToDate$6(e, o);
+}
+function calendarMonthDayToIsoReferenceDate(e, t, o) {
+  if (isIsoLikeCalendar(e))
+    return ((e, t) => {
+      const o = regulateIsoDate(e[yt.t] ?? 1972, e[yt.u], e[yt.T], t);
+      return createIsoDateRecord(1972, o.u, o.T);
+    })(
+      {
+        ...t,
+        year: mapUnlessUndefined(
+          t.year,
+          (t) => t - ("buddhist" === e ? -543 : "roc" === e ? 1911 : 0),
+        ),
+      },
+      o,
+    );
+  const n = t[yt.t],
+    r = t[yt.u];
+  let a = t[yt.v],
+    i = t[yt.T];
+  "chinese" === e || "dangi" === e
+    ? (i > 30 && o === p && throwRangeError(Te),
+      (i = clamp(i, 1, 30)),
+      void 0 !== n && (a || (a = nonIsoCalendarIsoToDate(e, calendarIntegersToIso(e, n, r, 1)).v)),
+      ("M01L" !== a &&
+        "M12L" !== a &&
+        (("M02L" !== a && "M08L" !== a && "M09L" !== a && "M10L" !== a && "M11L" !== a) ||
+          30 !== i)) ||
+        (o === p && throwRangeError(Te), (a = createMonthCode(parseMonthCode(a)[0]))))
+    : (void 0 !== n
+        ? (a && (a = constrainMonthCode(e, n, a, o)), (i = constrainDay(e, n, r, i, o)))
+        : (i = ((e, t, o, n) => {
+            const r = parseMonthCode(t);
+            if ("chinese" === e || "dangi" === e) {
+              const e = clamp(o, 1, 30);
+              return o !== e && n === p ? throwRangeError(Te) : e;
+            }
+            if ("hebrew" === e)
+              return "M05L" === t ? constrainDay(e, 3, 6, o, n) : constrainDay(e, 1, r[0], o, n);
+            if (isCopticOrEthiopic(e)) return constrainDay(e, 3, r[0], o, n);
+            if ("indian" === e) return constrainDay(e, 2, r[0], o, n);
+            if ("islamic-civil" === e || "islamic-tbla" === e)
+              return constrainDay(e, 2, r[0], o, n);
+            if ("islamic-umalqura" === e) {
+              const e = clamp(o, 1, 30);
+              return o !== e && n === p ? throwRangeError(Te) : e;
+            }
+            if ("persian" === e) {
+              const e = clamp(o, 1, r[0] <= 6 ? 31 : 30);
+              return o !== e && n === p ? throwRangeError(Te) : e;
+            }
+          })(e, a, i, o)),
+      a || (a = nonIsoCalendarIsoToDate(e, calendarIntegersToIso(e, n, r, i)).v));
+  const c = parseMonthCode(a);
+  return isCopticOrEthiopic(e)
+    ? epochDaysToIsoDate(
+        ((e, t) => (13 === e && 6 === t ? 618 : ((30 * (e - 1) + t + 252) % 365) + 731))(c[0], i),
+      )
+    : epochDaysToIsoDate(
+        "indian" === e
+          ? ((e, t) => calendarIntegersToEpochDays$3(30 * e + t <= 310 ? 1894 : 1893, e, t))(
+              c[0],
+              i,
+            )
+          : "persian" === e
+            ? ((e, t) => {
+                if (12 === e && 30 === t)
+                  for (let o = 1350; ; o--)
+                    if (isLeapYear(o)) return calendarIntegersToEpochDays(o, e, t);
+                const o = calendarIntegersToEpochDays(1351, e, t);
+                return o <= 1095 ? o : calendarIntegersToEpochDays(1350, e, t);
+              })(c[0], i)
+            : "islamic-civil" === e || "islamic-tbla" === e
+              ? ((e, t, o) =>
+                  12 === t && 30 === o
+                    ? "islamic-civil" === e
+                      ? 421
+                      : 420
+                    : calendarIntegersToEpochDays$2(
+                        e,
+                        30 * t + o <= ("islamic-civil" === e ? 355 : 356) ? 1392 : 1391,
+                        t,
+                        o,
+                      ))(e, c[0], i)
+              : "islamic-umalqura" === e
+                ? ((e, t) => {
+                    for (let o = 1392; ; o--)
+                      if (constrainDay$2(o, e, t) === t) {
+                        const n = calendarIntegersToEpochDays$1(o, e, t);
+                        if (n <= 1095) return n;
+                      }
+                  })(c[0], i)
+                : "hebrew" === e
+                  ? ((e, t) => {
+                      const o = parseMonthCode(e);
+                      if ("M05L" === e) return calendarIntegersToEpochDays$4(5730, 6, t);
+                      if (("M02" === e || "M03" === e) && 30 === t)
+                        return calendarIntegersToEpochDays$4(5732, o[0], t);
+                      const n = calendarIntegersToEpochDays$4(5733, o[0], t);
+                      return n <= 1095 ? n : calendarIntegersToEpochDays$4(5732, o[0], t);
+                    })(a, i)
+                  : (function (e, t, o) {
+                      const [n, r] = parseMonthCode(t),
+                        a = r || (30 === o && (6 === n || 8 === n)) || 12 === n ? n + 1 : n;
+                      if ("M11" === t) {
+                        const t = calendarIntegersToEpochDays$6(e, 30 === o ? 1969 : 1972, 11, o);
+                        return t <= 1095 ? t : calendarIntegersToEpochDays$6(e, 1971, 12, o);
+                      }
+                      return calendarIntegersToEpochDays$6(
+                        e,
+                        ((e, t, o) => {
+                          const [n, r] = parseMonthCode(t);
+                          return 12 === n
+                            ? 1971
+                            : !r && (o < 30 || 2 === n || 5 === n || 7 === n || 9 === n || 10 === n)
+                              ? 1972
+                              : r
+                                ? 2 === n
+                                  ? 1947
+                                  : 3 === n
+                                    ? 30 === o
+                                      ? 1955
+                                      : 1966
+                                    : 4 === n
+                                      ? 30 === o
+                                        ? 1944
+                                        : 1963
+                                      : 5 === n
+                                        ? 30 === o
+                                          ? 1952
+                                          : 1971
+                                        : 6 === n
+                                          ? 30 === o
+                                            ? 1941
+                                            : 1960
+                                          : 7 === n
+                                            ? 30 === o
+                                              ? 1938
+                                              : 1968
+                                            : 8 === n
+                                              ? 1957
+                                              : 9 === n
+                                                ? 2014
+                                                : 10 === n
+                                                  ? 1984
+                                                  : 2033
+                                : 1 === n || 4 === n
+                                  ? 1970
+                                  : 3 === n
+                                    ? "chinese" === e
+                                      ? 1966
+                                      : 1968
+                                    : 1971;
+                        })(e, t, o),
+                        a,
+                        o,
+                      );
+                    })(e, a, i),
+      );
+}
+function calendarSupportsEra(e) {
+  return !!St[e].size;
+}
+function canonicalizeEraInCalendar(e, t) {
+  const o = "ad" === t ? "ce" : "bc" === t ? "bce" : t;
+  return St[e].has(o) ? o : throwRangeError(((e) => `invalid era: ${e}`)(t));
+}
+function constrainMonthCode(e, t, o, n) {
+  if ("hebrew" === e)
+    return "M05L" !== o || isLeapYear$2(t) ? o : n === p ? throwRangeError(Te) : "M06";
+  if ("chinese" === e || "dangi" === e) {
+    const r = ((e, t, o) => {
+      const [n, r] = parseMonthCode(o);
+      return r && ordinalMonthToMonthCode(e, t, n + 1) !== o ? createMonthCode(n) : o;
+    })(e, t, o);
+    return o !== r && n === p ? throwRangeError(Te) : r;
+  }
+  return o;
+}
+function monthCodeToOrdinal(e, t, o) {
+  const n = parseMonthCode(o);
+  return "hebrew" === e
+    ? ((e, t) => {
+        const o = parseMonthCode(t);
+        return o[0] + +(isLeapYear$2(e) && o[0] + +o[1] >= 6);
+      })(t, o)
+    : "chinese" === e || "dangi" === e
+      ? ((e, t, o) => {
+          const [n, r] = parseMonthCode(o);
+          return r || ordinalMonthToMonthCode(e, t, n) !== o ? n + 1 : n;
+        })(e, t, o)
+      : n[0];
+}
+function calendarIntegersToIso(e, t, o, n) {
+  return isCopticOrEthiopic(e)
+    ? epochDaysToIsoDate(calendarIntegersToEpochDays$5(e, t, o, n))
+    : epochDaysToIsoDate(
+        "indian" === e
+          ? calendarIntegersToEpochDays$3(t, o, n)
+          : "persian" === e
+            ? calendarIntegersToEpochDays(t, o, n)
+            : "islamic-civil" === e || "islamic-tbla" === e
+              ? calendarIntegersToEpochDays$2(e, t, o, n)
+              : "islamic-umalqura" === e
+                ? calendarIntegersToEpochDays$1(t, o, n)
+                : "hebrew" === e
+                  ? calendarIntegersToEpochDays$4(t, o, n)
+                  : calendarIntegersToEpochDays$6(e, t, o, n),
+      );
+}
+function calendarSupportsEraForNonIsoCalendars(e) {
+  return calendarSupportsEra(e);
+}
+function isIsoLikeCalendar(e) {
+  return "iso8601" === e || "buddhist" === e || "gregory" === e || "japanese" === e || "roc" === e;
+}
+function isCopticOrEthiopic(e) {
+  return "coptic" === e || "ethioaa" === e || "ethiopic" === e;
+}
+function constrainDay(e, t, o, n, r) {
+  const a =
+    "persian" === e
+      ? ((e, t, o) =>
+          t <= 6
+            ? clamp(o, 1, 31)
+            : 12 !== t
+              ? clamp(o, 1, 30)
+              : o < 30
+                ? o
+                : clamp(o, 1, isLeapYear(e) ? 30 : 29))(t, o, n)
+      : "islamic-umalqura" === e
+        ? constrainDay$2(t, o, n)
+        : "chinese" === e || "dangi" === e
+          ? ((e, t, o, n) => (n <= 29 ? n : clamp(n, 1, daysInMonth$5(e, t, o))))(e, t, o, n)
+          : clamp(
+              n,
+              1,
+              isCopticOrEthiopic(e)
+                ? daysInMonth$4(t, o)
+                : "indian" === e
+                  ? daysInMonth$2(t, o)
+                  : "islamic-civil" === e || "islamic-tbla" === e
+                    ? daysInMonth$1(t, o)
+                    : "hebrew" === e
+                      ? daysInMonth$3(t, o)
+                      : void 0,
+            );
+  return n !== a && r === p ? throwRangeError(Te) : a;
+}
+function balanceNonIsoYearMonth(e, t, o) {
+  if ("hebrew" === e)
+    return ((e, t) => {
+      const o = monthNumber(e, 1) + t - 1,
+        n = Math.floor((19 * (o - 1) + 17) / 235) + 1;
+      return { t: n, u: o - monthNumber(n, 1) + 1 };
+    })(t, o);
+  if ("chinese" === e || "dangi" === e)
+    return ((e, t, o) => {
+      if (isWithin(o, 1, 12)) return { t: t, u: o };
+      const n = o >= 1 ? 1 : -1;
+      let r = getNewYear(e, t),
+        a = Math.abs(o - 1);
+      for (; a > 0; ) {
+        const t = Math.min(a, 5e5);
+        ((r += Math.floor(29.5306 * t * n + 10)), (r -= yearMonthDay(e, r).T - 1), (a -= t));
+      }
+      const i = epochDaysToDate$6(e, r);
+      return { t: i.t, u: i.u };
+    })(e, t, o);
+  const n = isCopticOrEthiopic(e) ? 13 : 12;
+  return { t: t + divFloor(o - 1, n), u: modFloor(o - 1, n) + 1 };
+}
+function parseMonthCode(e) {
+  const t = toPrimitive(e);
+  validateString(t);
+  const o = t.match(/M(\d\d)(L?)/);
+  return ((o && "M00" !== t) || throwRangeError(invalidMonthCode(t)), [we(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] = vt[e][0](o)))
+      : n && (n.includes(e) && throwTypeError(missingField(e)), (r[e] = vt[e][1]));
+  }
+  return (n || a || throwTypeError(Fe), r);
+}
+function calendarMergeFields(e, t, o) {
+  const n = ((e, t) => {
+      const o = [];
+      return (
+        void 0 !== t[yt.u] && o.push(yt.v),
+        void 0 !== t[yt.v] && o.push(yt.u),
+        !calendarSupportsEra(e) ||
+          (void 0 === t[yt.oe] && void 0 === t[yt.ne] && void 0 === t[yt.t]) ||
+          o.push(yt.oe, yt.ne, yt.t),
+        !((e) => "japanese" === e)(e) ||
+          (void 0 === t[yt.T] && void 0 === t[yt.u] && void 0 === t[yt.v]) ||
+          o.push(yt.oe, yt.ne),
+        o
+      );
+    })(e, o),
+    r = createEmptyCalendarFieldsRecord();
+  for (const e of wt)
+    (void 0 === t[e] || n.includes(e) || (r[e] = t[e]), void 0 !== o[e] && (r[e] = o[e]));
+  return r;
+}
+function toTemporalCalendarIdentifier(e) {
+  const t =
+    getInternalSlotForPlainDate(e) ||
+    getInternalSlotForPlainDateTime(e) ||
+    getInternalSlotForPlainMonthDay(e) ||
+    getInternalSlotForPlainYearMonth(e) ||
+    getInternalSlotForZonedDateTime(e);
+  return t
+    ? t.Y
+    : (validateString(e),
+      canonicalizeCalendar(
+        ((e) => {
+          try {
+            return parseIsoDateTime(e, [et, tt, ot, nt, rt, at]).Y || "iso8601";
+          } catch {
+            return (st.test(e) || throwRangeError(me), e);
+          }
+        })(e),
+      ));
+}
+function getTemporalCalendarIdentifierWithIsoDefault(e) {
+  const t =
+    getInternalSlotForPlainDate(e) ||
+    getInternalSlotForPlainDateTime(e) ||
+    getInternalSlotForPlainMonthDay(e) ||
+    getInternalSlotForPlainYearMonth(e) ||
+    getInternalSlotForZonedDateTime(e);
+  return t ? t.Y : mapUnlessUndefined(e.calendar, toTemporalCalendarIdentifier) || "iso8601";
+}
+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, m), validateIsoYearMonth(calendarDateToIso(e, t, o))
+  );
+}
+function calendarMonthDayFromFields(e, t, o) {
+  return (calendarResolveFields(e, t, u), calendarMonthDayToIsoReferenceDate(e, t, o));
+}
+function formatCalendarAnnotation(e, t) {
+  return t === j || (t === C && "iso8601" === e) ? "" : `[${t === W ? "!" : ""}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, ce: isoWeeksInYear(t - 1) }
+    : o > isoWeeksInYear(t)
+      ? { t: t + 1, ce: 1 }
+      : { t: t, ce: o };
+}
+function isoDayOfYear(e) {
+  return isoDateRecordToEpochDays(e) - isoDateToEpochDays(e.t, 0, 0);
+}
+function isoDayOfWeek(e) {
+  return modFloor(isoDateRecordToEpochDays(e) + 3, 7) + 1;
+}
+function isoCalendarIsoToDate(e) {
+  return {
+    t: e.t,
+    u: e.u,
+    v: createMonthCode(e.u),
+    T: e.T,
+    re: isoDayOfWeek(e),
+    ae: isoDayOfYear(e),
+    ie: isoWeekOfYear(e),
+    se: 7,
+    le: 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) : nonIsoCalendarIsoToDate(e, t);
+}
+function calendarExtraFields(e, t) {
+  return calendarSupportsEra(e) && t.includes("year") ? ["era", "eraYear"] : [];
+}
+function isoResolveFields(e, t) {
+  (t !== u && void 0 === e[yt.t] && throwTypeError(missingField(yt.t)),
+    t !== m && void 0 === e[yt.T] && throwTypeError(missingField(yt.T)),
+    void 0 === e[yt.v] && void 0 === e[yt.u] && throwTypeError(missingField("month, monthCode")));
+  const o = mapUnlessUndefined(e[yt.v], parseMonthCode);
+  o &&
+    ((o[0] > 12 || o[1] || (void 0 !== e[yt.u] && o[0] !== e[yt.u])) && throwRangeError(Ie),
+    (e[yt.u] = o[0]));
+}
+function calendarResolveFields(e, t, o = s) {
+  "iso8601" === e
+    ? isoResolveFields(t, o)
+    : (function (e, t, o = s) {
+        const n = t[yt.oe],
+          r = t[yt.ne];
+        let a = t[yt.t];
+        const i = t[yt.v],
+          c = t[yt.u],
+          l = t[yt.T];
+        if (
+          ((o === u && void 0 !== i && void 0 === c) ||
+            void 0 !== a ||
+            (calendarSupportsEraForNonIsoCalendars(e) && void 0 !== n && void 0 !== r) ||
+            throwTypeError(missingField("year, era, eraYear")),
+          calendarSupportsEraForNonIsoCalendars(e) &&
+            (void 0 === n) != (void 0 === r) &&
+            throwTypeError(),
+          o !== m && void 0 === l && throwTypeError(missingField("day")),
+          c === i && throwTypeError(missingField("month, monthCode")),
+          calendarSupportsEraForNonIsoCalendars(e) && void 0 !== r)
+        ) {
+          const o = ((e, t, o) => {
+            const n = canonicalizeEraInCalendar(e, t),
+              r = St[e].get(n);
+            return !1 === r ? 1 - o : r + o - 1;
+          })(e, canonicalizeEraInCalendar(e, n), r);
+          (void 0 !== a && a !== o && throwRangeError("mismatch of `year`, `era` and `eraYear`"),
+            (t[yt.t] = o));
+        }
+        if (((t[yt.oe] = t[yt.ne] = void 0), isIsoLikeCalendar(e))) isoResolveFields(t, o);
+        else if (void 0 !== i) {
+          ((e, t) => {
+            const o = parseMonthCode(t);
+            return (
+              (isWithin(o[0], 1, 12) && !o[1]) ||
+              (("chinese" === e || "dangi" === e) && isWithin(o[0], 1, 12)) ||
+              (isCopticOrEthiopic(e) && "M13" === t) ||
+              ("hebrew" === e && "M05L" === t)
+            );
+          })(e, i) || throwRangeError(invalidMonthCode(i));
+          const o = t[yt.t];
+          if (void 0 !== o) {
+            const n = monthCodeToOrdinal(e, o, constrainMonthCode(e, o, i, h));
+            (void 0 !== c && c !== n && throwRangeError(Ie), (t[yt.u] = n));
+          }
+        }
+      })(e, t, o);
+}
+function createEmptyCalendarFieldsRecord() {
+  return createNullPrototypeObject({});
+}
+function zeroDateDuration() {
+  return createDateDurationRecord(0, 0, 0, 0);
+}
+function toInternalDurationRecord(e) {
+  return combineDateAndTimeDuration(
+    createDateDurationRecord(e[X], e[Q], e[ee], e[te]),
+    timeDurationFromComponents(e[oe], e[ne], e[re], e[ae], e[ie], e[ce]),
+  );
+}
+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.A.ee, e.A.te, e.A.X, e.A.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 { A: e, p: t };
+}
+function toTemporalDuration(e) {
+  return (
+    (t = e),
+    Et.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(me);
+            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.F,
+                o.S,
+                o.$,
+              ]),
+              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.A) || Mt(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[X]) < 2 ** 32 &&
+      Math.abs(e[Q]) < 2 ** 32 &&
+      Math.abs(e[ee]) < 2 ** 32) ||
+      throwRangeError(De),
+    validateTimeDurationRange(
+      timeDurationFromComponents(24 * e[te] + e[oe], e[ne], e[re], e[ae], e[ie], e[ce]),
+    ));
+}
+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[le[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(bt.prototype)) {
+  return (Et.set(t, e), t);
+}
+function timeDurationFromComponents(e, t, o, n, c, s) {
+  return addTimeDuration(
+    addTimeDuration(
+      addTimeDuration(
+        createTimeDurationFromSeconds(3600 * e + 60 * t + o),
+        normalize(divTrunc((m = n), r), (m % r) * 1e6),
+      ),
+      ((d = c), normalize(Math.round((d - (d % a)) / a), (d % a) * 1e3)),
+    ),
+    ((l = s), normalize(Math.round((l - (l % i)) / i), l % i)),
+  );
+  var l, d, m;
+}
+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(2 * divTrunc(e[0], 2), roundNumberToIncrement(e[1] + (e[0] % 2) * i, t, o)))(
+      e,
+      t,
+      o,
+    ),
+  );
+}
+function dateDurationDays(e, t) {
+  const o = adjustDateDurationRecord(e, 0);
+  return dateDurationSign(e)
+    ? e.K +
+        isoDateRecordToEpochDays(calendarDateAdd(t.Y, t.o, o, h)) -
+        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, s) {
+  let l, d, m, u, T;
+  if (c === x)
+    ((l = roundNumberToIncrement(t.A.ee, i, P) + (s ? i * e : 0)),
+      (d = l + i * e),
+      (m = createDateDurationRecord(l, 0, 0, 0)),
+      (u = createDateDurationRecord(d, 0, 0, 0)));
+  else if (c === H)
+    ((l = roundNumberToIncrement(t.A.te, i, P) + (s ? i * e : 0)),
+      (d = l + i * e),
+      (m = adjustDateDurationRecord(t.A, 0, 0, l)),
+      (u = adjustDateDurationRecord(t.A, 0, 0, d)));
+  else if (c === q) {
+    const o = calendarDateAdd(a, n.o, adjustDateDurationRecord(t.A, 0, 0), h);
+    ((l = roundNumberToIncrement(
+      t.A.X + calendarDateUntil(a, o, addDaysToIsoDate(o, t.A.K), q).X,
+      i,
+      P,
+    )),
+      (d = l + i * e),
+      (m = adjustDateDurationRecord(t.A, 0, l)),
+      (u = adjustDateDurationRecord(t.A, 0, d)));
+  } else
+    ((l = roundNumberToIncrement(t.A.K, i, P)),
+      (d = l + i * e),
+      (m = adjustDateDurationRecord(t.A, l)),
+      (u = adjustDateDurationRecord(t.A, d)));
+  if (0 === l) T = o;
+  else {
+    const e = combineIsoDateAndTimeRecord(calendarDateAdd(a, n.o, m, h), n.p);
+    T = r ? getEpochNanosecondsFor(r, e, g) : getUtcEpochNanoseconds(e);
+  }
+  const D = combineIsoDateAndTimeRecord(calendarDateAdd(a, n.o, u, h), n.p);
+  return {
+    he: l,
+    De: d,
+    pe: T,
+    ge: r ? getEpochNanosecondsFor(r, D, g) : getUtcEpochNanoseconds(D),
+    fe: m,
+    Ie: u,
+  };
+}
+function nudgeToCalendarUnit(e, t, o, n, r, a, i, c, s, l) {
+  let d = !1,
+    m = computeNudgeWindow(e, t, o, r, a, i, c, s, !1);
+  compareEpochNanoseconds(m.pe, n) * compareEpochNanoseconds(m.ge, n) > 0 &&
+    ((m = computeNudgeWindow(e, t, o, r, a, i, c, s, !0)), (d = !0));
+  const u = differenceEpochNanoseconds(m.pe, n),
+    T = differenceEpochNanoseconds(m.pe, m.ge);
+  let D = m.fe,
+    h = m.pe;
+  return (
+    roundNumberToIncrement(
+      m.he +
+        ((e, t, o) =>
+          signTimeDuration(e) ? (Me(e, t) ? (Me(addTimeDuration(e, e), t) * o) / 5 + 0.5 : 1) : 0)(
+          u,
+          T,
+          e,
+        ) *
+          c *
+          e,
+      c,
+      l,
+    ) === m.De && ((d = !0), (D = m.Ie), (h = m.ge)),
+    {
+      Oe: { Fe: combineDateAndTimeDuration(D, createTimeDurationFromSeconds(0)), Se: h, ye: d },
+      we:
+        m.he +
+        (divideTimeDurationToFloatingPoint(u, 1e9) / divideTimeDurationToFloatingPoint(T, 1e9)) *
+          c *
+          e,
+    }
+  );
+}
+function roundRelativeDuration(e, t, o, n, r, a, i, c, s, l) {
+  const d = internalDurationSign(e) || 1,
+    m =
+      isCalendarUnit(s) || (r && s === B)
+        ? nudgeToCalendarUnit(d, e, t, o, n, r, a, c, s, l).Oe
+        : r
+          ? ((e, t, o, n, r, a, i, c) => {
+              const s = calendarDateAdd(r, o.o, t.A, h),
+                l = combineIsoDateAndTimeRecord(s, o.p),
+                d = combineIsoDateAndTimeRecord(addDaysToIsoDate(s, e), o.p),
+                m = getEpochNanosecondsFor(n, l, g),
+                u = getEpochNanosecondsFor(n, d, g),
+                T = timeDurationFromEpochNanosecondsDifference(u, m),
+                D = nanosecondsForTimeUnit(i);
+              let p = roundTimeDurationToIncrement(t.p, a * D, c);
+              const f = addTimeDuration(p, negateTimeDuration(T));
+              let I,
+                O = !1,
+                F = 0;
+              return (
+                Mt(f) !== -e
+                  ? ((O = !0),
+                    (F = e),
+                    (p = roundTimeDurationToIncrement(f, a * D, c)),
+                    (I = addTimeDurationToEpochNanoseconds(u, p)))
+                  : (I = addTimeDurationToEpochNanoseconds(u, p)),
+                {
+                  Fe: combineDateAndTimeDuration(adjustDateDurationRecord(t.A, t.A.K + F), p),
+                  Se: I,
+                  ye: O,
+                }
+              );
+            })(d, e, n, r, a, c, s, l)
+          : (function (e, t, o, n, r, a) {
+              const i = add24HourDaysToTimeDuration(e.p, e.A.K),
+                c =
+                  r === B
+                    ? roundTimeDurationByDays(i, n, a)
+                    : roundTimeDurationToIncrement(i, nanosecondsForTimeUnit(r) * n, a),
+                s = c[0],
+                [l, d] = isDateUnit(o)
+                  ? [s, addTimeDuration(c, timeDurationFromComponents(24 * -s, 0, 0, 0, 0, 0))]
+                  : [0, c];
+              return {
+                Fe: combineDateAndTimeDuration(adjustDateDurationRecord(e.A, l), d),
+                Se: addTimeDurationToEpochNanoseconds(t, addTimeDuration(c, negateTimeDuration(i))),
+                ye: sign(s - i[0]) === Mt(i),
+              };
+            })(e, o, i, c, s, l);
+  return m.ye && s !== q
+    ? ((e, t, o, n, r, a, i, c) => {
+        if (c === i) return t;
+        const s = i;
+        let l;
+        for (let i = c - 1; i >= s; i--)
+          if (i !== ee || s === ee) {
+            l =
+              i === X
+                ? createDateDurationRecord(t.A.ee + e, 0, 0, 0)
+                : i === Q
+                  ? adjustDateDurationRecord(t.A, 0, 0, t.A.te + e)
+                  : adjustDateDurationRecord(t.A, 0, t.A.X + e);
+            const c = combineIsoDateAndTimeRecord(calendarDateAdd(a, n.o, l, h), n.p);
+            if (
+              Mt(
+                differenceEpochNanoseconds(
+                  r ? getEpochNanosecondsFor(r, c, g) : getUtcEpochNanoseconds(c),
+                  o,
+                ),
+              ) === -e
+            )
+              break;
+            t = combineDateAndTimeDuration(l, createTimeDurationFromSeconds(0));
+          }
+        return t;
+      })(d, m.Fe, m.Se, n, r, a, i, largerOfTwoTemporalUnits(s, B))
+    : m.Fe;
+}
+function totalRelativeDuration(e, t, o, n, r, a, i) {
+  return isCalendarUnit(i) || (r && i === B)
+    ? nudgeToCalendarUnit(internalDurationSign(e) || 1, e, t, o, n, r, a, 1, i, P).we
+    : totalTimeDuration(add24HourDaysToTimeDuration(e.p, e.A.K), i);
+}
+function temporalDurationToString(e, t) {
+  const o = durationSign(e),
+    n = timeDurationFromComponents(
+      0,
+      0,
+      (e = applySignToDurationSlot(e, o))[re],
+      e[ae],
+      e[ie],
+      e[ce],
+    ),
+    [, , , r, a, i, c] = balanceTimeDuration(n, _),
+    [s, l, d, m, u, T] = ["Y", "M", "W", "D", "H", "M"].map((t, o) => (e[o] ? `${e[o]}${t}` : "")),
+    D = `${u}${T}${Mt(n) || defaultTemporalLargestUnit(e) >= _ || void 0 !== t ? `${toString(r)}${formatFractionalSeconds(1e6 * a + 1e3 * i + c, t)}S` : ""}`;
+  return `${o < 0 ? "-" : ""}P${s}${l}${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 = Et.get(e);
+  return (t || throwTypeError(ge), t);
+}
+function applySignToDurationSlot(e, t) {
+  return createTemporalDurationSlot(e.map((e) => e * t + 0));
+}
+function validateTimeDurationRange(e) {
+  return (
+    ((e) => Me(absTimeDuration(e), createTimeDurationFromSeconds(2 ** 53)) < 0)(e) ||
+      throwRangeError(De),
+    e
+  );
+}
+function balanceTimeDuration(e, t) {
+  const o = clamp(t, 3, 9);
+  return [
+    ...[0, 0, 0, 0, 0, 0].slice(0, o - te),
+    o > re
+      ? timeDurationToSubsecondsNumber(e, 18 - 3 * o)
+      : divTrunc(((r = e), r[0] * n + divTrunc(r[1], 1e9)), de[o - te] / 1e9),
+    ...[0, 1, 2, 3, 4, 5]
+      .map((t) => (divTrunc(e[1], de[t + 1]) % (de[t] / de[t + 1])) + 0)
+      .slice(o - te),
+  ];
+  var r;
+}
+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) / r + (divTrunc(n.t, 400) + 1) * c + 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", [h, p], h);
+}
+function getTemporalDisambiguationOption(e) {
+  return getOption(e, "disambiguation", [g, "earlier", f, I], g);
+}
+function negateRoundingMode(e) {
+  return e === E ? M : e === M ? E : e === R ? N : e === N ? R : e;
+}
+function getTemporalOffsetOption(e, t) {
+  return getOption(e, "offset", [O, "use", F, S], t);
+}
+function getTemporalShowCalendarNameOption(e) {
+  return getOption(e, "calendarName", [C, U, j, W], C);
+}
+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 (isWithin(n, 0, 9) || throwRangeError(invalidField(t)), n);
+}
+function toSecondsStringPrecisionRecord(e, t) {
+  return e
+    ? { $e: e === G ? D : 3 * (e - 6), ve: e, Ee: 1 }
+    : { $e: t, ve: divFloor((t ?? 9) - 1, 3) + 7, Ee: 10 ** ((9 - (t ?? 9)) % 3) };
+}
+function getTemporalUnitValuedOption(e, t, o) {
+  return mapUnlessUndefined(getOption(e, t, [...se, ...le, "auto"], o), (e) => {
+    return "auto" === e ? "auto" : ((t = e.replace(/s$/, "")), se.indexOf(t));
+    var t;
+  });
+}
+function validateTemporalUnitValue(e, t, o = []) {
+  void 0 === e ||
+    o.includes(e) ||
+    ("auto" === e && throwRangeError(disallowedUnit(e)),
+    ((e <= B && t === l) || (e > B && t === s)) && throwRangeError(disallowedUnit(e)));
+}
+function getTemporalRelativeToOption(e) {
+  const t = e.relativeTo;
+  if (void 0 === t) return createNullPrototypeObject({});
+  let o,
+    n,
+    r,
+    a,
+    i,
+    c = !0,
+    s = y;
+  if (isObject(t)) {
+    if (isZonedDateTime(t))
+      return createNullPrototypeObject({ Me: getInternalSlotOrThrowForZonedDateTime(t) });
+    if (isPlainDate(t))
+      return createNullPrototypeObject({ be: getInternalSlotOrThrowForPlainDate(t) });
+    const e = getInternalSlotForPlainDateTime(t);
+    if (e)
+      return createNullPrototypeObject({
+        be: getInternalSlotOrThrowForPlainDate(createTemporalDate(e._.o, e.Y)),
+      });
+    r = getTemporalCalendarIdentifierWithIsoDefault(t);
+    const c = prepareCalendarFields(
+        r,
+        t,
+        [yt.t, yt.u, yt.v, yt.T, yt.D, yt.I, yt.O, yt.F, yt.S, yt.$, yt.M, yt.P],
+        [],
+      ),
+      l = interpretTemporalDateTimeFields(r, c, h);
+    ((a = l.o), (i = l.p), (o = c.timeZone), (n = c.offset), (s = n ? y : v));
+  } else {
+    validateString(t);
+    const e = parseIsoDateTime(t, [et, tt]);
+    ((n = e.P.N),
+      e.P.R
+        ? ((o = toTemporalTimeZoneIdentifier(e.P.R)),
+          (s = e.P.Z ? w : n ? y : v),
+          (c = void 0 !== n && hasUtcOffsetSubMinuteParts(n)))
+        : (o = void 0),
+      (r = canonicalizeCalendar(e.Y || "iso8601")),
+      (a = createIsoDateRecord(e.t, e.u, e.T)),
+      (i = e.p));
+  }
+  return createNullPrototypeObject(
+    o
+      ? {
+          Me: getInternalSlotOrThrowForZonedDateTime(
+            createTemporalZonedDateTime(
+              interpretISODateTimeOffset(
+                a,
+                i,
+                s,
+                s === y ? parseDateTimeUtcOffset(n) : 0,
+                o,
+                g,
+                S,
+                c,
+              ),
+              o,
+              r,
+            ),
+          ),
+        }
+      : { be: getInternalSlotOrThrowForPlainDate(createTemporalDate(a, r)) },
+  );
+}
+function largerOfTwoTemporalUnits(e, t) {
+  return e < t ? e : t;
+}
+function isCalendarUnit(e) {
+  return e < B;
+}
+function isDateUnit(e) {
+  return e <= B;
+}
+function maximumTemporalDurationRoundingIncrement(e) {
+  return [24, 60, 60][e - 4] || 1e3;
+}
+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) {
+  return `${toZeroPaddedDecimalString(e, 2)}:${toZeroPaddedDecimalString(t, 2)}${r === D ? "" : `:${toZeroPaddedDecimalString(o, 2)}${formatFractionalSeconds(n, r)}`}`;
+}
+function roundNumberToIncrement(e, t, o) {
+  return Pt[o](e / t) * t;
+}
+function getRoundingModeOption(e, t) {
+  return getOption(e, "roundingMode", [E, M, b, P, R, N, Z, $, Y], t);
+}
+function getRoundingIncrementOption(e) {
+  const t = "roundingIncrement",
+    o = mapUnlessUndefined(e[t], toIntegerWithTruncation) ?? 1;
+  return ((o < 1 || o > 1e9) && throwRangeError(invalidField(t)), o);
+}
+function isoDateToFields(e, t, o) {
+  const n = calendarIsoToDate(e, t);
+  return createNullPrototypeObject({
+    [yt.t]: o === u ? void 0 : n.t,
+    [yt.v]: n.v,
+    [yt.T]: o === m ? void 0 : n.T,
+  });
+}
+function getDifferenceSettings(e, t, o, n, r, a) {
+  let i = getTemporalUnitValuedOption(t, "largestUnit", void 0) ?? "auto";
+  const c = getRoundingIncrementOption(t),
+    s = getRoundingModeOption(t, P),
+    l = getTemporalUnitValuedOption(t, "smallestUnit", void 0) ?? r;
+  return (
+    validateTemporalUnitValue(i, o, ["auto"]),
+    n.includes(i) && throwRangeError(disallowedUnit(i)),
+    validateTemporalUnitValue(l, o),
+    n.includes(l) && throwRangeError(disallowedUnit(l)),
+    "auto" === i && (i = largerOfTwoTemporalUnits(a, l)),
+    i > l && throwRangeError(fe),
+    isDateUnit(l) ||
+      validateTemporalRoundingIncrement(c, maximumTemporalDurationRoundingIncrement(l), !1),
+    { H: l, L: i, q: -1 === e ? negateRoundingMode(s) : s, V: c }
+  );
+}
+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.F),
+    ),
+    1e3 * e.p.S + e.p.$,
+  );
+}
+function epochDaysToIsoDate(e) {
+  const t = new Date(modFloor(e, c) * r);
+  return {
+    t: t.getUTCFullYear() + 400 * divFloor(e, c),
+    u: t.getUTCMonth() + 1,
+    T: t.getUTCDate(),
+  };
+}
+function isoDateTimeToFields(e, t) {
+  return createNullPrototypeObject({
+    ...isoDateToFields(e, t.o, s),
+    [yt.D]: t.p.D,
+    [yt.I]: t.p.I,
+    [yt.O]: t.p.O,
+    [yt.F]: t.p.F,
+    [yt.S]: t.p.S,
+    [yt.$]: t.p.$,
+  });
+}
+function getInternalSlotOrThrowForDateTimeFormat(e) {
+  const t = $t.get(e);
+  return (t || throwTypeError(ge), 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, Yt) ||
+      (hasAnyOptions(e, Ct) && throwTypeError(he), (t.year = t.month = t.day = "numeric")),
+    removeDateTimeFormatOptions(t, [...Ct, "timeZoneName"]),
+    (t.timeZone = "UTC"),
+    t
+  );
+}
+function amendOptionsForPlainTime(e) {
+  const t = createNullPrototypeObject(e);
+  return (
+    hasAnyOptions(e, Ct) ||
+      (hasAnyOptions(e, Yt) && throwTypeError(he), (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, [...Yt, "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, [...Yt, ...Ct]) ||
+      (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, [...Yt, ...Ct]) && throwTypeError(he), (t.year = t.month = "numeric")),
+    removeDateTimeFormatOptions(t, [...Ct, "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, [...Yt, ...Ct]) && throwTypeError(he), (t.month = t.day = "numeric")),
+    removeDateTimeFormatOptions(t, [...Ct, "era", "year", "weekday", "timeZoneName"]),
+    (t.timeZone = "UTC"),
+    t
+  );
+}
+function amendOptionsForInstant(e) {
+  const t = createNullPrototypeObject(e);
+  return (
+    hasAnyOptions(e, [...Yt, ...Ct]) ||
+      (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(
+  e,
+  t = createNullPrototypeObject({}),
+  o,
+  n,
+  r = Object.create(jt.prototype),
+) {
+  null === t && throwTypeError(he);
+  const a = ((e, t) => {
+    const o = createNullPrototypeObject({});
+    for (const n of t) o[n] = e[n];
+    return o;
+  })(Object(t), Zt);
+  ((a.hour12 = mapUnlessUndefined(a.hour12, toBoolean)),
+    (a.hourCycle = mapUnlessUndefined(a.hourCycle, toString)),
+    (a.formatMatcher = mapUnlessUndefined(a.formatMatcher, toString)),
+    void 0 !== n &&
+      (void 0 !== a.timeZone && throwTypeError("disallowed field: timeZone"),
+      (a.timeZone = n),
+      hasAnyOptions(a, [...Yt, ...Ct, "timeZoneName"]) || (a.timeZoneName = "short")));
+  const i = new Nt(e, a),
+    c = i.resolvedOptions(),
+    d = createNullPrototypeObject(c);
+  for (const e of Object.keys(d)) void 0 === a[e] && (d[e] = void 0);
+  return (
+    (d.hour12 = a.hour12),
+    (d.hourCycle = a.hourCycle),
+    (d.formatMatcher = a.formatMatcher),
+    (d.timeZone = c.timeZone),
+    (d.calendar = c.calendar),
+    ((o === s && d.timeStyle) || (o === l && d.dateStyle)) && throwTypeError(he),
+    $t.set(r, createNullPrototypeObject({ Pe: i, Re: d, Ne: i.resolvedOptions().locale })),
+    r
+  );
+}
+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
+    : we(e);
+}
+function handleDateTimeValue(e, t) {
+  const o = getInternalSlotForPlainDate(t),
+    n = getInternalSlotForPlainDateTime(t),
+    r = getInternalSlotForPlainYearMonth(t),
+    a = getInternalSlotForPlainMonthDay(t);
+  return isPlainTime(t)
+    ? [
+        (e.Ze ||= new Nt(e.Ne, amendOptionsForPlainTime(e.Re))),
+        epochMilliseconds(
+          getUtcEpochNanoseconds(
+            combineIsoDateAndTimeRecord(
+              createIsoDateRecord(1970, 1, 1),
+              getInternalSlotOrThrowForPlainTime(t),
+            ),
+          ),
+        ),
+      ]
+    : o
+      ? (o.Y !== e.Re.calendar && "iso8601" !== o.Y && throwRangeError(pe),
+        [
+          (e.Ye ||= new Nt(e.Ne, amendOptionsForPlainDate(e.Re))),
+          epochMilliseconds(
+            getUtcEpochNanoseconds(combineIsoDateAndTimeRecord(o.o, midnightTimeRecord())),
+          ),
+        ])
+      : n
+        ? (n.Y !== e.Re.calendar && "iso8601" !== n.Y && throwRangeError(pe),
+          [
+            (e.Ce ||= new Nt(e.Ne, amendOptionsForPlainDateTime(e.Re))),
+            epochMilliseconds(getUtcEpochNanoseconds(n._)),
+          ])
+        : r
+          ? (r.Y !== e.Re.calendar && throwRangeError(pe),
+            [
+              (e.Ue ||= new Nt(e.Ne, amendOptionsForPlainYearMonth(e.Re))),
+              epochMilliseconds(
+                getUtcEpochNanoseconds(combineIsoDateAndTimeRecord(r.o, midnightTimeRecord())),
+              ),
+            ])
+          : a
+            ? (a.Y !== e.Re.calendar && throwRangeError(pe),
+              [
+                (e.je ||= new Nt(e.Ne, amendOptionsForPlainMonthDay(e.Re))),
+                epochMilliseconds(
+                  getUtcEpochNanoseconds(combineIsoDateAndTimeRecord(a.o, midnightTimeRecord())),
+                ),
+              ])
+            : isInstant(t)
+              ? [
+                  (e.We ||= new Nt(e.Ne, amendOptionsForInstant(e.Re))),
+                  epochMilliseconds(getInternalSlotOrThrowForInstant(t).U),
+                ]
+              : (isZonedDateTime(t) && throwTypeError(Oe), [e.Pe, t]);
+}
+function DateTimeFormat(e, t) {
+  return new jt(e, t);
+}
+function createTemporalInstant(e, t = Object.create(Lt.prototype)) {
+  return (At.set(t, { U: e }), t);
+}
+function toTemporalInstant$1(e) {
+  if (isObject(e)) {
+    const t = getInternalSlotForInstant(e) || getInternalSlotForZonedDateTime(e);
+    if (t) return createTemporalInstant(t.U);
+    e = toPrimitive(e);
+  }
+  validateString(e);
+  const t = parseIsoDateTime(e, [ot]),
+    o = t.P.Z ? 0 : parseDateTimeUtcOffset(t.P.N),
+    n = t.p;
+  return createTemporalInstant(
+    validateEpochNanoseconds(
+      getUtcEpochNanoseconds(balanceIsoDateTime(t.t, t.u, t.T, n.D, n.I, n.O, n.F, n.S, n.$ - 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) => Rt[o](e / t) * t)(e[1], t, o));
+  })(e, t * nanosecondsForTimeUnit(o), n);
+}
+function temporalInstantToString(e, t, o) {
+  const n = getOffsetNanosecondsFor(t || "UTC", e);
+  return `${isoDateTimeToString(getIsoDateTimeFromOffsetNanoseconds(e, n), "iso8601", o, j)}${t ? formatDateTimeUtcOffsetRounded(n) : "Z"}`;
+}
+function differenceTemporalInstant(e, t, o, n) {
+  const r = getInternalSlotOrThrowForInstant(toTemporalInstant$1(o)),
+    a = getDifferenceSettings(e, getOptionsObject(n), l, [], K, _);
+  return createTemporalDuration(
+    applySignToDurationSlot(
+      temporalDurationFromInternal(differenceInstant(t.U, r.U, a.V, a.H, a.q), a.L),
+      e,
+    ),
+  );
+}
+function addDurationToInstant(e, t, o) {
+  const n = applySignToDurationSlot(toTemporalDuration(o), e);
+  return (
+    isDateUnit(defaultTemporalLargestUnit(n)) &&
+      throwRangeError(durationWithDateUnit(defaultTemporalLargestUnit(n))),
+    createTemporalInstant(addInstant(t.U, toInternalDurationRecordWith24HourDays(n).p))
+  );
+}
+function validateEpochNanoseconds(e) {
+  return (
+    ((e) => compareEpochNanoseconds(ve, e) * compareEpochNanoseconds(Ee, e) <= 0)(e) ||
+      throwRangeError(Te),
+    e
+  );
+}
+function getInternalSlotForInstant(e) {
+  return At.get(e);
+}
+function getInternalSlotOrThrowForInstant(e) {
+  const t = getInternalSlotForInstant(e);
+  return (t || throwTypeError(ge), t);
+}
+function isInstant(e) {
+  return At.has(e);
+}
+function clampEpochNanoseconds(e) {
+  return compareEpochNanoseconds(e, Ee) > 0 ? Ee : compareEpochNanoseconds(e, ve) < 0 ? ve : e;
+}
+function systemTimeZoneIdentifier() {
+  return new Nt().resolvedOptions().timeZone;
+}
+function systemUtcEpochNanoseconds() {
+  return createEpochNanosecondsFromEpochMilliseconds(Date.now());
+}
+function systemDateTime(e = systemTimeZoneIdentifier()) {
+  return getIsoDateTimeForZonedDateTimeSlot(
+    createZonedDateTimeSlot(
+      systemUtcEpochNanoseconds(),
+      toTemporalTimeZoneIdentifier(e),
+      "iso8601",
+    ),
+  );
+}
+const e = 1e6,
+  t = 6e10,
+  o = 36e11,
+  n = 86400,
+  r = 864e5,
+  a = 864e8,
+  i = 864e11,
+  c = 146097,
+  s = Symbol(),
+  l = Symbol(),
+  d = Symbol(),
+  m = Symbol(),
+  u = Symbol(),
+  T = Symbol(),
+  D = Symbol(),
+  h = "constrain",
+  p = "reject",
+  g = "compatible",
+  f = "later",
+  I = "reject",
+  O = "prefer",
+  F = "ignore",
+  S = "reject",
+  y = Symbol(),
+  w = Symbol(),
+  v = Symbol(),
+  E = "ceil",
+  M = "floor",
+  b = "expand",
+  P = "trunc",
+  R = "halfCeil",
+  N = "halfFloor",
+  Z = "halfExpand",
+  $ = "halfTrunc",
+  Y = "halfEven",
+  C = "auto",
+  U = "always",
+  j = "never",
+  W = "critical",
+  A = "auto",
+  L = "never",
+  k = "auto",
+  z = "never",
+  V = "critical",
+  x = 0,
+  H = 1,
+  q = 2,
+  B = 3,
+  J = 4,
+  G = 5,
+  _ = 6,
+  K = 9,
+  X = 0,
+  Q = 1,
+  ee = 2,
+  te = 3,
+  oe = 4,
+  ne = 5,
+  re = 6,
+  ae = 7,
+  ie = 8,
+  ce = 9,
+  se = [
+    "year",
+    "month",
+    "week",
+    "day",
+    "hour",
+    "minute",
+    "second",
+    "millisecond",
+    "microsecond",
+    "nanosecond",
+  ],
+  le = se.map((e) => `${e}s`),
+  de = [i, o, t, 1e9, 1e6, 1e3, 1],
+  missingField = (e) => `missing field: ${e}`,
+  invalidField = (e) => `invalid field: ${e}`,
+  me = "parse error",
+  ue = "invalid date / time",
+  Te = "out-of-bounds date",
+  De = "out-of-bounds duration",
+  he = "invalid formatting options",
+  pe = "calendar mismatch",
+  disallowedUnit = (e) => `disallowed unit: ${"auto" === e ? e : getNameFromUnit(e)}`,
+  invalidNumber = (e) => `invalid number: ${e}`,
+  invalidTimeZone = (e) => `invalid time zone: ${e}`,
+  ge = "invalid method call",
+  invalidMonthCode = (e) => `invalid month code:${e}`,
+  durationWithDateUnit = (e) => `duration has a date unit: ${getNameFromUnit(e)}`,
+  fe = "invalid `largestUnit` and `smallestUnit` options",
+  Ie = "mismatch of `month` and `monthCode`",
+  Oe = "value is not formattable",
+  notObject = (e) => `not object: ${e}`,
+  Fe = "empty fields",
+  Se = "can't convert Temporal classes to number",
+  ye = "argument is undefined",
+  we = Math.max,
+  ve = createEpochNanosecondsFromEpochMilliseconds(-864e13),
+  Ee = createEpochNanosecondsFromEpochMilliseconds(864e13),
+  Me = compareEpochNanoseconds,
+  be = new WeakMap();
+var Pe = 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 createTemporalZonedDateTimeFromSlot(toTemporalZonedDateTime(e, t));
+  }
+  static compare(e, t) {
+    return compareEpochNanoseconds(toTemporalZonedDateTime(e).U, toTemporalZonedDateTime(t).U);
+  }
+  get calendarId() {
+    return getInternalSlotOrThrowForZonedDateTime(this).Y;
+  }
+  get timeZoneId() {
+    return getInternalSlotOrThrowForZonedDateTime(this).P;
+  }
+  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)).v;
+  }
+  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.F;
+  }
+  get microsecond() {
+    return getIsoDateTimeForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).p.S;
+  }
+  get nanosecond() {
+    return getIsoDateTimeForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).p.$;
+  }
+  get epochMilliseconds() {
+    return epochMilliseconds(getInternalSlotOrThrowForZonedDateTime(this).U);
+  }
+  get epochNanoseconds() {
+    return convertEpochNanosecondsToBigInt(getInternalSlotOrThrowForZonedDateTime(this).U);
+  }
+  get dayOfWeek() {
+    return calendarIsoToDateForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).re;
+  }
+  get dayOfYear() {
+    return calendarIsoToDateForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).ae;
+  }
+  get weekOfYear() {
+    return calendarIsoToDateForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).ie
+      .ce;
+  }
+  get yearOfWeek() {
+    return calendarIsoToDateForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).ie.t;
+  }
+  get hoursInDay() {
+    const e = getInternalSlotOrThrowForZonedDateTime(this),
+      t = getIsoDateTimeForZonedDateTimeSlot(e).o;
+    return (
+      timeDurationToSubsecondsNumber(
+        differenceEpochNanoseconds(
+          getStartOfDay(e.P, t),
+          getStartOfDay(e.P, addDaysToIsoDate(t, 1)),
+        ),
+        -9,
+      ) / o
+    );
+  }
+  get daysInWeek() {
+    return calendarIsoToDateForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).se;
+  }
+  get daysInMonth() {
+    return calendarIsoToDateForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).le;
+  }
+  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.Y,
+        createNullPrototypeObject({
+          ...isoDateTimeToFields(o.Y, r),
+          [yt.M]: formatUtcOffsetNanoseconds(n),
+        }),
+        prepareCalendarFields(o.Y, e, [
+          yt.t,
+          yt.u,
+          yt.v,
+          yt.T,
+          yt.D,
+          yt.I,
+          yt.O,
+          yt.F,
+          yt.S,
+          yt.$,
+          yt.M,
+        ]),
+      ),
+      i = getOptionsObject(t),
+      c = getTemporalDisambiguationOption(i),
+      s = getTemporalOffsetOption(i, O),
+      l = getTemporalOverflowOption(i),
+      d = interpretTemporalDateTimeFields(o.Y, a, l);
+    return createTemporalZonedDateTime(
+      interpretISODateTimeOffset(d.o, d.p, y, parseDateTimeUtcOffset(a[yt.M]), o.P, c, s, !0),
+      o.P,
+      o.Y,
+    );
+  }
+  withPlainTime(e = void 0) {
+    const t = getInternalSlotOrThrowForZonedDateTime(this),
+      o = getIsoDateTimeForZonedDateTimeSlot(t);
+    return createTemporalZonedDateTime(
+      void 0 === e
+        ? getStartOfDay(t.P, o.o)
+        : getEpochNanosecondsFor(t.P, combineIsoDateAndTimeRecord(o.o, toTemporalTime(e)), g),
+      t.P,
+      t.Y,
+    );
+  }
+  withTimeZone(e) {
+    const t = getInternalSlotOrThrowForZonedDateTime(this);
+    return createTemporalZonedDateTime(t.U, toTemporalTimeZoneIdentifier(e), t.Y);
+  }
+  withCalendar(e) {
+    const t = getInternalSlotOrThrowForZonedDateTime(this);
+    return createTemporalZonedDateTime(t.U, t.P, 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 t = getInternalSlotOrThrowForZonedDateTime(this),
+      o = getRoundToOptionsObject(e),
+      n = getRoundingIncrementOption(o),
+      r = getRoundingModeOption(o, "halfExpand"),
+      a = getTemporalUnitValuedOption(o, "smallestUnit", T);
+    if (
+      (validateTemporalUnitValue(a, l, [B]),
+      validateTemporalRoundingIncrement(
+        n,
+        a === B ? 1 : maximumTemporalDurationRoundingIncrement(a),
+        a === B,
+      ),
+      a === K && 1 === n)
+    )
+      return createTemporalZonedDateTimeFromSlot(t);
+    const i = getIsoDateTimeForZonedDateTimeSlot(t);
+    if (a === B) {
+      const e = getStartOfDay(t.P, i.o),
+        o = getStartOfDay(t.P, addDaysToIsoDate(i.o, 1));
+      return createTemporalZonedDateTime(
+        addNanosecondsToEpochSeconds(
+          e,
+          roundNumberToIncrement(
+            timeDurationToSubsecondsNumber(differenceEpochNanoseconds(e, t.U), -9),
+            timeDurationToSubsecondsNumber(differenceEpochNanoseconds(e, o), -9),
+            r,
+          ),
+        ),
+        t.P,
+        t.Y,
+      );
+    }
+    const c = roundIsoDateTime(i, n, a, r),
+      s = getOffsetNanosecondsForZonedDateTimeSlot(t);
+    return createTemporalZonedDateTime(
+      interpretISODateTimeOffset(c.o, c.p, y, s, t.P, g, O, !0),
+      t.P,
+      t.Y,
+    );
+  }
+  equals(e) {
+    const t = getInternalSlotOrThrowForZonedDateTime(this),
+      o = toTemporalZonedDateTime(e);
+    return (
+      !compareEpochNanoseconds(t.U, o.U) && timeZoneEquals(t.P, o.P) && calendarEquals(t.Y, o.Y)
+    );
+  }
+  toString(e = void 0) {
+    const t = getInternalSlotOrThrowForZonedDateTime(this),
+      o = getOptionsObject(e),
+      n = getTemporalShowCalendarNameOption(o),
+      r = getTemporalFractionalSecondDigitsOption(o),
+      a = ((e) => getOption(e, "offset", [A, L], A))(o),
+      i = getRoundingModeOption(o, P),
+      c = getTemporalUnitValuedOption(o, "smallestUnit", void 0),
+      s = ((e) => getOption(e, "timeZoneName", [k, z, V], k))(o);
+    (validateTemporalUnitValue(c, l), c === J && throwRangeError(invalidField("smallestUnit")));
+    const d = toSecondsStringPrecisionRecord(c, r);
+    return temporalZonedDateTimeToString(t, d.$e, n, s, a, d.Ee, d.ve, i);
+  }
+  toLocaleString(e = void 0, t = void 0) {
+    const o = getInternalSlotOrThrowForZonedDateTime(this),
+      n = createDateTimeFormat(e, t, d, o.P),
+      r = getInternalSlotOrThrowForDateTimeFormat(n);
+    return (
+      "iso8601" === o.Y || calendarEquals(o.Y, r.Re.calendar) || throwRangeError(pe),
+      formatDateTime(n, createTemporalInstant(o.U))
+    );
+  }
+  toJSON() {
+    return temporalZonedDateTimeToString(
+      getInternalSlotOrThrowForZonedDateTime(this),
+      void 0,
+      C,
+      k,
+      A,
+    );
+  }
+  valueOf() {
+    throwTypeError(Se);
+  }
+  startOfDay() {
+    const e = getInternalSlotOrThrowForZonedDateTime(this);
+    return createTemporalZonedDateTime(
+      getStartOfDay(e.P, getIsoDateTimeForZonedDateTimeSlot(e).o),
+      e.P,
+      e.Y,
+    );
+  }
+  getTimeZoneTransition(e) {
+    const t = getInternalSlotOrThrowForZonedDateTime(this);
+    void 0 === e && throwTypeError(ye);
+    const o = getOption(
+        "string" == typeof e ? { direction: e } : getOptionsObject(e),
+        "direction",
+        ["next", "previous"],
+        T,
+      ),
+      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.P, t.U, "next" === o ? 1 : -1);
+    return null === n ? null : createTemporalZonedDateTime(n, t.P, t.Y);
+  }
+  toInstant() {
+    return createTemporalInstant(getInternalSlotOrThrowForZonedDateTime(this).U);
+  }
+  toPlainDate() {
+    const e = getInternalSlotOrThrowForZonedDateTime(this);
+    return createTemporalDate(getIsoDateTimeForZonedDateTimeSlot(e).o, e.Y);
+  }
+  toPlainTime() {
+    return createTemporalTime(
+      getIsoDateTimeForZonedDateTimeSlot(getInternalSlotOrThrowForZonedDateTime(this)).p,
+    );
+  }
+  toPlainDateTime() {
+    const e = getInternalSlotOrThrowForZonedDateTime(this);
+    return createTemporalDateTime(getIsoDateTimeForZonedDateTimeSlot(e), e.Y);
+  }
+};
+(defineStringTag(Pe.prototype, "Temporal.ZonedDateTime"), renameFunction(Pe, "ZonedDateTime"));
+const Re = createNullPrototypeObject({}),
+  Ne = createNullPrototypeObject({}),
+  Ze = new WeakMap();
+var $e = class {
+  constructor(e, t, o, n = 0, r = 0, a = 0, i = 0, c = 0, s = 0, l = "iso8601") {
+    const d = [e, t, o].map(toIntegerWithTruncation),
+      m = [n, r, a, i, c, s].map(toIntegerWithTruncation);
+    validateString(l);
+    const u = canonicalizeCalendar(l);
+    ((isValidIsoDate(...d) && isValidTime(...m)) || throwRangeError(ue),
+      createTemporalDateTime(
+        combineIsoDateAndTimeRecord(createIsoDateRecord(...d), createTimeRecord(...m)),
+        u,
+        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).Y;
+  }
+  get era() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.Y, e._.o).oe;
+  }
+  get eraYear() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.Y, e._.o).ne;
+  }
+  get year() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.Y, e._.o).t;
+  }
+  get month() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.Y, e._.o).u;
+  }
+  get monthCode() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.Y, e._.o).v;
+  }
+  get day() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.Y, 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.F;
+  }
+  get microsecond() {
+    return getInternalSlotOrThrowForPlainDateTime(this)._.p.S;
+  }
+  get nanosecond() {
+    return getInternalSlotOrThrowForPlainDateTime(this)._.p.$;
+  }
+  get dayOfWeek() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.Y, e._.o).re;
+  }
+  get dayOfYear() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.Y, e._.o).ae;
+  }
+  get weekOfYear() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.Y, e._.o).ie.ce;
+  }
+  get yearOfWeek() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.Y, e._.o).ie.t;
+  }
+  get daysInWeek() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.Y, e._.o).se;
+  }
+  get daysInMonth() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.Y, e._.o).le;
+  }
+  get daysInYear() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.Y, e._.o).de;
+  }
+  get monthsInYear() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.Y, e._.o).me;
+  }
+  get inLeapYear() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return calendarIsoToDate(e.Y, e._.o).ue;
+  }
+  with(e, t = void 0) {
+    const o = getInternalSlotOrThrowForPlainDateTime(this);
+    validatePartialTemporalObject(e);
+    const n = calendarMergeFields(
+      o.Y,
+      isoDateTimeToFields(o.Y, o._),
+      prepareCalendarFields(o.Y, e, [yt.t, yt.u, yt.v, yt.T, yt.D, yt.I, yt.O, yt.F, yt.S, yt.$]),
+    );
+    return createTemporalDateTime(
+      interpretTemporalDateTimeFields(o.Y, n, getTemporalOverflowOption(getOptionsObject(t))),
+      o.Y,
+    );
+  }
+  withPlainTime(e = void 0) {
+    const t = getInternalSlotOrThrowForPlainDateTime(this);
+    return createTemporalDateTime(
+      combineIsoDateAndTimeRecord(t._.o, toTimeRecordOrMidnight(e)),
+      t.Y,
+    );
+  }
+  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 t = getInternalSlotOrThrowForPlainDateTime(this),
+      o = getRoundToOptionsObject(e),
+      n = getRoundingIncrementOption(o),
+      r = getRoundingModeOption(o, "halfExpand"),
+      a = getTemporalUnitValuedOption(o, "smallestUnit", T);
+    return (
+      validateTemporalUnitValue(a, l, [B]),
+      validateTemporalRoundingIncrement(
+        n,
+        a === B ? 1 : maximumTemporalDurationRoundingIncrement(a),
+        a === B,
+      ),
+      createTemporalDateTime(roundIsoDateTime(t._, n, a, r), t.Y)
+    );
+  }
+  equals(e) {
+    const t = getInternalSlotOrThrowForPlainDateTime(this),
+      o = getInternalSlotOrThrowForPlainDateTime(toTemporalDateTime(e));
+    return !compareIsoDateTime(t._, o._) && calendarEquals(t.Y, o.Y);
+  }
+  toString(e = void 0) {
+    const t = getInternalSlotOrThrowForPlainDateTime(this),
+      o = getOptionsObject(e),
+      n = getTemporalShowCalendarNameOption(o),
+      r = getTemporalFractionalSecondDigitsOption(o),
+      a = getRoundingModeOption(o, P),
+      i = getTemporalUnitValuedOption(o, "smallestUnit", void 0);
+    (validateTemporalUnitValue(i, l), i === J && throwRangeError(invalidField("smallestUnit")));
+    const c = toSecondsStringPrecisionRecord(i, r);
+    return isoDateTimeToString(
+      validateIsoDateTime(roundIsoDateTime(t._, c.Ee, c.ve, a)),
+      t.Y,
+      c.$e,
+      n,
+    );
+  }
+  toLocaleString(e = void 0, t = void 0) {
+    return (
+      getInternalSlotOrThrowForPlainDateTime(this),
+      formatDateTime(createDateTimeFormat(e, t, d), this)
+    );
+  }
+  toJSON() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return isoDateTimeToString(e._, e.Y, void 0, C);
+  }
+  valueOf() {
+    throwTypeError(Se);
+  }
+  toZonedDateTime(e, t = void 0) {
+    const o = getInternalSlotOrThrowForPlainDateTime(this),
+      n = toTemporalTimeZoneIdentifier(e),
+      r = getTemporalDisambiguationOption(getOptionsObject(t));
+    return createTemporalZonedDateTime(getEpochNanosecondsFor(n, o._, r), n, o.Y);
+  }
+  toPlainDate() {
+    const e = getInternalSlotOrThrowForPlainDateTime(this);
+    return createTemporalDate(e._.o, e.Y);
+  }
+  toPlainTime() {
+    return createTemporalTime(getInternalSlotOrThrowForPlainDateTime(this)._.p);
+  }
+};
+(defineStringTag($e.prototype, "Temporal.PlainDateTime"), renameFunction($e, "PlainDateTime"));
+const Ye = new WeakMap();
+var Ce = 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(ue), createTemporalTime(createTimeRecord(...i), this));
+  }
+  static from(e, t = void 0) {
+    return createTemporalTime(toTemporalTime(e, t));
+  }
+  static compare(e, t) {
+    return compareTimeRecord(toTemporalTime(e), 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).F;
+  }
+  get microsecond() {
+    return getInternalSlotOrThrowForPlainTime(this).S;
+  }
+  get nanosecond() {
+    return getInternalSlotOrThrowForPlainTime(this).$;
+  }
+  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.F, o.S, o.$]),
+          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 t = getInternalSlotOrThrowForPlainTime(this),
+      o = getRoundToOptionsObject(e),
+      n = getRoundingIncrementOption(o),
+      r = getRoundingModeOption(o, Z),
+      a = getTemporalUnitValuedOption(o, "smallestUnit", T);
+    return (
+      validateTemporalUnitValue(a, l),
+      validateTemporalRoundingIncrement(n, maximumTemporalDurationRoundingIncrement(a), !1),
+      createTemporalTime(roundTime(t, n, a, r))
+    );
+  }
+  equals(e) {
+    return !compareTimeRecord(getInternalSlotOrThrowForPlainTime(this), toTemporalTime(e));
+  }
+  toString(e = void 0) {
+    const t = getInternalSlotOrThrowForPlainTime(this),
+      o = getOptionsObject(e),
+      n = getTemporalFractionalSecondDigitsOption(o),
+      r = getRoundingModeOption(o, P),
+      a = getTemporalUnitValuedOption(o, "smallestUnit", void 0);
+    (validateTemporalUnitValue(a, l), a === J && throwRangeError(invalidField("smallestUnit")));
+    const i = toSecondsStringPrecisionRecord(a, n);
+    return timeRecordToString(roundTime(t, i.Ee, i.ve, r), i.$e);
+  }
+  toLocaleString(e = void 0, t = void 0) {
+    return (
+      getInternalSlotOrThrowForPlainTime(this), formatDateTime(createDateTimeFormat(e, t, l), this)
+    );
+  }
+  toJSON() {
+    return timeRecordToString(getInternalSlotOrThrowForPlainTime(this));
+  }
+  valueOf() {
+    throwTypeError(Se);
+  }
+};
+(defineStringTag(Ce.prototype, "Temporal.PlainTime"), renameFunction(Ce, "PlainTime"));
+const Ue = "\\d{4}|[-+]\\d{6}",
+  je = "0[1-9]|1[0-2]",
+  We = "0[1-9]|[12]\\d|30|31",
+  Ae = "[01]\\d|2[0-3]",
+  Le = "[0-5]\\d",
+  ke = `(?<a>${Ue})(?<x>-?)(?<b>${je})\\k<x>(?<c>${We})`,
+  ze = optionalChain([
+    `(?<d>${Ae})`,
+    `(?<y>:?)(?<e>${Le})`,
+    "\\k<y>(?<f>[0-5]\\d|60)",
+    "[.,](?<g>\\d{1,9})",
+  ]),
+  Ve = optionalChain([`([+-])(${Ae})`, `(?<z>:?)(${Le})`, `\\k<z>(${Le})`, "[.,](\\d{1,9})"]),
+  xe = optionalChain([ke, `[ tT]${ze}`, `(?<h>${Ve})`]),
+  He = `(?<l>${Ue})-?(?<m>${je})`,
+  qe = `(?:--)?(?<m>${je})-?(?<n>${We})`,
+  Be = `(?<h>${Ve})|(?<i>[zZ])`,
+  Je = `([+-])(${Ae})(?::?(${Le}))?|${join("[a-zA-Z._][a-zA-Z._+-\\d]*", "\\/")}`,
+  Ge = `\\[!?(?<j>${Je})\\]`,
+  _e = join("[a-zA-Z\\d]+", "-"),
+  Ke = `\\[(!)?([a-z_][a-z\\d_-]*)=(${_e})\\]`,
+  Xe = `(?<k>(${Ke})*)`,
+  Qe = RegExp(Ke, "g"),
+  et = createRegExp(`${optionalChain([ke, `[ tT]${ze}`, Be])}${Ge}${Xe}`),
+  tt = createRegExp(`${xe}(?:${Ge})?${Xe}`),
+  ot = createRegExp(`${ke}[ tT]${ze}(?:${Be})(?:${Ge})?${Xe}`),
+  nt = createRegExp(`(${ke}[ tT]|[tT]?)${ze}(?<h>${Ve})?(?:${Ge})?${Xe}`),
+  rt = createRegExp(`(${xe}|${qe})(?:${Ge})?${Xe}`),
+  at = createRegExp(`(${xe}|${He})(?:${Ge})?${Xe}`),
+  it = [createRegExp(`${qe}(${Ge})?(${Ke})*`), createRegExp(`${He}(${Ge})?(${Ke})*`)],
+  ct = createRegExp(Je),
+  st = createRegExp(_e),
+  lt = createRegExp(Ve),
+  dt = new WeakMap();
+var mt = class {
+  constructor(e, t, o = "iso8601", n = 1972) {
+    const r = toIntegerWithTruncation(e),
+      a = toIntegerWithTruncation(t);
+    validateString(o);
+    const i = canonicalizeCalendar(o),
+      c = toIntegerWithTruncation(n);
+    (isValidIsoDate(c, r, a) || throwRangeError(ue),
+      createTemporalMonthDay(createIsoDateRecord(c, r, a), i, this));
+  }
+  static from(e, t = void 0) {
+    return toTemporalMonthDay(e, t);
+  }
+  get calendarId() {
+    return getInternalSlotOrThrowForPlainMonthDay(this).Y;
+  }
+  get monthCode() {
+    const e = getInternalSlotOrThrowForPlainMonthDay(this);
+    return calendarIsoToDate(e.Y, e.o).v;
+  }
+  get day() {
+    const e = getInternalSlotOrThrowForPlainMonthDay(this);
+    return calendarIsoToDate(e.Y, e.o).T;
+  }
+  with(e, t = void 0) {
+    const o = getInternalSlotOrThrowForPlainMonthDay(this);
+    return (
+      validatePartialTemporalObject(e),
+      createTemporalMonthDay(
+        calendarMonthDayFromFields(
+          o.Y,
+          calendarMergeFields(
+            o.Y,
+            isoDateToFields(o.Y, o.o, u),
+            prepareCalendarFields(o.Y, e, [yt.t, yt.u, yt.v, yt.T]),
+          ),
+          getTemporalOverflowOption(getOptionsObject(t)),
+        ),
+        o.Y,
+      )
+    );
+  }
+  equals(e) {
+    const t = getInternalSlotOrThrowForPlainMonthDay(this),
+      o = getInternalSlotOrThrowForPlainMonthDay(toTemporalMonthDay(e));
+    return 0 === compareIsoDate(t.o, o.o) && calendarEquals(t.Y, o.Y);
+  }
+  toString(e = void 0) {
+    return temporalMonthDayToString(
+      getInternalSlotOrThrowForPlainMonthDay(this),
+      getTemporalShowCalendarNameOption(getOptionsObject(e)),
+    );
+  }
+  toLocaleString(e = void 0, t = void 0) {
+    return (
+      getInternalSlotOrThrowForPlainMonthDay(this),
+      formatDateTime(createDateTimeFormat(e, t, s), this)
+    );
+  }
+  toJSON() {
+    return temporalMonthDayToString(getInternalSlotOrThrowForPlainMonthDay(this), C);
+  }
+  valueOf() {
+    throwTypeError(Se);
+  }
+  toPlainDate(e) {
+    const t = getInternalSlotOrThrowForPlainMonthDay(this);
+    return (
+      isObject(e) || throwTypeError(notObject(e)),
+      createTemporalDate(
+        calendarDateFromFields(
+          t.Y,
+          calendarMergeFields(
+            t.Y,
+            isoDateToFields(t.Y, t.o, u),
+            prepareCalendarFields(t.Y, e, [yt.t], []),
+          ),
+          h,
+        ),
+        t.Y,
+      )
+    );
+  }
+};
+(defineStringTag(mt.prototype, "Temporal.PlainMonthDay"), renameFunction(mt, "PlainMonthDay"));
+const ut = 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),
+      c = toIntegerWithTruncation(n);
+    (isValidIsoDate(r, a, c) || throwRangeError(ue),
+      createTemporalYearMonth(createIsoDateRecord(r, a, c), 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).Y;
+  }
+  get era() {
+    const e = getInternalSlotOrThrowForPlainYearMonth(this);
+    return calendarIsoToDate(e.Y, e.o).oe;
+  }
+  get eraYear() {
+    const e = getInternalSlotOrThrowForPlainYearMonth(this);
+    return calendarIsoToDate(e.Y, e.o).ne;
+  }
+  get year() {
+    const e = getInternalSlotOrThrowForPlainYearMonth(this);
+    return calendarIsoToDate(e.Y, e.o).t;
+  }
+  get month() {
+    const e = getInternalSlotOrThrowForPlainYearMonth(this);
+    return calendarIsoToDate(e.Y, e.o).u;
+  }
+  get monthCode() {
+    const e = getInternalSlotOrThrowForPlainYearMonth(this);
+    return calendarIsoToDate(e.Y, e.o).v;
+  }
+  get daysInYear() {
+    const e = getInternalSlotOrThrowForPlainYearMonth(this);
+    return calendarIsoToDate(e.Y, e.o).de;
+  }
+  get daysInMonth() {
+    const e = getInternalSlotOrThrowForPlainYearMonth(this);
+    return calendarIsoToDate(e.Y, e.o).le;
+  }
+  get monthsInYear() {
+    const e = getInternalSlotOrThrowForPlainYearMonth(this);
+    return calendarIsoToDate(e.Y, e.o).me;
+  }
+  get inLeapYear() {
+    const e = getInternalSlotOrThrowForPlainYearMonth(this);
+    return calendarIsoToDate(e.Y, e.o).ue;
+  }
+  with(e, t = void 0) {
+    const o = getInternalSlotOrThrowForPlainYearMonth(this);
+    validatePartialTemporalObject(e);
+    const n = calendarMergeFields(
+      o.Y,
+      isoDateToFields(o.Y, o.o, m),
+      prepareCalendarFields(o.Y, e, [yt.t, yt.u, yt.v]),
+    );
+    return createTemporalYearMonth(
+      calendarYearMonthFromFields(o.Y, n, getTemporalOverflowOption(getOptionsObject(t))),
+      o.Y,
+    );
+  }
+  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.Y === o.Y;
+  }
+  toString(e = void 0) {
+    return temporalYearMonthToString(
+      getInternalSlotOrThrowForPlainYearMonth(this),
+      getTemporalShowCalendarNameOption(getOptionsObject(e)),
+    );
+  }
+  toLocaleString(e = void 0, t = void 0) {
+    return (
+      getInternalSlotOrThrowForPlainYearMonth(this),
+      formatDateTime(createDateTimeFormat(e, t, s), this)
+    );
+  }
+  toJSON() {
+    return temporalYearMonthToString(getInternalSlotOrThrowForPlainYearMonth(this), C);
+  }
+  valueOf() {
+    throwTypeError(Se);
+  }
+  toPlainDate(e) {
+    const t = getInternalSlotOrThrowForPlainYearMonth(this);
+    return (
+      isObject(e) || throwTypeError(notObject(e)),
+      createTemporalDate(
+        calendarDateFromFields(
+          t.Y,
+          calendarMergeFields(
+            t.Y,
+            isoDateToFields(t.Y, t.o, m),
+            prepareCalendarFields(t.Y, e, [yt.T], []),
+          ),
+          h,
+        ),
+        t.Y,
+      )
+    );
+  }
+};
+(defineStringTag(Tt.prototype, "Temporal.PlainYearMonth"), renameFunction(Tt, "PlainYearMonth"));
+const Dt = new WeakMap();
+var ht = class {
+  constructor(e, t, o, n = "iso8601") {
+    const r = toIntegerWithTruncation(e),
+      a = toIntegerWithTruncation(t),
+      i = toIntegerWithTruncation(o);
+    validateString(n);
+    const c = canonicalizeCalendar(n);
+    (isValidIsoDate(r, a, i) || throwRangeError(ue),
+      createTemporalDate(createIsoDateRecord(r, a, i), c, 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).Y;
+  }
+  get era() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.Y, e.o).oe;
+  }
+  get eraYear() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.Y, e.o).ne;
+  }
+  get year() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.Y, e.o).t;
+  }
+  get month() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.Y, e.o).u;
+  }
+  get monthCode() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.Y, e.o).v;
+  }
+  get day() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.Y, e.o).T;
+  }
+  get dayOfWeek() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.Y, e.o).re;
+  }
+  get dayOfYear() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.Y, e.o).ae;
+  }
+  get weekOfYear() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.Y, e.o).ie.ce;
+  }
+  get yearOfWeek() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.Y, e.o).ie.t;
+  }
+  get daysInWeek() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.Y, e.o).se;
+  }
+  get daysInMonth() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.Y, e.o).le;
+  }
+  get daysInYear() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.Y, e.o).de;
+  }
+  get monthsInYear() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.Y, e.o).me;
+  }
+  get inLeapYear() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return calendarIsoToDate(e.Y, e.o).ue;
+  }
+  toPlainYearMonth() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return createTemporalYearMonth(
+      calendarYearMonthFromFields(e.Y, isoDateToFields(e.Y, e.o, s), h),
+      e.Y,
+    );
+  }
+  toPlainMonthDay() {
+    const e = getInternalSlotOrThrowForPlainDate(this);
+    return createTemporalMonthDay(
+      calendarMonthDayFromFields(e.Y, isoDateToFields(e.Y, e.o, s), h),
+      e.Y,
+    );
+  }
+  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(e, t = void 0) {
+    const o = getInternalSlotOrThrowForPlainDate(this);
+    validatePartialTemporalObject(e);
+    const n = calendarMergeFields(
+        o.Y,
+        isoDateToFields(o.Y, o.o, s),
+        prepareCalendarFields(o.Y, e, [yt.t, yt.u, yt.v, yt.T]),
+      ),
+      r = getTemporalOverflowOption(getOptionsObject(t));
+    return createTemporalDate(calendarDateFromFields(o.Y, n, r), o.Y);
+  }
+  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.Y, o.Y);
+  }
+  toPlainDateTime(e = void 0) {
+    const t = getInternalSlotOrThrowForPlainDate(this);
+    return createTemporalDateTime(combineIsoDateAndTimeRecord(t.o, toTimeRecordOrMidnight(e)), t.Y);
+  }
+  toZonedDateTime(e) {
+    const t = getInternalSlotOrThrowForPlainDate(this);
+    let o, n;
+    if (isObject(e)) {
+      const t = e.timeZone;
+      void 0 === t
+        ? (n = toTemporalTimeZoneIdentifier(e))
+        : ((n = toTemporalTimeZoneIdentifier(t)), (o = e.plainTime));
+    } else n = toTemporalTimeZoneIdentifier(e);
+    return createTemporalZonedDateTime(
+      void 0 === o
+        ? getStartOfDay(n, t.o)
+        : getEpochNanosecondsFor(
+            n,
+            validateIsoDateTime(combineIsoDateAndTimeRecord(t.o, toTemporalTime(o))),
+            g,
+          ),
+      n,
+      t.Y,
+    );
+  }
+  toString(e = void 0) {
+    return temporalDateToString(
+      getInternalSlotOrThrowForPlainDate(this),
+      getTemporalShowCalendarNameOption(getOptionsObject(e)),
+    );
+  }
+  toLocaleString(e = void 0, t = void 0) {
+    return (
+      getInternalSlotOrThrowForPlainDate(this), formatDateTime(createDateTimeFormat(e, t, s), this)
+    );
+  }
+  toJSON() {
+    return temporalDateToString(getInternalSlotOrThrowForPlainDate(this), C);
+  }
+  valueOf() {
+    throwTypeError(Se);
+  }
+};
+(defineStringTag(ht.prototype, "Temporal.PlainDate"), renameFunction(ht, "PlainDate"));
+const pt = createNullPrototypeObject({}),
+  gt = { chinese: createLruCache(2e3), dangi: createLruCache(2e3) },
+  ft = { chinese: createLruCache(1e4), dangi: createLruCache(1e4) },
+  It = createLruCache(5e3),
+  Ot = createLruCache(1e3),
+  Ft = new Map([
+    ["ah", 1],
+    ["bh", !1],
+  ]),
+  St = createNullPrototypeObject({
+    iso8601: new Map(),
+    buddhist: new Map([["be", 1]]),
+    chinese: new Map(),
+    coptic: new Map([["am", 1]]),
+    dangi: new Map(),
+    ethioaa: new Map([["aa", 1]]),
+    ethiopic: new Map([
+      ["am", 1],
+      ["aa", -5499],
+    ]),
+    gregory: new Map([
+      ["ce", 1],
+      ["bce", !1],
+    ]),
+    hebrew: new Map([["am", 1]]),
+    indian: new Map([["shaka", 1]]),
+    "islamic-civil": Ft,
+    "islamic-tbla": Ft,
+    "islamic-umalqura": Ft,
+    japanese: new Map([
+      ["reiwa", 2019],
+      ["heisei", 1989],
+      ["showa", 1926],
+      ["taisho", 1912],
+      ["meiji", 1868],
+      ["ce", 1],
+      ["bce", !1],
+    ]),
+    persian: new Map([["ap", 1]]),
+    roc: new Map([
+      ["roc", 1],
+      ["broc", !1],
+    ]),
+  }),
+  yt = {
+    oe: "era",
+    ne: "eraYear",
+    t: "year",
+    u: "month",
+    v: "monthCode",
+    T: "day",
+    D: "hour",
+    I: "minute",
+    O: "second",
+    F: "millisecond",
+    S: "microsecond",
+    $: "nanosecond",
+    M: "offset",
+    P: "timeZone",
+  },
+  wt = [yt.oe, yt.ne, yt.t, yt.u, yt.v, yt.T, yt.D, yt.I, yt.O, yt.F, yt.S, yt.$, yt.M, yt.P],
+  vt = {
+    [yt.oe]: [toString],
+    [yt.ne]: [toIntegerWithTruncation],
+    [yt.t]: [toIntegerWithTruncation],
+    [yt.u]: [toPositiveIntegerWithTruncation],
+    [yt.v]: [(e) => createMonthCode(...parseMonthCode(e))],
+    [yt.T]: [toPositiveIntegerWithTruncation],
+    [yt.D]: [toIntegerWithTruncation, 0],
+    [yt.I]: [toIntegerWithTruncation, 0],
+    [yt.O]: [toIntegerWithTruncation, 0],
+    [yt.F]: [toIntegerWithTruncation, 0],
+    [yt.S]: [toIntegerWithTruncation, 0],
+    [yt.$]: [toIntegerWithTruncation, 0],
+    [yt.M]: [
+      (e) => {
+        const t = toPrimitive(e);
+        return (validateString(t), parseDateTimeUtcOffset(t), t);
+      },
+    ],
+    [yt.P]: [toTemporalTimeZoneIdentifier],
+  },
+  Et = new WeakMap(),
+  Mt = signTimeDuration;
+var bt = class {
+  constructor(e = 0, t = 0, o = 0, n = 0, r = 0, a = 0, i = 0, c = 0, s = 0, l = 0) {
+    createTemporalDuration(
+      createTemporalDurationSlot([e, t, o, n, r, a, i, c, s, l].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),
+      l = toInternalDurationRecord(r);
+    let d, m;
+    return a.Me && (isDateUnit(i) || isDateUnit(c))
+      ? compareEpochNanoseconds(addZonedDateTime(a.Me, s, h), addZonedDateTime(a.Me, l, h))
+      : (isCalendarUnit(i) || isCalendarUnit(c)
+          ? (a.be || throwRangeError(missingField("relativeTo")),
+            (d = dateDurationDays(s.A, a.be)),
+            (m = dateDurationDays(l.A, a.be)))
+          : ((d = n[te]), (m = r[te])),
+        Me(add24HourDaysToTimeDuration(s.p, d), add24HourDaysToTimeDuration(l.p, m)));
+  }
+  get years() {
+    return getInternalSlotOrThrowForDuration(this)[X];
+  }
+  get months() {
+    return getInternalSlotOrThrowForDuration(this)[Q];
+  }
+  get weeks() {
+    return getInternalSlotOrThrowForDuration(this)[ee];
+  }
+  get days() {
+    return getInternalSlotOrThrowForDuration(this)[te];
+  }
+  get hours() {
+    return getInternalSlotOrThrowForDuration(this)[oe];
+  }
+  get minutes() {
+    return getInternalSlotOrThrowForDuration(this)[ne];
+  }
+  get seconds() {
+    return getInternalSlotOrThrowForDuration(this)[re];
+  }
+  get milliseconds() {
+    return getInternalSlotOrThrowForDuration(this)[ae];
+  }
+  get microseconds() {
+    return getInternalSlotOrThrowForDuration(this)[ie];
+  }
+  get nanoseconds() {
+    return getInternalSlotOrThrowForDuration(this)[ce];
+  }
+  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(
+      applySignToDurationSlot(getInternalSlotOrThrowForDuration(this), -1),
+    );
+  }
+  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),
+      o = getRoundToOptionsObject(e);
+    let n = getTemporalUnitValuedOption(o, "largestUnit", void 0);
+    const r = getTemporalRelativeToOption(o),
+      a = getRoundingIncrementOption(o),
+      i = getRoundingModeOption(o, Z);
+    let c = getTemporalUnitValuedOption(o, "smallestUnit", void 0);
+    validateTemporalUnitValue(c, d);
+    const s = void 0 !== c;
+    c ??= K;
+    const l = defaultTemporalLargestUnit(t),
+      m = largerOfTwoTemporalUnits(l, c),
+      u = void 0 !== n;
+    if (
+      ((void 0 !== n && "auto" !== n) || (n = m),
+      ((!s && !u) || n > c) && throwRangeError(fe),
+      isDateUnit(c) ||
+        validateTemporalRoundingIncrement(a, maximumTemporalDurationRoundingIncrement(c), !1),
+      a > 1 && n !== c && isDateUnit(c) && throwRangeError(fe),
+      r.Me)
+    )
+      return createTemporalDuration(
+        temporalDurationFromInternal(
+          differenceZonedDateTimeWithRounding(
+            r.Me,
+            createZonedDateTimeSlot(
+              addZonedDateTime(r.Me, toInternalDurationRecord(t), h),
+              r.Me.P,
+              r.Me.Y,
+            ),
+            n,
+            a,
+            c,
+            i,
+          ),
+          isDateUnit(n) ? J : n,
+        ),
+      );
+    if (r.be) {
+      const e = toInternalDurationRecordWith24HourDays(t),
+        o = addTime(midnightTimeRecord(), e.p);
+      return createTemporalDuration(
+        temporalDurationFromInternal(
+          differencePlainDateTimeWithRounding(
+            combineIsoDateAndTimeRecord(r.be.o, midnightTimeRecord()),
+            combineIsoDateAndTimeRecord(
+              calendarDateAdd(r.be.Y, r.be.o, adjustDateDurationRecord(e.A, o.K), h),
+              o,
+            ),
+            r.be.Y,
+            n,
+            a,
+            c,
+            i,
+          ),
+          n,
+        ),
+      );
+    }
+    (isCalendarUnit(l) || isCalendarUnit(n)) && throwRangeError(missingField("relativeTo"));
+    const T = toInternalDurationRecordWith24HourDays(t);
+    return createTemporalDuration(
+      temporalDurationFromInternal(
+        c === B
+          ? combineDateAndTimeDuration(
+              createDateDurationRecord(0, 0, 0, roundTimeDurationByDays(T.p, a, i)[0]),
+              createTimeDurationFromSeconds(0),
+            )
+          : combineDateAndTimeDuration(zeroDateDuration(), roundTimeDuration(T.p, a, c, i)),
+        n,
+      ),
+    );
+  }
+  total(e) {
+    const t = getInternalSlotOrThrowForDuration(this);
+    void 0 === e && throwTypeError(ye);
+    const o = "string" == typeof e ? createNullPrototypeObject({ unit: e }) : getOptionsObject(e),
+      n = getTemporalRelativeToOption(o),
+      r = getTemporalUnitValuedOption(o, "unit", T);
+    if ((validateTemporalUnitValue(r, d), n.Me))
+      return ((e, t, o) =>
+        isDateUnit(o)
+          ? totalRelativeDuration(
+              differenceZonedDateTime(e, t, o),
+              e.U,
+              t.U,
+              getIsoDateTimeForZonedDateTimeSlot(e),
+              e.P,
+              e.Y,
+              o,
+            )
+          : totalTimeDuration(timeDurationFromEpochNanosecondsDifference(t.U, e.U), o))(
+        n.Me,
+        createZonedDateTimeSlot(
+          addZonedDateTime(n.Me, toInternalDurationRecord(t), h),
+          n.Me.P,
+          n.Me.Y,
+        ),
+        r,
+      );
+    if (n.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,
+              o,
+              n,
+            ))
+          : 0)(
+        combineIsoDateAndTimeRecord(n.be.o, midnightTimeRecord()),
+        combineIsoDateAndTimeRecord(
+          calendarDateAdd(n.be.Y, n.be.o, adjustDateDurationRecord(e.A, o.K), h),
+          o,
+        ),
+        n.be.Y,
+        r,
+      );
+    }
+    return (
+      (isCalendarUnit(defaultTemporalLargestUnit(t)) || isCalendarUnit(r)) &&
+        throwRangeError(missingField("relativeTo")),
+      totalTimeDuration(toInternalDurationRecordWith24HourDays(t).p, r)
+    );
+  }
+  toString(e = void 0) {
+    const t = getInternalSlotOrThrowForDuration(this),
+      o = getOptionsObject(e),
+      n = getTemporalFractionalSecondDigitsOption(o),
+      r = getRoundingModeOption(o, P),
+      a = getTemporalUnitValuedOption(o, "smallestUnit", void 0);
+    (validateTemporalUnitValue(a, l), (a !== J && a !== G) || throwRangeError(disallowedUnit(a)));
+    const i = toSecondsStringPrecisionRecord(a, n);
+    if (i.ve === K && 1 === i.Ee) return temporalDurationToString(t, i.$e);
+    const c = toInternalDurationRecord(t);
+    return temporalDurationToString(
+      temporalDurationFromInternal(
+        combineDateAndTimeDuration(c.A, roundTimeDuration(c.p, i.Ee, i.ve, r)),
+        largerOfTwoTemporalUnits(defaultTemporalLargestUnit(t), _),
+      ),
+      i.$e,
+    );
+  }
+  toJSON() {
+    return temporalDurationToString(getInternalSlotOrThrowForDuration(this));
+  }
+  toLocaleString(e = void 0, t = void 0) {
+    const o = getInternalSlotOrThrowForDuration(this),
+      n = createNullPrototypeObject({});
+    return (
+      le.map((e, t) => {
+        n[e] = o[t];
+      }),
+      new Intl.DurationFormat(e, t).format(n)
+    );
+  }
+  valueOf() {
+    throwTypeError(Se);
+  }
+};
+(defineStringTag(bt.prototype, "Temporal.Duration"), renameFunction(bt, "Duration"));
+const Pt = {
+    [E]: Math.ceil,
+    [M]: Math.floor,
+    [b]: roundExpand,
+    [P]: Math.trunc,
+    [R]: roundHalfCeil,
+    [N]: roundHalfFloor,
+    [Z]: (e) => (isIntegerAndHalf(e) ? roundExpand(e) : Math.round(e)) + 0,
+    [$]: (e) => (isIntegerAndHalf(e) ? Math.trunc(e) : Math.round(e)) + 0,
+    [Y]: roundHalfEven,
+  },
+  Rt = {
+    [E]: Math.ceil,
+    [M]: Math.floor,
+    [b]: Math.ceil,
+    [P]: Math.floor,
+    [R]: roundHalfCeil,
+    [N]: roundHalfFloor,
+    [Z]: roundHalfCeil,
+    [$]: roundHalfFloor,
+    [Y]: roundHalfEven,
+  },
+  Nt = globalThis.Intl.DateTimeFormat,
+  Zt = [];
+new Nt(
+  void 0,
+  new Proxy(
+    {},
+    {
+      get(e, t) {
+        Zt.push(t);
+      },
+    },
+  ),
+);
+const $t = new WeakMap(),
+  Yt = ["year", "month", "day", "weekday", "dateStyle"],
+  Ct = ["hour", "minute", "second", "fractionalSecondDigits", "dayPeriod", "timeStyle"];
+var Ut = class {
+    Ae(e) {
+      return formatDateTime(this, e);
+    }
+  },
+  jt = class {
+    constructor(e, t) {
+      createDateTimeFormat(e, t, d, void 0, this);
+    }
+    get format() {
+      return Object.defineProperty(
+        (getInternalSlotOrThrowForDateTimeFormat(this).ke ||= Ut.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(Oe),
+        ((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(Oe),
+        ((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).Pe.resolvedOptions();
+    }
+  };
+const Wt = Object.getOwnPropertyDescriptors(Intl.DateTimeFormat);
+((Wt.prototype.value = jt.prototype),
+  Object.defineProperties(DateTimeFormat, Wt),
+  (DateTimeFormat.prototype.constructor = DateTimeFormat),
+  defineStringTag(DateTimeFormat.prototype, "Intl.DateTimeFormat"));
+const At = new WeakMap();
+var Lt = 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)).U,
+      getInternalSlotOrThrowForInstant(toTemporalInstant$1(t)).U,
+    );
+  }
+  get epochMilliseconds() {
+    return epochMilliseconds(getInternalSlotOrThrowForInstant(this).U);
+  }
+  get epochNanoseconds() {
+    return convertEpochNanosecondsToBigInt(getInternalSlotOrThrowForInstant(this).U);
+  }
+  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 t = getInternalSlotOrThrowForInstant(this),
+      o = getRoundToOptionsObject(e),
+      n = getRoundingIncrementOption(o),
+      r = getRoundingModeOption(o, Z),
+      a = getTemporalUnitValuedOption(o, "smallestUnit", T);
+    return (
+      validateTemporalUnitValue(a, l),
+      validateTemporalRoundingIncrement(n, i / nanosecondsForTimeUnit(a), !0),
+      createTemporalInstant(roundTemporalInstant(t.U, n, a, r))
+    );
+  }
+  equals(e) {
+    return !compareEpochNanoseconds(
+      getInternalSlotOrThrowForInstant(this).U,
+      getInternalSlotOrThrowForInstant(toTemporalInstant$1(e)).U,
+    );
+  }
+  toString(e = void 0) {
+    const t = getInternalSlotOrThrowForInstant(this),
+      o = getOptionsObject(e),
+      n = getTemporalFractionalSecondDigitsOption(o),
+      r = getRoundingModeOption(o, P),
+      a = getTemporalUnitValuedOption(o, "smallestUnit", void 0),
+      i = o.timeZone;
+    (validateTemporalUnitValue(a, l), a === J && throwRangeError(invalidField("smallestUnit")));
+    const c = mapUnlessUndefined(i, toTemporalTimeZoneIdentifier),
+      s = toSecondsStringPrecisionRecord(a, n);
+    return temporalInstantToString(roundTemporalInstant(t.U, s.Ee, s.ve, r), c, s.$e);
+  }
+  toLocaleString(e = void 0, t = void 0) {
+    return (
+      getInternalSlotOrThrowForInstant(this), formatDateTime(createDateTimeFormat(e, t, d), this)
+    );
+  }
+  toJSON() {
+    return temporalInstantToString(getInternalSlotOrThrowForInstant(this).U);
+  }
+  valueOf() {
+    throwTypeError(Se);
+  }
+  toZonedDateTimeISO(e) {
+    return createTemporalZonedDateTime(
+      getInternalSlotOrThrowForInstant(this).U,
+      toTemporalTimeZoneIdentifier(e),
+      "iso8601",
+    );
+  }
+};
+(defineStringTag(Lt.prototype, "Temporal.Instant"), renameFunction(Lt, "Instant"));
+const kt = class {
+    toTemporalInstant() {
+      const e = Date.prototype.valueOf.call(this);
+      return (
+        isNaN(e) && throwRangeError("invalid date"),
+        createTemporalInstant(createEpochNanosecondsFromEpochMilliseconds(e))
+      );
+    }
+  }.prototype.toTemporalInstant,
+  zt = Object.getOwnPropertyDescriptors(globalThis.Intl);
+zt.DateTimeFormat.value = DateTimeFormat;
+const Vt = {};
+Object.defineProperties(Vt, zt);
+const xt = {
+  timeZoneId: () => systemTimeZoneIdentifier(),
+  instant: () => createTemporalInstant(systemUtcEpochNanoseconds()),
+  plainDateTimeISO: (e = void 0) => createTemporalDateTime(systemDateTime(e), "iso8601"),
+  zonedDateTimeISO: (e = systemTimeZoneIdentifier()) =>
+    createTemporalZonedDateTime(
+      systemUtcEpochNanoseconds(),
+      toTemporalTimeZoneIdentifier(e),
+      "iso8601",
+    ),
+  plainDateISO: (e = void 0) => createTemporalDate(systemDateTime(e).o, "iso8601"),
+  plainTimeISO: (e = void 0) => createTemporalTime(systemDateTime(e).p),
+};
+(defineStringTag(xt, "Temporal.Now"), makePropertiesNonEnumerable(xt));
+const Ht = {
+  Instant: Lt,
+  PlainDateTime: $e,
+  PlainDate: ht,
+  PlainTime: Ce,
+  PlainYearMonth: Tt,
+  PlainMonthDay: mt,
+  Duration: bt,
+  ZonedDateTime: Pe,
+  Now: xt,
+};
+(defineStringTag(Ht, "Temporal"), makePropertiesNonEnumerable(Ht));
+export { defineNonEnumerableProperty as i, Vt as n, kt as r, Ht as t };