temporal-polyfill-lite 0.3.0 → 0.3.2

package/dist/src-D8sFgi35.js

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