@fedify/redis 2.4.0-dev.1583 → 2.4.0-dev.1599

package/dist/node_modules/.pnpm/temporal-polyfill@1.0.1/node_modules/temporal-polyfill/chunks/internal.cjs

@@ -0,0 +1,2711 @@
+
+const require_errorMessages = require("../../../../temporal-utils@1.0.1/node_modules/temporal-utils/dist/errorMessages.cjs");
+const require_utils = require("../../../../temporal-utils@1.0.1/node_modules/temporal-utils/dist/utils.cjs");
+//#region ../../node_modules/.pnpm/temporal-polyfill@1.0.1/node_modules/temporal-polyfill/chunks/internal.js
+const invalidEntity = require_errorMessages.invalidEntity;
+const missingField = (fieldName) => `Missing ${fieldName}`;
+const noValidFields = (validFields) => "No valid fields: " + validFields.join();
+const invalidBag = "Invalid bag";
+const invalidChoice = (fieldName, val, choiceMap) => require_errorMessages.invalidEntity(fieldName, val) + "; must be " + Object.keys(choiceMap).join();
+const forbiddenValueOf = "Cannot use valueOf";
+const invalidCallingContext = "Invalid calling context";
+const missingYear = (allowEra) => "Missing year" + (allowEra ? "/era/eraYear" : "");
+const invalidLeapMonth = "Invalid leap month";
+const invalidCalendar = (calendarId) => require_errorMessages.invalidEntity("Calendar", calendarId);
+const exoticCalendarRequired = (calendarId, remedy) => `Unknown calendar ${calendarId}; might need ${remedy}`;
+const invalidTimeZone = (calendarId) => require_errorMessages.invalidEntity("TimeZone", calendarId);
+const failedParse = (s) => `Cannot parse: ${s}`;
+const invalidSubstring = (substring) => `Invalid substring: ${substring}`;
+const constrainToRange = require_utils.constrainToRange;
+const isObjectLike = require_utils.isObjectLike;
+function throwRangeError(message) {
+	throw new RangeError(message);
+}
+function throwTypeError(message) {
+	throw new TypeError(message);
+}
+function clampProp(props, propName, min, max, overflow) {
+	return clampEntity(propName, ((props, propName) => {
+		const propVal = props[propName];
+		return void 0 === propVal && throwTypeError(missingField(propName)), propVal;
+	})(props, propName), min, max, overflow);
+}
+function clampEntity(entityName, num, min, max, overflow, choices) {
+	const clamped = constrainToRange(num, min, max);
+	return overflow && num !== clamped && throwRangeError(((entityName, val, min, max, choices) => choices ? require_errorMessages.numberOutOfRange(entityName, choices[val], choices[min], choices[max]) : require_errorMessages.numberOutOfRange(entityName, val, min, max))(entityName, num, min, max, choices)), clamped;
+}
+function memoize(generator, MapClass = Map) {
+	const map = new MapClass();
+	return (key, ...otherArgs) => {
+		if (map.has(key)) return map.get(key);
+		const val = generator(key, ...otherArgs);
+		return map.set(key, val), val;
+	};
+}
+const createNameDescriptors = (name) => createPropDescriptors({ name }, 1);
+const createPropDescriptors = (propVals, readonly) => mapProps((value) => ({
+	value,
+	configurable: 1,
+	writable: !readonly
+}), propVals);
+const createStringTagDescriptors = (value) => ({ [Symbol.toStringTag]: {
+	value,
+	configurable: 1
+} });
+function mapProps(transformer, props) {
+	const res = {};
+	for (const propName in props) res[propName] = transformer(props[propName], propName);
+	return res;
+}
+function zipPropsConst(propNames, propVal) {
+	const res = {};
+	for (const propName of propNames) res[propName] = propVal;
+	return res;
+}
+function createPropGetters(propNames) {
+	const getters = {};
+	for (const propName of propNames) getters[propName] = (slots) => slots[propName];
+	return getters;
+}
+function pluckProps(propNames, props, dest = Object.create(null)) {
+	for (const propName of propNames) dest[propName] = props[propName];
+	return dest;
+}
+function allPropsEqual(propNames, props0, props1) {
+	for (const propName of propNames) if (props0[propName] !== props1[propName]) return 0;
+	return 1;
+}
+function zeroOutProps(propNames, clearUntilI, props) {
+	const copy = { ...props };
+	for (let i = 0; i < clearUntilI; i++) copy[propNames[i]] = 0;
+	return copy;
+}
+function bindArgs(f, ...boundArgs) {
+	return (...dynamicArgs) => f(...boundArgs, ...dynamicArgs);
+}
+function noop() {}
+function capitalize(s) {
+	return s[0].toUpperCase() + s.substring(1);
+}
+function sortStrings(...strss) {
+	return [].concat(...strss).sort();
+}
+function createRegExp(meat) {
+	return new RegExp(`^${meat}$`, "i");
+}
+function parseSubsecNano(fracStr) {
+	return parseInt(fracStr.padEnd(9, "0"));
+}
+function parseSign(s) {
+	return s && "+" !== s ? -1 : 1;
+}
+function parseInt0(s) {
+	return void 0 === s ? 0 : parseInt(s);
+}
+function padNumber(digits, num) {
+	return String(num).padStart(digits, "0");
+}
+const padNumber2 = /* @__PURE__ */ bindArgs(padNumber, 2);
+function compareNumbers(a, b) {
+	return Math.sign(a - b);
+}
+function compareBigInts(a, b) {
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+function divFloorBigInt(num, denom) {
+	const whole = num / denom;
+	return num % denom < 0n ? whole - 1n : whole;
+}
+function divModFloorBigInt(num, divisor) {
+	const quotient = divFloorBigInt(num, divisor);
+	return [quotient, num - quotient * divisor];
+}
+function divModFloor(num, divisor) {
+	return [Math.floor(num / divisor), modFloor(num, divisor)];
+}
+function modFloor(num, divisor) {
+	return (num % divisor + divisor) % divisor;
+}
+function divTrunc(num, divisor) {
+	return Math.trunc(num / divisor) || 0;
+}
+function modTrunc(num, divisor) {
+	return num % divisor || 0;
+}
+function fabricateNearHalfFraction(halfCompare, sign = 1) {
+	return sign * (.5 + halfCompare / 5);
+}
+function hasHalf(num) {
+	return .5 === Math.abs(num % 1);
+}
+const isoCalendarId = "iso8601";
+const gregoryCalendarId = "gregory";
+const gregoryEraOrigins = {
+	"bce": -1,
+	"ce": 0
+};
+function normalizeEraName(era) {
+	const normalized = era.normalize("NFD").toLowerCase().replace(/[^a-z0-9]/g, "");
+	return "bc" === normalized || "b" === normalized ? "bce" : "ad" === normalized || "a" === normalized ? "ce" : normalized;
+}
+function getCalendarSlotId(calendar) {
+	return calendar === void 0 ? "iso8601" : 0 === calendar ? "gregory" : calendar.id;
+}
+const monthCodeRegExp = /^M(\d{2})(L?)$/;
+function parseMonthCode(monthCode) {
+	const m = monthCodeRegExp.exec(monthCode);
+	return m || throwRangeError(((monthCode) => `Invalid monthCode: ${monthCode}`)(monthCode)), [parseInt(m[1]), Boolean(m[2])];
+}
+function formatMonthCode(monthCodeNumber, isLeapMonth) {
+	return "M" + padNumber2(monthCodeNumber) + (isLeapMonth ? "L" : "");
+}
+function monthCodeNumberToMonth(monthCodeNumber, isLeapMonth, leapMonth) {
+	return monthCodeNumber + (isLeapMonth || leapMonth && monthCodeNumber >= leapMonth ? 1 : 0);
+}
+const unitNameMap = {
+	nanosecond: 0,
+	microsecond: 1,
+	millisecond: 2,
+	second: 3,
+	minute: 4,
+	hour: 5,
+	day: 6,
+	week: 7,
+	month: 8,
+	year: 9
+};
+const unitNamesAsc = /* @__PURE__ */ Object.keys(unitNameMap);
+const nanoInMicro = require_utils.nanoInMicro;
+const nanoInMilli = require_utils.nanoInMilli;
+const nanoInSec = require_utils.nanoInSec;
+const nanoInMinute = require_utils.nanoInMinute;
+const nanoInHour = require_utils.nanoInHour;
+const nanoInUtcDay = 864e11;
+const unitNanoMap = [
+	1,
+	nanoInMicro,
+	nanoInMilli,
+	nanoInSec,
+	nanoInMinute,
+	nanoInHour,
+	nanoInUtcDay
+];
+const bigNanoInMicro = /* @__PURE__ */ BigInt(nanoInMicro);
+const bigNanoInMilli = /* @__PURE__ */ BigInt(nanoInMilli);
+const bigNanoInSec = /* @__PURE__ */ BigInt(nanoInSec);
+const bigNanoInMinute = /* @__PURE__ */ BigInt(nanoInMinute);
+const bigNanoInHour = /* @__PURE__ */ BigInt(nanoInHour);
+const bigNanoInUtcDay = /* @__PURE__ */ BigInt(nanoInUtcDay);
+function divideBigNanoToExactNumber(bigNano, divisorNano) {
+	const days = Number(bigNano / bigNanoInUtcDay);
+	const timeNano = Number(bigNano % bigNanoInUtcDay);
+	return days * (nanoInUtcDay / divisorNano) + (Math.trunc(timeNano / divisorNano) + timeNano % divisorNano / divisorNano);
+}
+const timeFieldNamesAsc = /* @__PURE__ */ unitNamesAsc.slice(0, 6);
+const timeGetters = /* @__PURE__ */ createPropGetters(timeFieldNamesAsc);
+const yearFieldNamesAsc = ["year"];
+const dayFieldNamesAsc = ["day"];
+const calendarDateFieldNamesAsc = [
+	"day",
+	"month",
+	"year"
+];
+const offsetFieldNames = ["offset"];
+const timeZoneFieldNames = ["timeZone"];
+const eraYearFieldNames = ["era", "eraYear"];
+const allYearFieldNames = [
+	"era",
+	"eraYear",
+	"year"
+];
+const monthFieldNames = ["month", "monthCode"];
+const monthDayFieldNames = [
+	"day",
+	"month",
+	"monthCode"
+];
+const timeFieldNamesAlpha = /* @__PURE__ */ sortStrings(timeFieldNamesAsc);
+const yearFieldNamesWithEraAlpha = /* @__PURE__ */ sortStrings(eraYearFieldNames, yearFieldNamesAsc);
+const yearMonthFieldNamesAlpha = /* @__PURE__ */ sortStrings(monthFieldNames, yearFieldNamesAsc);
+const yearMonthFieldNamesWithEraAlpha = /* @__PURE__ */ sortStrings(eraYearFieldNames, yearMonthFieldNamesAlpha);
+const yearMonthCodeFieldNamesAlpha = /* @__PURE__ */ sortStrings(["monthCode"], yearFieldNamesAsc);
+const yearMonthCodeFieldNamesWithEraAlpha = /* @__PURE__ */ sortStrings(eraYearFieldNames, yearMonthCodeFieldNamesAlpha);
+const monthCodeDayFieldNamesAlpha = /* @__PURE__ */ sortStrings(dayFieldNamesAsc, ["monthCode"]);
+const dateFieldNamesAlpha = /* @__PURE__ */ sortStrings(dayFieldNamesAsc, yearMonthFieldNamesAlpha);
+const dateFieldNamesWithEraAlpha = /* @__PURE__ */ sortStrings(dayFieldNamesAsc, eraYearFieldNames, yearMonthFieldNamesAlpha);
+const dateTimeFieldNamesAlpha = /* @__PURE__ */ sortStrings(dateFieldNamesAlpha, timeFieldNamesAsc);
+const dateTimeFieldNamesWithEraAlpha = /* @__PURE__ */ sortStrings(dateFieldNamesWithEraAlpha, timeFieldNamesAsc);
+const dateTimeAndOffsetFieldNamesAlpha = /* @__PURE__ */ sortStrings(dateFieldNamesAlpha, timeFieldNamesAsc, offsetFieldNames);
+const dateTimeAndOffsetFieldNamesWithEraAlpha = /* @__PURE__ */ sortStrings(dateFieldNamesWithEraAlpha, timeFieldNamesAsc, offsetFieldNames);
+const dateTimeAndZoneFieldNamesAlpha = /* @__PURE__ */ sortStrings(dateFieldNamesAlpha, timeFieldNamesAsc, offsetFieldNames, timeZoneFieldNames);
+const dateTimeAndZoneFieldNamesWithEraAlpha = /* @__PURE__ */ sortStrings(dateFieldNamesWithEraAlpha, timeFieldNamesAsc, offsetFieldNames, timeZoneFieldNames);
+const yearMonthCodeDayFieldNamesAlpha = /* @__PURE__ */ sortStrings(dayFieldNamesAsc, yearMonthCodeFieldNamesAlpha);
+const yearMonthCodeDayFieldNamesWithEraAlpha = /* @__PURE__ */ sortStrings(dayFieldNamesAsc, eraYearFieldNames, yearMonthCodeFieldNamesAlpha);
+const timeFieldDefaults = /* @__PURE__ */ zipPropsConst(timeFieldNamesAsc, 0);
+function validateTimeFields(timeFields) {
+	return constrainTimeFields(timeFields, 1), timeFields;
+}
+const maxValues = {
+	hour: 23,
+	minute: 59,
+	second: 59
+};
+function constrainTimeFields(timeFields, overflow) {
+	const constrainedFields = {};
+	for (const fieldName of timeFieldNamesAsc) constrainedFields[fieldName] = clampEntity(fieldName, timeFields[fieldName], 0, maxValues[fieldName] || 999, overflow);
+	return constrainedFields;
+}
+function timeFieldsToNano(timeFields) {
+	return timeFieldsToSec(timeFields) * nanoInSec + timeFieldsToSubsecNano(timeFields);
+}
+function timeFieldsToMilli(timeFields) {
+	return 1e3 * timeFieldsToSec(timeFields) + timeFields.millisecond;
+}
+function timeFieldsToSec(timeFields) {
+	return 3600 * timeFields.hour + 60 * timeFields.minute + timeFields.second;
+}
+function timeFieldsToSubsecNano(timeFields) {
+	return timeFields.millisecond * nanoInMilli + timeFields.microsecond * nanoInMicro + timeFields.nanosecond;
+}
+function nanoToTimeAndDay(nano) {
+	const [dayDelta, timeNano] = divModFloor(nano, nanoInUtcDay);
+	return [nanoToTimeFields(timeNano), dayDelta];
+}
+function nanoToTimeFields(timeNano) {
+	const [timeMilli, nanoAfterMilli] = divModFloor(timeNano, nanoInMilli);
+	const [microsecond, nanosecond] = divModFloor(nanoAfterMilli, nanoInMicro);
+	return milliToTimeFields(timeMilli, microsecond, nanosecond);
+}
+function milliToTimeFields(timeMilli, microsecond = 0, nanosecond = 0) {
+	const [hour, milliAfterHour] = divModFloor(timeMilli, 36e5);
+	const [minute, milliAfterMinute] = divModFloor(milliAfterHour, 6e4);
+	const [second, millisecond] = divModFloor(milliAfterMinute, 1e3);
+	return {
+		hour,
+		minute,
+		second,
+		millisecond,
+		microsecond,
+		nanosecond
+	};
+}
+function epochNanoToSecMod(epochNano) {
+	const [epochSec, nano] = divModFloorBigInt(epochNano, bigNanoInSec);
+	return [Number(epochSec), Number(nano)];
+}
+function isoDateTimeToEpochNano(isoDateTime) {
+	return isoDateToEpochNano(isoDateTime) + BigInt(timeFieldsToNano(isoDateTime));
+}
+function isoDateTimeToEpochMilli(isoDateTime) {
+	return isoDateToEpochMilli(isoDateTime) + timeFieldsToMilli(isoDateTime);
+}
+function isoDateToEpochNano(isoDate) {
+	return BigInt(isoDateToEpochDays(isoDate)) * bigNanoInUtcDay;
+}
+function isoDateToEpochMilli(isoDate) {
+	return 864e5 * isoDateToEpochDays(isoDate);
+}
+function isoDateToEpochDays(isoDate) {
+	return isoArgsToEpochDays(isoDate.year, isoDate.month, isoDate.day);
+}
+function isoArgsToEpochDays(isoYear, isoMonth = 1, isoDay = 1) {
+	const monthIndex = isoMonth - 1;
+	return isoYear += Math.floor(monthIndex / 12), isoMonth = modFloor(monthIndex, 12), Date.UTC(isoYear % 400 - 400, isoMonth, 0) / 864e5 + 146097 * (divTrunc(isoYear, 400) + 1) + isoDay;
+}
+function epochNanoToIsoDateTime(epochNano) {
+	const [epochDays, nanoAfterDay] = divModFloorBigInt(epochNano, bigNanoInUtcDay);
+	return {
+		...epochDaysToIsoDate(Number(epochDays)),
+		...nanoToTimeFields(Number(nanoAfterDay))
+	};
+}
+function epochDaysToIsoDate(epochDays) {
+	const legacyDate = /* @__PURE__ */ new Date(864e5 * modFloor(epochDays, 146097));
+	return {
+		year: legacyDate.getUTCFullYear() + 400 * Math.floor(epochDays / 146097),
+		month: legacyDate.getUTCMonth() + 1,
+		day: legacyDate.getUTCDate()
+	};
+}
+const isoEpochFirstLeapYear = 1972;
+function computeIsoMonthCodeParts(month) {
+	return [month, 0];
+}
+function computeIsoYearMonthFieldsForMonthDay(monthCodeNumber, isLeapMonth) {
+	if (!isLeapMonth) return {
+		year: 1972,
+		month: monthCodeNumber
+	};
+}
+function computeIsoFieldsFromParts(year, month, day) {
+	return {
+		year,
+		month,
+		day
+	};
+}
+function computeIsoDaysInMonth(year, month) {
+	switch (month) {
+		case 2: return computeIsoInLeapYear(year) ? 29 : 28;
+		case 4:
+		case 6:
+		case 9:
+		case 11: return 30;
+	}
+	return 31;
+}
+function computeIsoDaysInYear(year) {
+	return computeIsoInLeapYear(year) ? 366 : 365;
+}
+function computeIsoInLeapYear(year) {
+	return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
+}
+function addIsoMonths(year, month, monthDelta) {
+	return year += divTrunc(monthDelta, 12), (month += modTrunc(monthDelta, 12)) < 1 ? (year--, month += 12) : month > 12 && (year++, month -= 12), {
+		year,
+		month
+	};
+}
+function diffIsoMonthSlots(year0, month0, year1, month1) {
+	return 12 * (year1 - year0) + month1 - month0;
+}
+function computeIsoDayOfWeek(isoDateFields) {
+	return modFloor(isoArgsToEpochDays(isoDateFields.year, isoDateFields.month, isoDateFields.day) + 4, 7) || 7;
+}
+function computeIsoDayOfYear(isoDateFields) {
+	return isoArgsToEpochDays(isoDateFields.year, isoDateFields.month, isoDateFields.day) - isoArgsToEpochDays(isoDateFields.year) + 1;
+}
+function computeIsoWeekFields(isoDateFields) {
+	let yearOfWeek = isoDateFields.year;
+	let weekOfYear = Math.floor((computeIsoDayOfYear(isoDateFields) - computeIsoDayOfWeek(isoDateFields) + 10) / 7);
+	let weeksInYear = computeIsoWeeksInYear(yearOfWeek);
+	return weekOfYear < 1 ? weekOfYear = weeksInYear = computeIsoWeeksInYear(--yearOfWeek) : weekOfYear > weeksInYear && (weekOfYear = 1, weeksInYear = computeIsoWeeksInYear(++yearOfWeek)), {
+		weekOfYear,
+		yearOfWeek,
+		Ie: weeksInYear
+	};
+}
+function computeIsoWeeksInYear(year) {
+	const y0DayOfWeek = computeIsoDayOfWeek({
+		year,
+		month: 1,
+		day: 1
+	});
+	return 4 === y0DayOfWeek || 3 === y0DayOfWeek && computeIsoInLeapYear(year) ? 53 : 52;
+}
+function computeGregoryEraFields({ year }) {
+	return year < 1 ? {
+		era: "bce",
+		eraYear: 1 - year
+	} : {
+		era: "ce",
+		eraYear: year
+	};
+}
+function validateIsoDateTimeFields(isoDateTime) {
+	return validateIsoDateFields(isoDateTime), validateTimeFields(isoDateTime);
+}
+function validateIsoDateFields(isoInternals) {
+	return constrainIsoDateFields(isoInternals, 1), isoInternals;
+}
+function isIsoDateFieldsValid(isoDate) {
+	return allPropsEqual(calendarDateFieldNamesAsc, isoDate, constrainIsoDateFields(isoDate));
+}
+function constrainIsoDateFields(isoDate, overflow) {
+	const { year } = isoDate;
+	const month = clampProp(isoDate, "month", 1, 12, overflow);
+	return {
+		year,
+		month,
+		day: clampProp(isoDate, "day", 1, computeIsoDaysInMonth(year, month), overflow)
+	};
+}
+function computeCalendarDateFields(calendar, isoDate) {
+	return calendar ? calendar.ie(isoDate) : isoDate;
+}
+function computeCalendarMonthCodeParts(calendar, year, month) {
+	return calendar ? calendar.O(year, month) : computeIsoMonthCodeParts(month);
+}
+function computeCalendarEraFields(calendar, isoDate) {
+	return 0 === calendar ? computeGregoryEraFields(isoDate) : calendar ? calendar.h(isoDate) : {};
+}
+function computeCalendarIsoFieldsFromParts(calendar, year, month, day) {
+	return calendar ? calendar.je(year, month, day) : computeIsoFieldsFromParts(year, month, day);
+}
+function computeCalendarMonthsInYearForYear(calendar, year) {
+	return calendar ? calendar.k(year) : 12;
+}
+function computeCalendarDaysInMonthForYearMonth(calendar, year, month) {
+	return calendar ? calendar.p(year, month) : computeIsoDaysInMonth(year, month);
+}
+function computeCalendarMonthCode(calendar, isoDate) {
+	const { year, month } = computeCalendarDateFields(calendar, isoDate);
+	const [monthCodeNumber, isLeapMonth] = computeCalendarMonthCodeParts(calendar, year, month);
+	return formatMonthCode(monthCodeNumber, isLeapMonth);
+}
+function computeCalendarInLeapYear(calendar, isoDate) {
+	const { year } = computeCalendarDateFields(calendar, isoDate);
+	return calendar ? calendar.u(year) : computeIsoInLeapYear(year);
+}
+function computeCalendarMonthsInYear(calendar, isoDate) {
+	const { year } = computeCalendarDateFields(calendar, isoDate);
+	return computeCalendarMonthsInYearForYear(calendar, year);
+}
+function computeCalendarDaysInMonth(calendar, isoDate) {
+	const { year, month } = computeCalendarDateFields(calendar, isoDate);
+	return computeCalendarDaysInMonthForYearMonth(calendar, year, month);
+}
+function computeCalendarDaysInYear(calendar, isoDate) {
+	const { year } = computeCalendarDateFields(calendar, isoDate);
+	return calendar ? calendar.j(year) : computeIsoDaysInYear(year);
+}
+function computeCalendarDayOfYear(calendar, isoDate) {
+	if (!calendar) return computeIsoDayOfYear(isoDate);
+	const { year } = computeCalendarDateFields(calendar, isoDate);
+	const yearStartIsoDate = computeCalendarIsoFieldsFromParts(calendar, year, 1, 1);
+	return isoDateToEpochDays(isoDate) - isoDateToEpochDays(yearStartIsoDate) + 1;
+}
+function computeCalendarWeekOfYear(calendar, isoDate) {
+	return calendar === void 0 ? computeIsoWeekFields(isoDate).weekOfYear : void 0;
+}
+function computeCalendarYearOfWeek(calendar, isoDate) {
+	return calendar === void 0 ? computeIsoWeekFields(isoDate).yearOfWeek : void 0;
+}
+const durationFieldNamesAsc = /* @__PURE__ */ unitNamesAsc.map((unitName) => unitName + "s");
+const durationGetters = /* @__PURE__ */ createPropGetters(durationFieldNamesAsc);
+const durationFieldNamesAlpha = /* @__PURE__ */ sortStrings(durationFieldNamesAsc);
+const durationTimeFieldNamesAsc = /* @__PURE__ */ durationFieldNamesAsc.slice(0, 6);
+const durationDateFieldNamesAsc = /* @__PURE__ */ durationFieldNamesAsc.slice(6);
+const durationCalendarFieldNamesAsc = /* @__PURE__ */ durationDateFieldNamesAsc.slice(1);
+const durationFieldIndexes = /* @__PURE__ */ durationFieldNamesAsc.reduce((indexes, fieldName, i) => (indexes[fieldName] = i, indexes), {});
+const durationFieldDefaults = /* @__PURE__ */ zipPropsConst(durationFieldNamesAsc, 0);
+const durationTimeFieldDefaults = /* @__PURE__ */ zipPropsConst(durationTimeFieldNamesAsc, 0);
+const clearDurationFields = /* @__PURE__ */ bindArgs(zeroOutProps, durationFieldNamesAsc);
+function requirePropDefined(optionName, optionVal) {
+	return optionVal ?? throwRangeError(missingField(optionName)), optionVal;
+}
+const requireString = /* @__PURE__ */ bindArgs(requireType, "string");
+function requireType(typeName, arg, entityName = typeName) {
+	return typeof arg !== typeName && throwTypeError(invalidEntity(entityName, arg)), arg;
+}
+function requireNumberIsInteger(num, entityName = "number") {
+	return Number.isInteger(num) || throwRangeError(((entityName, num) => `Non-integer ${entityName}: ${num}`)(entityName, num)), num || 0;
+}
+function toString(arg) {
+	return "symbol" == typeof arg && throwTypeError("Cannot convert Symbol to string"), String(arg);
+}
+function toStringViaPrimitive(arg, entityName) {
+	return require_utils.isObjectLike(arg) ? String(arg) : requireString(arg, entityName);
+}
+function toBigInt(bi) {
+	return "boolean" == typeof bi ? BigInt(bi ? 1 : 0) : "string" == typeof bi ? BigInt(bi) : ("bigint" != typeof bi && throwTypeError(`Invalid bigint: ${bi}`), bi);
+}
+function toStrictInteger(arg, entityName) {
+	return requireNumberIsInteger(require_utils.toFiniteNumber(arg, entityName), entityName);
+}
+function normalizeOptionsOrString(options, optionName) {
+	return "string" == typeof options ? ((optionName, optionVal) => {
+		const res = Object.create(null);
+		return res[optionName] = optionVal, res;
+	})(optionName, options) : require_utils.requireObjectLike(options);
+}
+const smallestUnitStr = "smallestUnit";
+const overflowMap = {
+	constrain: 0,
+	reject: 1
+};
+const epochDisambigMap = {
+	compatible: 0,
+	reject: 1,
+	earlier: 2,
+	later: 3
+};
+const offsetDisambigMap = {
+	reject: 0,
+	use: 1,
+	prefer: 2,
+	ignore: 3
+};
+const calendarDisplayMap = {
+	auto: 0,
+	never: 1,
+	critical: 2,
+	always: 3
+};
+const timeZoneDisplayMap = {
+	auto: 0,
+	never: 1,
+	critical: 2
+};
+const offsetDisplayMap = {
+	auto: 0,
+	never: 1
+};
+const roundingModeMap = {
+	floor: 0,
+	halfFloor: 1,
+	ceil: 2,
+	halfCeil: 3,
+	trunc: 4,
+	halfTrunc: 5,
+	expand: 6,
+	halfExpand: 7,
+	halfEven: 8
+};
+const roundingModeFuncs = [
+	Math.floor,
+	(num) => hasHalf(num) ? Math.floor(num) : Math.round(num),
+	Math.ceil,
+	(num) => hasHalf(num) ? Math.ceil(num) : Math.round(num),
+	Math.trunc,
+	(num) => hasHalf(num) ? Math.trunc(num) || 0 : Math.round(num),
+	(num) => num < 0 ? Math.floor(num) : Math.ceil(num),
+	(num) => Math.sign(num) * Math.round(Math.abs(num)) || 0,
+	(num) => hasHalf(num) ? (num = Math.trunc(num) || 0) + num % 2 : Math.round(num)
+];
+const directionMap = {
+	previous: -1,
+	next: 1
+};
+function coerceRoundingIncInteger(options) {
+	const roundingInc = options.roundingIncrement;
+	return void 0 === roundingInc ? 1 : require_utils.toIntegerWithTrunc(roundingInc, "roundingIncrement");
+}
+function coerceFractionalSecondDigits(options) {
+	let subsecDigits = options.fractionalSecondDigits;
+	if (void 0 !== subsecDigits) {
+		if ("number" != typeof subsecDigits) {
+			if ("auto" === toString(subsecDigits)) return;
+			throwRangeError(invalidEntity("fractionalSecondDigits", subsecDigits));
+		}
+		subsecDigits = clampEntity("fractionalSecondDigits", Math.floor(subsecDigits), 0, 9, 1);
+	}
+	return subsecDigits;
+}
+function coerceUnitOption(optionName, options, minUnit = 0, ensureDefined) {
+	let unitStr = options[optionName];
+	if (void 0 === unitStr) return ensureDefined ? minUnit : void 0;
+	if (unitStr = toString(unitStr), "auto" === unitStr) return ensureDefined ? minUnit : null;
+	let unit = unitNameMap[unitStr];
+	return void 0 === unit && (unit = durationFieldIndexes[unitStr]), void 0 === unit && throwRangeError(invalidChoice(optionName, unitStr, unitNameMap)), unit;
+}
+function coerceChoiceOption(optionName, enumNameMap, options, defaultChoice = 0) {
+	const enumArg = options[optionName];
+	if (void 0 === enumArg) return defaultChoice;
+	const enumStr = toString(enumArg);
+	const enumNum = enumNameMap[enumStr];
+	return void 0 === enumNum && throwRangeError(invalidChoice(optionName, enumStr, enumNameMap)), enumNum;
+}
+const coerceSmallestUnit = /* @__PURE__ */ bindArgs(coerceUnitOption, smallestUnitStr);
+const coerceLargestUnit = /* @__PURE__ */ bindArgs(coerceUnitOption, "largestUnit");
+const coerceTotalUnit = /* @__PURE__ */ bindArgs(coerceUnitOption, "unit");
+const coerceOverflow = /* @__PURE__ */ bindArgs(coerceChoiceOption, "overflow", overflowMap);
+const coerceEpochDisambig = /* @__PURE__ */ bindArgs(coerceChoiceOption, "disambiguation", epochDisambigMap);
+const coerceOffsetDisambig = /* @__PURE__ */ bindArgs(coerceChoiceOption, "offset", offsetDisambigMap);
+const coerceCalendarDisplay = /* @__PURE__ */ bindArgs(coerceChoiceOption, "calendarName", calendarDisplayMap);
+const coerceTimeZoneDisplay = /* @__PURE__ */ bindArgs(coerceChoiceOption, "timeZoneName", timeZoneDisplayMap);
+const coerceOffsetDisplay = /* @__PURE__ */ bindArgs(coerceChoiceOption, "offset", offsetDisplayMap);
+const coerceRoundingMode = /* @__PURE__ */ bindArgs(coerceChoiceOption, "roundingMode", roundingModeMap);
+const coerceDirection = /* @__PURE__ */ bindArgs(coerceChoiceOption, "direction", directionMap);
+function validateRoundingInc(roundingInc, smallestUnit, allowManyLargeUnits, solarMode) {
+	const upUnitNano = solarMode ? nanoInUtcDay : unitNanoMap[smallestUnit + 1];
+	if (upUnitNano) {
+		const unitNano = unitNanoMap[smallestUnit];
+		upUnitNano % ((roundingInc = clampEntity("roundingIncrement", roundingInc, 1, upUnitNano / unitNano - (solarMode ? 0 : 1), 1)) * unitNano) && throwRangeError(invalidEntity("roundingIncrement", roundingInc));
+	} else roundingInc = clampEntity("roundingIncrement", roundingInc, 1, allowManyLargeUnits ? 10 ** 9 : 1, 1);
+	return roundingInc;
+}
+function validateUnitRange(optionName, unit, minUnit, maxUnit) {
+	return null != unit && clampEntity(optionName, unit, minUnit, maxUnit, 1, unitNamesAsc), unit;
+}
+function checkLargestSmallestUnit(largestUnit, smallestUnit) {
+	smallestUnit > largestUnit && throwRangeError("smallestUnit > largestUnit");
+}
+function refineDiffOptions(roundingModeInvert, options, defaultLargestUnit, maxUnit = 9, minUnit = 0, defaultRoundingMode = 4) {
+	options = require_utils.normalizeOptions(options);
+	let largestUnit = coerceLargestUnit(options, minUnit);
+	let roundingInc = coerceRoundingIncInteger(options);
+	let roundingMode = coerceRoundingMode(options, defaultRoundingMode);
+	let smallestUnit = coerceSmallestUnit(options, minUnit, 1);
+	return largestUnit = validateUnitRange("largestUnit", largestUnit, minUnit, maxUnit), smallestUnit = validateUnitRange(smallestUnitStr, smallestUnit, minUnit, maxUnit), null == largestUnit ? largestUnit = Math.max(defaultLargestUnit, smallestUnit) : checkLargestSmallestUnit(largestUnit, smallestUnit), roundingInc = validateRoundingInc(roundingInc, smallestUnit, 1), roundingModeInvert && (roundingMode = ((roundingMode) => roundingMode < 4 ? (roundingMode + 2) % 4 : roundingMode)(roundingMode)), [
+		largestUnit,
+		smallestUnit,
+		roundingInc,
+		roundingMode
+	];
+}
+function refineRoundingOptions(options, maxUnit = 6, solarMode) {
+	let roundingInc = coerceRoundingIncInteger(options = normalizeOptionsOrString(options, smallestUnitStr));
+	const roundingMode = coerceRoundingMode(options, 7);
+	let smallestUnit = coerceSmallestUnit(options);
+	return smallestUnit = requirePropDefined(smallestUnitStr, smallestUnit), smallestUnit = validateUnitRange(smallestUnitStr, smallestUnit, 0, maxUnit), roundingInc = validateRoundingInc(roundingInc, smallestUnit, void 0, solarMode), [
+		smallestUnit,
+		roundingInc,
+		roundingMode
+	];
+}
+function combineDateAndTime(isoDate, time) {
+	return pluckProps(calendarDateFieldNamesAsc, isoDate, pluckProps(timeFieldNamesAsc, time));
+}
+function refineOverflowOptions(options) {
+	return void 0 === options ? 0 : coerceOverflow(require_utils.requireObjectLike(options));
+}
+function refineZonedFieldOptions(options, defaultOffsetDisambig = 0) {
+	options = require_utils.normalizeOptions(options);
+	const epochDisambig = coerceEpochDisambig(options);
+	const offsetDisambig = coerceOffsetDisambig(options, defaultOffsetDisambig);
+	return [
+		coerceOverflow(options),
+		offsetDisambig,
+		epochDisambig
+	];
+}
+const epochNanoMax = /* @__PURE__ */ BigInt(1e8) * bigNanoInUtcDay;
+const epochNanoMin = /* @__PURE__ */ BigInt(-1e8) * bigNanoInUtcDay;
+const plainDateEpochNanoMin = epochNanoMin - bigNanoInUtcDay;
+const isoYearMonthIndexMin = -3261848;
+function checkIsoYearMonthInBounds(isoDate) {
+	const isoYearMonthIndex = 12 * isoDate.year + isoDate.month;
+	return (isoYearMonthIndex < isoYearMonthIndexMin || isoYearMonthIndex > 3309129) && throwRangeError("Out-of-bounds date"), isoDate;
+}
+function checkIsoDateInBounds(isoDate, allowPlainDateLowerEdge = 1) {
+	return checkIsoDateEpochNanoInBounds(isoDateToEpochNano(isoDate), allowPlainDateLowerEdge), isoDate;
+}
+function checkIsoDateTimeInBounds(isoDateTime) {
+	const epochNano = isoDateToEpochNano(isoDateTime);
+	return checkIsoDateEpochNanoInBounds(epochNano), epochNano !== plainDateEpochNanoMin || timeFieldsToNano(isoDateTime) || throwRangeError("Out-of-bounds date"), isoDateTime;
+}
+function checkIsoDateEpochNanoInBounds(epochNano, allowPlainDateLowerEdge = 1) {
+	(epochNano < (allowPlainDateLowerEdge ? plainDateEpochNanoMin : epochNanoMin) || epochNano > epochNanoMax) && throwRangeError("Out-of-bounds date");
+}
+function checkEpochNanoInBounds(epochNano) {
+	return (epochNano < epochNanoMin || epochNano > epochNanoMax) && throwRangeError("Out-of-bounds date"), epochNano;
+}
+function isoDateTimeAndOffsetToEpochNano(isoDateTime, offsetNano) {
+	return checkEpochNanoInBounds(isoDateToEpochNano(isoDateTime) + BigInt(timeFieldsToNano(isoDateTime) - offsetNano));
+}
+function createEpochNanoSlots(epochNano) {
+	return { epochNanoseconds: epochNano };
+}
+function createZonedEpochNanoSlots(epochNano, timeZone, calendar) {
+	return {
+		calendar,
+		timeZone,
+		epochNanoseconds: epochNano
+	};
+}
+function createDateTimeSlots(isoDateTime, calendar) {
+	return pluckProps(timeFieldNamesAsc, isoDateTime, createDateSlots(isoDateTime, calendar));
+}
+function createDateSlots(isoDate, calendar) {
+	return pluckProps(calendarDateFieldNamesAsc, isoDate, { calendar });
+}
+function createTimeSlots(time) {
+	return pluckProps(timeFieldNamesAsc, time);
+}
+function createDurationSlots(durationFields) {
+	return pluckProps(durationFieldNamesAsc, durationFields, { sign: computeDurationSign(durationFields) });
+}
+function getEpochMilli(slots) {
+	return epochNano = slots.epochNanoseconds, Number(divFloorBigInt(epochNano, bigNanoInMilli));
+	var epochNano;
+}
+function getEpochNano(slots) {
+	return slots.epochNanoseconds;
+}
+function totalDuration(refineRelativeTo, slots, options) {
+	const maxDurationUnit = getMaxDurationUnit(slots);
+	const [totalUnit, relativeToSlots] = ((options, refineRelativeTo) => {
+		const relativeToInternals = refineRelativeTo((options = normalizeOptionsOrString(options, "unit")).relativeTo);
+		let totalUnit = coerceTotalUnit(options);
+		return totalUnit = requirePropDefined("unit", totalUnit), [totalUnit, relativeToInternals];
+	})(options, refineRelativeTo);
+	if (!relativeToSlots && isUniformUnit(Math.max(totalUnit, maxDurationUnit), relativeToSlots)) return totalDayTimeDuration(slots, totalUnit);
+	if (relativeToSlots || throwRangeError("Missing relativeTo"), !slots.sign && isUniformUnit(totalUnit, relativeToSlots)) return 0;
+	const markerSpanOps = createMarkerSpanOps(relativeToSlots);
+	const endMarker = markerSpanOps.G(markerSpanOps.i, slots);
+	checkMarkerSpanInBounds(markerSpanOps, endMarker);
+	const balancedDuration = markerSpanOps.re(markerSpanOps.i, endMarker, totalUnit);
+	return isUniformUnit(totalUnit, relativeToSlots) ? totalDayTimeDuration(balancedDuration, totalUnit) : totalRelativeDuration(balancedDuration, markerSpanOps.V(endMarker), totalUnit, markerSpanOps);
+}
+function totalRelativeDuration(durationFields, endEpochNano, totalUnit, markerMoveOps) {
+	const sign = computeDurationSign(durationFields) || 1;
+	const nudgeWindow = clampRelativeDuration(clearDurationFields(totalUnit, durationFields), totalUnit, sign, markerMoveOps, endEpochNano);
+	const epochNano0 = nudgeWindow.ae;
+	const epochNano1 = nudgeWindow.de;
+	const denom = Number(epochNano1 - epochNano0);
+	const numerator = Number(endEpochNano - epochNano0);
+	return nudgeWindow.ye[durationFieldNamesAsc[totalUnit]] + numerator / denom * sign;
+}
+function totalDayTimeDuration(durationFields, totalUnit) {
+	return divideBigNanoToExactNumber(durationDayTimeToBigNano(durationFields), unitNanoMap[totalUnit]);
+}
+function clampRelativeDuration(durationFields, clampUnit, clampDistance, markerMoveOps, epochNanoProgress) {
+	const unitName = durationFieldNamesAsc[clampUnit];
+	let startDurationFields = durationFields;
+	let shifted = 0;
+	let window = computeRelativeDurationWindow(startDurationFields, unitName, clampDistance, markerMoveOps);
+	return epochNanoProgress && !((epochNanoProgress, epochNano0, epochNano1, sign) => sign > 0 ? compareBigInts(epochNano0, epochNanoProgress) <= 0 && compareBigInts(epochNanoProgress, epochNano1) <= 0 : compareBigInts(epochNano1, epochNanoProgress) <= 0 && compareBigInts(epochNanoProgress, epochNano0) <= 0)(epochNanoProgress, window.ae, window.de, Math.sign(clampDistance)) && (startDurationFields = {
+		...durationFields,
+		[unitName]: durationFields[unitName] + clampDistance
+	}, shifted = 1, window = computeRelativeDurationWindow(startDurationFields, unitName, clampDistance, markerMoveOps)), {
+		...window,
+		ye: startDurationFields,
+		He: shifted
+	};
+}
+function computeRelativeDurationWindow(startDurationFields, unitName, clampDistance, markerMoveOps) {
+	const endDurationFields = {
+		...startDurationFields,
+		[unitName]: startDurationFields[unitName] + clampDistance
+	};
+	return {
+		ae: moveMarkerToEpochNano(markerMoveOps, startDurationFields),
+		de: moveMarkerToEpochNano(markerMoveOps, endDurationFields),
+		Ae: endDurationFields
+	};
+}
+function computeEpochNanoFrac(epochNanoProgress, epochNano0, epochNano1) {
+	const denomBig = epochNano1 - epochNano0;
+	const numeratorBig = epochNanoProgress - epochNano0;
+	if (!numeratorBig) return 0;
+	const absNumerator = numeratorBig < 0n ? -numeratorBig : numeratorBig;
+	const absDenom = denomBig < 0n ? -denomBig : denomBig;
+	const fracSign = compareBigInts(numeratorBig, 0n) === compareBigInts(denomBig, 0n) ? 1 : -1;
+	return compareBigInts(absNumerator, absDenom) <= 0 ? absNumerator === absDenom ? fracSign : fabricateNearHalfFraction(compareBigInts(2n * absNumerator, absDenom), fracSign) : Number(numeratorBig) / Number(denomBig);
+}
+function roundZonedEpochSlotsToUnit(slots, smallestUnit, roundingInc, roundingMode) {
+	let { epochNanoseconds } = slots;
+	const { timeZone, calendar } = slots;
+	if (0 === smallestUnit && 1 === roundingInc) return {
+		epochNanoseconds,
+		timeZone,
+		calendar
+	};
+	if (6 === smallestUnit) {
+		const isoFields0 = combineDateAndTime(zonedEpochSlotsToIso(slots), timeFieldDefaults);
+		const isoFields1 = combineDateAndTime(moveByDays(isoFields0, 1), timeFieldDefaults);
+		const epochNano0 = getStartOfDayInstantFor(timeZone, isoFields0);
+		const epochNano1 = getStartOfDayInstantFor(timeZone, isoFields1);
+		epochNanoseconds = roundWithMode(computeEpochNanoFrac(epochNanoseconds, epochNano0, epochNano1), roundingMode) ? epochNano1 : epochNano0;
+	} else {
+		const isoDateTime = zonedEpochSlotsToIso(slots);
+		const offsetNano = isoDateTime.offsetNanoseconds;
+		epochNanoseconds = getMatchingInstantFor(timeZone, roundDateTimeToNano(isoDateTime, computeNanoInc(smallestUnit, roundingInc), roundingMode), offsetNano, 2, 0, 1);
+	}
+	return {
+		epochNanoseconds,
+		timeZone,
+		calendar
+	};
+}
+function computeZonedHoursInDay(slots) {
+	const { timeZone } = slots;
+	const isoFields0 = combineDateAndTime(zonedEpochSlotsToIso(slots), timeFieldDefaults);
+	const isoFields1 = combineDateAndTime(moveByDays(isoFields0, 1), timeFieldDefaults);
+	const epochNano0 = getStartOfDayInstantFor(timeZone, isoFields0);
+	return divideBigNanoToExactNumber(getStartOfDayInstantFor(timeZone, isoFields1) - epochNano0, nanoInHour);
+}
+function computeZonedStartOfDay(slots) {
+	const { timeZone, calendar } = slots;
+	return createZonedEpochNanoSlots(getStartOfDayInstantFor(timeZone, combineDateAndTime(zonedEpochSlotsToIso(slots), timeFieldDefaults)), timeZone, calendar);
+}
+function roundDateTimeToNano(isoDateTime, nanoInc, roundingMode) {
+	const [roundedTimeFields, dayDelta] = roundTimeToNano(isoDateTime, nanoInc, roundingMode);
+	const roundedIsoDateTime = combineDateAndTime(moveByDays(isoDateTime, dayDelta), roundedTimeFields);
+	return checkIsoDateTimeInBounds(roundedIsoDateTime), roundedIsoDateTime;
+}
+function roundTimeToNano(timeFields, nanoInc, roundingMode) {
+	return nanoToTimeAndDay(roundNumberToInc(timeFieldsToNano(timeFields), nanoInc, roundingMode));
+}
+function roundToMinute(offsetNano) {
+	return roundNumberToInc(offsetNano, nanoInMinute, 7);
+}
+function computeNanoInc(smallestUnit, roundingInc) {
+	return unitNanoMap[smallestUnit] * roundingInc;
+}
+function computeBigNanoInc(smallestUnit, roundingInc) {
+	return BigInt(unitNanoMap[smallestUnit]) * BigInt(roundingInc);
+}
+function roundDayTimeDurationByInc(durationFields, nanoInc, roundingMode) {
+	const maxUnit = Math.min(getMaxDurationUnit(durationFields), 6);
+	return nanoToDurationDayTimeFields(roundBigNanoToInc(durationDayTimeToBigNano(durationFields), BigInt(nanoInc), roundingMode), maxUnit);
+}
+function roundRelativeDuration(durationFields, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode, markerMoveOps) {
+	if (0 === smallestUnit && 1 === roundingInc) return durationFields;
+	const sign = computeDurationSign(durationFields) || 1;
+	let [roundedDurationFields, roundedEpochNano, grewBigUnit] = (isUniformUnit(smallestUnit, markerMoveOps.i) ? isZonedEpochSlots(markerMoveOps.i) && smallestUnit < 6 && largestUnit >= 6 ? nudgeZonedTimeDuration : nudgeDayTimeDuration : nudgeRelativeDuration)(sign, durationFields, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode, markerMoveOps);
+	return grewBigUnit && 7 !== smallestUnit && (roundedDurationFields = ((durationFields, endEpochNano, largestUnit, smallestUnit, sign, markerMoveOps) => {
+		for (let currentUnit = smallestUnit + 1; currentUnit <= largestUnit; currentUnit++) {
+			if (7 === currentUnit && 7 !== largestUnit) continue;
+			const baseDurationFields = clearDurationFields(currentUnit, durationFields);
+			baseDurationFields[durationFieldNamesAsc[currentUnit]] += sign;
+			const thresholdCompare = compareBigInts(endEpochNano, moveMarkerToEpochNano(markerMoveOps, baseDurationFields));
+			if (thresholdCompare && thresholdCompare !== sign) break;
+			durationFields = baseDurationFields;
+		}
+		return durationFields;
+	})(roundedDurationFields, roundedEpochNano, largestUnit, Math.max(6, smallestUnit), sign, markerMoveOps)), roundedDurationFields;
+}
+function roundBigNanoToInc(bigNano, bigNanoInc, roundingMode) {
+	return roundBigNanoToIncWithTail(bigNano, bigNanoInc, roundingMode, bigNano / bigNanoInc % 2n);
+}
+function roundBigNanoToDayOriginInc(bigNano, bigNanoInc, roundingMode) {
+	const [day, timeNano] = divModFloorBigInt(bigNano, bigNanoInUtcDay);
+	const dayOriginNano = day * bigNanoInUtcDay;
+	return dayOriginNano + roundBigNanoToIncWithTail(timeNano, bigNanoInc, roundingMode, (dayOriginNano / bigNanoInc + timeNano / bigNanoInc) % 2n);
+}
+function roundBigNanoToIncWithTail(bigNano, bigNanoInc, roundingMode, quotientTail) {
+	const quotient = bigNano / bigNanoInc;
+	const remainder = bigNano % bigNanoInc;
+	let fraction = 0;
+	remainder && (fraction = fabricateNearHalfFraction(compareBigInts(2n * (remainder < 0n ? -remainder : remainder), bigNanoInc), Math.sign(Number(remainder))));
+	const roundedTail = roundWithMode(Number(quotientTail) + fraction, roundingMode);
+	return (quotient - quotientTail + BigInt(roundedTail)) * bigNanoInc;
+}
+function roundNumberToInc(num, roundingInc, roundingMode) {
+	return roundWithMode(num / roundingInc, roundingMode) * roundingInc;
+}
+function roundWithMode(num, roundingMode) {
+	return roundingModeFuncs[roundingMode](num);
+}
+function nudgeDayTimeDuration(sign, durationFields, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode) {
+	const bigNano = durationDayTimeToBigNano(durationFields);
+	const roundedBigNano = roundBigNanoToInc(bigNano, computeBigNanoInc(smallestUnit, roundingInc), roundingMode);
+	const nanoDiff = roundedBigNano - bigNano;
+	const expandedBigUnit = Math.sign(Number(roundedBigNano / bigNanoInUtcDay) - Number(bigNano / bigNanoInUtcDay)) === sign;
+	const roundedDayTimeFields = nanoToDurationDayTimeFields(roundedBigNano, Math.min(largestUnit, 6));
+	return [
+		{
+			...durationFields,
+			...roundedDayTimeFields
+		},
+		endEpochNano + nanoDiff,
+		expandedBigUnit
+	];
+}
+function nudgeZonedTimeDuration(sign, durationFields, endEpochNano, _largestUnit, smallestUnit, roundingInc, roundingMode, markerMoveOps) {
+	const timeNano = Number(durationTimeToBigNano(durationFields));
+	const nanoInc = computeNanoInc(smallestUnit, roundingInc);
+	let roundedTimeNano = roundNumberToInc(timeNano, nanoInc, roundingMode);
+	const dayWindow = clampRelativeDuration({
+		...durationFields,
+		...durationTimeFieldDefaults
+	}, 6, sign, markerMoveOps, endEpochNano);
+	const dayEpochNano0 = dayWindow.ae;
+	const dayEpochNano1 = dayWindow.de;
+	const beyondDayNano = roundedTimeNano - Number(dayEpochNano1 - dayEpochNano0);
+	let dayDelta = 0;
+	beyondDayNano && Math.sign(beyondDayNano) !== sign ? endEpochNano = dayEpochNano0 + BigInt(roundedTimeNano) : (dayDelta += sign, roundedTimeNano = roundNumberToInc(beyondDayNano, nanoInc, roundingMode), endEpochNano = dayEpochNano1 + BigInt(roundedTimeNano));
+	const durationTimeFields = nanoToDurationTimeFields(roundedTimeNano);
+	return [
+		{
+			...durationFields,
+			...durationTimeFields,
+			days: durationFields.days + dayDelta
+		},
+		endEpochNano,
+		Boolean(dayDelta)
+	];
+}
+function nudgeRelativeDuration(sign, durationFields, endEpochNano, _largestUnit, smallestUnit, roundingInc, roundingMode, markerMoveOps) {
+	const smallestUnitFieldName = durationFieldNamesAsc[smallestUnit];
+	const baseDurationFields = clearDurationFields(smallestUnit, durationFields);
+	7 === smallestUnit && (durationFields = {
+		...durationFields,
+		weeks: durationFields.weeks + Math.trunc(durationFields.days / 7)
+	});
+	baseDurationFields[smallestUnitFieldName] = divTrunc(durationFields[smallestUnitFieldName], roundingInc) * roundingInc;
+	const nudgeWindow = clampRelativeDuration(baseDurationFields, smallestUnit, roundingInc * sign, markerMoveOps, endEpochNano);
+	const epochNano0 = nudgeWindow.ae;
+	const epochNano1 = nudgeWindow.de;
+	const frac = computeEpochNanoFrac(endEpochNano, epochNano0, epochNano1);
+	const windowStartVal = nudgeWindow.ye[smallestUnitFieldName];
+	const windowEndVal = nudgeWindow.Ae[smallestUnitFieldName];
+	const roundedVal = roundNumberToInc(windowStartVal + frac * sign * roundingInc, roundingInc, roundingMode);
+	const roundedToEnd = roundedVal === windowEndVal;
+	return baseDurationFields[smallestUnitFieldName] = roundedVal, [
+		baseDurationFields,
+		roundedToEnd ? epochNano1 : epochNano0,
+		nudgeWindow.He || roundedToEnd
+	];
+}
+function getTimeZoneTransitionEpochNanoseconds(slots, options) {
+	return slots.timeZone.U(slots.epochNanoseconds, ((options) => {
+		const res = coerceDirection(normalizeOptionsOrString(options, "direction"), 0);
+		return res || throwRangeError(invalidEntity("direction", res)), res;
+	})(options));
+}
+const zonedEpochSlotsToIso = /* @__PURE__ */ memoize(_zonedEpochSlotsToIso, WeakMap);
+function _zonedEpochSlotsToIso(slots) {
+	const { epochNanoseconds, timeZone } = slots;
+	const offsetNanoseconds = timeZone.C(epochNanoseconds);
+	return {
+		...epochNanoToIsoDateTime(epochNanoseconds + BigInt(offsetNanoseconds)),
+		offsetNanoseconds
+	};
+}
+function getMatchingInstantFor(timeZone, isoDateTime, offsetNano, offsetDisambig = 0, epochDisambig = 0, epochFuzzy, hasZ) {
+	if (void 0 !== offsetNano && 1 === offsetDisambig && (1 === offsetDisambig || hasZ)) return isoDateTimeAndOffsetToEpochNano(isoDateTime, offsetNano);
+	2 !== offsetDisambig && 0 !== offsetDisambig || checkIsoDateInBounds(isoDateTime, 0);
+	const possibleEpochNanos = timeZone.R(isoDateTime);
+	if (void 0 !== offsetNano && 3 !== offsetDisambig) {
+		const matchingEpochNano = ((possibleEpochNanos, isoDateTime, offsetNano, fuzzy) => {
+			const zonedEpochNano = isoDateTimeToEpochNano(isoDateTime);
+			fuzzy && (offsetNano = roundToMinute(offsetNano));
+			for (const possibleEpochNano of possibleEpochNanos) {
+				let possibleOffsetNano = Number(zonedEpochNano - possibleEpochNano);
+				if (fuzzy && (possibleOffsetNano = roundToMinute(possibleOffsetNano)), possibleOffsetNano === offsetNano) return possibleEpochNano;
+			}
+		})(possibleEpochNanos, isoDateTime, offsetNano, epochFuzzy);
+		if (void 0 !== matchingEpochNano) return matchingEpochNano;
+		0 === offsetDisambig && throwRangeError("Invalid TimeZone offset");
+	}
+	return hasZ ? isoDateTimeToEpochNano(isoDateTime) : getSingleInstantFor(timeZone, isoDateTime, epochDisambig, possibleEpochNanos);
+}
+function getSingleInstantFor(timeZone, isoDateTime, disambig = 0, possibleEpochNanos = timeZone.R(isoDateTime)) {
+	if (1 === possibleEpochNanos.length) return possibleEpochNanos[0];
+	if (1 === disambig && throwRangeError("Ambiguous offset"), possibleEpochNanos.length) return possibleEpochNanos[3 === disambig ? 1 : 0];
+	const zonedEpochNano = isoDateTimeToEpochNano(isoDateTime);
+	const gapNano = ((timeZone, zonedEpochNano) => {
+		const startOffsetNano = timeZone.C(zonedEpochNano - bigNanoInUtcDay);
+		return ((gapNano) => (gapNano > 864e11 && throwRangeError("Out-of-bounds TimeZone gap"), gapNano))(timeZone.C(zonedEpochNano + bigNanoInUtcDay) - startOffsetNano);
+	})(timeZone, zonedEpochNano);
+	const shiftedIsoDateTime = epochNanoToIsoDateTime(zonedEpochNano + BigInt(gapNano * (2 === disambig ? -1 : 1)));
+	return (possibleEpochNanos = timeZone.R(shiftedIsoDateTime))[2 === disambig ? 0 : possibleEpochNanos.length - 1];
+}
+function getStartOfDayInstantFor(timeZone, isoDateTime) {
+	const possibleEpochNanos = timeZone.R(isoDateTime);
+	if (possibleEpochNanos.length) return possibleEpochNanos[0];
+	const zonedEpochNanoDayBefore = isoDateTimeToEpochNano(isoDateTime) - bigNanoInUtcDay;
+	return timeZone.U(zonedEpochNanoDayBefore, 1);
+}
+function moveYearMonth(doSubtract, calendar, isoDateFields, durationSlots, options) {
+	const overflow = refineOverflowOptions(options);
+	durationSlots.sign && getMaxDurationUnit(durationSlots) < 8 && throwRangeError("Cannot use small units");
+	return moveToStartOfMonth(calendar, dateAddWithOverflow(calendar, checkIsoDateInBounds(moveToStartOfMonth(calendar, isoDateFields)), doSubtract ? negateDurationFields(durationSlots) : durationSlots, overflow));
+}
+function moveEpochNano(epochNano, durationFields) {
+	return checkEpochNanoInBounds(epochNano + (durationHasDateParts(fields = durationFields) && throwRangeError("Cannot use large units"), durationTimeToBigNano(fields)));
+	var fields;
+}
+function moveZonedEpochSlots(slots, durationFields, options) {
+	const { calendar, epochNanoseconds: epochNano, timeZone } = slots;
+	const timeOnlyNano = durationTimeToBigNano(durationFields);
+	let movedEpochNano = epochNano;
+	if (durationHasDateParts(durationFields)) {
+		const isoDateTime = zonedEpochSlotsToIso(slots);
+		movedEpochNano = getSingleInstantFor(timeZone, combineDateAndTime(moveDate(calendar, isoDateTime, {
+			...durationFields,
+			...durationTimeFieldDefaults
+		}, options), isoDateTime)) + timeOnlyNano;
+	} else movedEpochNano += timeOnlyNano, refineOverflowOptions(options);
+	return {
+		...slots,
+		epochNanoseconds: checkEpochNanoInBounds(movedEpochNano)
+	};
+}
+function moveDateTime(calendar, isoDateTimeFields, durationFields, options) {
+	const [movedTimeFields, dayDelta] = moveTime(isoDateTimeFields, durationFields);
+	const movedIsoDateTimeFields = combineDateAndTime(moveDate(calendar, isoDateTimeFields, {
+		...durationFields,
+		...durationTimeFieldDefaults,
+		days: durationFields.days + dayDelta
+	}, options), movedTimeFields);
+	return checkIsoDateTimeInBounds(movedIsoDateTimeFields), movedIsoDateTimeFields;
+}
+function moveDate(calendar, isoDateFields, durationFields, options) {
+	if (durationFields.years || durationFields.months || durationFields.weeks) return dateAddWithOverflow(calendar, isoDateFields, durationFields, refineOverflowOptions(options));
+	refineOverflowOptions(options);
+	const days = durationFields.days + Number(durationTimeToBigNano(durationFields) / bigNanoInUtcDay);
+	return days ? checkIsoDateInBounds(moveByDays(isoDateFields, days)) : isoDateFields;
+}
+function moveToStartOfMonth(calendar, isoDateFields) {
+	return moveByDays(isoDateFields, 1 - computeCalendarDateFields(calendar, isoDateFields).day);
+}
+function moveTime(timeFields, durationFields) {
+	const durationBigNano = durationTimeToBigNano(durationFields);
+	const durDays = Number(durationBigNano / bigNanoInUtcDay);
+	const durTimeNano = Number(durationBigNano % bigNanoInUtcDay);
+	const [newTimeFields, overflowDays] = nanoToTimeAndDay(timeFieldsToNano(timeFields) + durTimeNano);
+	return [newTimeFields, durDays + overflowDays];
+}
+function moveByDays(isoDate, days) {
+	return days ? epochDaysToIsoDate(isoDateToEpochDays(isoDate) + days) : isoDate;
+}
+function dateAddWithOverflow(calendar, isoDateFields, durationFields, overflow) {
+	let { years, months, weeks, days } = durationFields;
+	let isoDate;
+	if (days += Number(durationTimeToBigNano(durationFields) / bigNanoInUtcDay), years || months) isoDate = addDateMonths(calendar, isoDateFields, years, months, overflow);
+	else {
+		if (!weeks && !days) return isoDateFields;
+		isoDate = isoDateFields;
+	}
+	return (weeks || days) && (isoDate = moveByDays(isoDate, 7 * weeks + days)), checkIsoDateInBounds(isoDate);
+}
+function addDateMonths(calendar, isoDateFields, years, months, overflow) {
+	let { year, month, day } = computeCalendarDateFields(calendar, isoDateFields);
+	if (years) {
+		const [monthCodeNumber, isLeapMonth] = computeCalendarMonthCodeParts(calendar, year, month);
+		year += years, month = computeYearMovedMonth(calendar, monthCodeNumber, isLeapMonth, calendar ? calendar.q(year) : void 0, overflow), month = clampEntity("month", month, 1, computeCalendarMonthsInYearForYear(calendar, year), overflow);
+	}
+	if (months) {
+		const yearMonthParts = calendar ? calendar.N(year, month, months) : addIsoMonths(year, month, months);
+		({year: year, month: month} = yearMonthParts);
+	}
+	return day = clampEntity("day", day, 1, computeCalendarDaysInMonthForYearMonth(calendar, year, month), overflow), computeCalendarIsoFieldsFromParts(calendar, year, month, day);
+}
+function computeYearMovedMonth(calendar, monthCodeNumber, isLeapMonth, targetLeapMonth, overflow) {
+	if (isLeapMonth) {
+		const leapMonthMeta = calendar ? calendar.m : void 0;
+		return void 0 !== targetLeapMonth && (leapMonthMeta < 0 || targetLeapMonth === monthCodeNumber + 1) ? targetLeapMonth : (1 === overflow && throwRangeError(invalidLeapMonth), leapMonthMeta < 0 ? -leapMonthMeta : monthCodeNumber);
+	}
+	return monthCodeNumberToMonth(monthCodeNumber, 0, targetLeapMonth);
+}
+function getCommonCalendar(a, b) {
+	return getCalendarSlotId(a) !== getCalendarSlotId(b) && throwRangeError("Mismatching Calendars"), a;
+}
+function getCommonTimeZone(a, b) {
+	return a.o !== b.o && throwRangeError("Mismatching TimeZones"), a;
+}
+function getZonedTimeZoneId(slots) {
+	return slots.timeZone.id;
+}
+function diffInstants(invert, instantSlots0, instantSlots1, options) {
+	const [largestUnit, smallestUnit, roundingInc, roundingMode] = refineDiffOptions(invert, options, 3, 5);
+	const durationFields = diffEpochNanos(instantSlots0.epochNanoseconds, instantSlots1.epochNanoseconds, largestUnit, smallestUnit, roundingInc, roundingMode);
+	return createDurationSlots(invert ? negateDurationFields(durationFields) : durationFields);
+}
+function diffZonedDateTimes(invert, calendar, slots0, slots1, options) {
+	const [largestUnit, smallestUnit, roundingInc, roundingMode] = refineDiffOptions(invert, options, 5);
+	const epochNano0 = slots0.epochNanoseconds;
+	const epochNano1 = slots1.epochNanoseconds;
+	let durationFields;
+	return compareBigInts(epochNano1, epochNano0) ? largestUnit < 6 ? durationFields = diffEpochNanos(epochNano0, epochNano1, largestUnit, smallestUnit, roundingInc, roundingMode) : (durationFields = diffZonedEpochsExact(getCommonTimeZone(slots0.timeZone, slots1.timeZone), calendar, slots0, slots1, largestUnit), durationFields = roundRelativeDuration(durationFields, epochNano1, largestUnit, smallestUnit, roundingInc, roundingMode, createMarkerMoveOps(slots0, getEpochNano, moveZonedEpochSlots))) : durationFields = durationFieldDefaults, createDurationSlots(invert ? negateDurationFields(durationFields) : durationFields);
+}
+function diffPlainDateTimes(invert, calendar, plainDateTimeSlots0, plainDateTimeSlots1, options) {
+	const [largestUnit, smallestUnit, roundingInc, roundingMode] = refineDiffOptions(invert, options, 6);
+	const startEpochNano = isoDateTimeToEpochNano(plainDateTimeSlots0);
+	const endEpochNano = isoDateTimeToEpochNano(plainDateTimeSlots1);
+	const sign = compareBigInts(endEpochNano, startEpochNano);
+	let durationFields;
+	return sign ? largestUnit <= 6 ? durationFields = diffEpochNanos(startEpochNano, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode) : (durationFields = diffDateTimesBig(calendar, plainDateTimeSlots0, plainDateTimeSlots1, sign, largestUnit), durationFields = roundRelativeDuration(durationFields, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode, createMarkerMoveOps(plainDateTimeSlots0, isoDateTimeToEpochNano, bindArgs(moveDateTime, calendar)))) : durationFields = durationFieldDefaults, createDurationSlots(invert ? negateDurationFields(durationFields) : durationFields);
+}
+function diffPlainDates(invert, calendar, plainDateSlots0, plainDateSlots1, options) {
+	const [largestUnit, smallestUnit, roundingInc, roundingMode] = refineDiffOptions(invert, options, 6, 9, 6);
+	return diffDateLike(invert, calendar, plainDateSlots0, plainDateSlots1, largestUnit, smallestUnit, roundingInc, roundingMode);
+}
+function diffPlainYearMonth(invert, calendar, plainYearMonthSlots0, plainYearMonthSlots1, options) {
+	const [largestUnit, smallestUnit, roundingInc, roundingMode] = refineDiffOptions(invert, options, 9, 9, 8);
+	const firstOfMonth0 = moveToStartOfMonth(calendar, plainYearMonthSlots0);
+	const firstOfMonth1 = moveToStartOfMonth(calendar, plainYearMonthSlots1);
+	return compareIsoDate(firstOfMonth0, firstOfMonth1) ? diffDateLike(invert, calendar, checkIsoDateInBounds(firstOfMonth0), checkIsoDateInBounds(firstOfMonth1), largestUnit, smallestUnit, roundingInc, roundingMode, 8) : createDurationSlots(durationFieldDefaults);
+}
+function diffDateLike(invert, calendar, startIsoDate, endIsoDate, largestUnit, smallestUnit, roundingInc, roundingMode, smallestPrecision = 6) {
+	const startEpochNano = isoDateToEpochNano(startIsoDate);
+	const endEpochNano = isoDateToEpochNano(endIsoDate);
+	let durationFields;
+	return compareBigInts(endEpochNano, startEpochNano) ? 6 === largestUnit ? durationFields = diffEpochNanos(startEpochNano, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode) : (durationFields = diffCalendarDates(calendar, startIsoDate, endIsoDate, largestUnit), smallestUnit === smallestPrecision && 1 === roundingInc || (durationFields = roundRelativeDuration(durationFields, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode, createMarkerMoveOps(startIsoDate, isoDateToEpochNano, bindArgs(moveDate, calendar))))) : durationFields = durationFieldDefaults, createDurationSlots(invert ? negateDurationFields(durationFields) : durationFields);
+}
+function diffPlainTimes(invert, plainTimeSlots0, plainTimeSlots1, options) {
+	const [largestUnit, smallestUnit, roundingInc, roundingMode] = refineDiffOptions(invert, options, 5, 5);
+	const timeDiffNano = roundNumberToInc(timeFieldsToNano(plainTimeSlots1) - timeFieldsToNano(plainTimeSlots0), computeNanoInc(smallestUnit, roundingInc), roundingMode);
+	const durationFields = {
+		...durationFieldDefaults,
+		...nanoToDurationTimeFields(timeDiffNano, largestUnit)
+	};
+	return createDurationSlots(invert ? negateDurationFields(durationFields) : durationFields);
+}
+function diffZonedEpochsExact(timeZone, calendar, slots0, slots1, largestUnit) {
+	const sign = compareBigInts(slots1.epochNanoseconds, slots0.epochNanoseconds);
+	if (!sign) return durationFieldDefaults;
+	if (largestUnit < 6) return {
+		...durationFieldDefaults,
+		...nanoToDurationDayTimeFields(slots1.epochNanoseconds - slots0.epochNanoseconds, largestUnit)
+	};
+	if (!compareIsoDate(zonedEpochSlotsToIso(slots0), zonedEpochSlotsToIso(slots1))) return {
+		...durationFieldDefaults,
+		...nanoToDurationDayTimeFields(slots1.epochNanoseconds - slots0.epochNanoseconds, 5)
+	};
+	const [isoFields0, isoFields1, remainderNano] = prepareZonedEpochDiff(timeZone, slots0, slots1, sign);
+	return {
+		...6 === largestUnit ? {
+			...durationFieldDefaults,
+			days: diffDays(isoFields0, isoFields1)
+		} : diffCalendarDates(calendar, isoFields0, isoFields1, largestUnit),
+		...nanoToDurationTimeFields(remainderNano)
+	};
+}
+function diffDateTimesExact(calendar, startIsoDateTime, endIsoDateTime, largestUnit) {
+	const startEpochNano = isoDateTimeToEpochNano(startIsoDateTime);
+	const endEpochNano = isoDateTimeToEpochNano(endIsoDateTime);
+	const sign = compareBigInts(endEpochNano, startEpochNano);
+	return sign ? largestUnit <= 6 ? {
+		...durationFieldDefaults,
+		...nanoToDurationDayTimeFields(endEpochNano - startEpochNano, largestUnit)
+	} : diffDateTimesBig(calendar, startIsoDateTime, endIsoDateTime, sign, largestUnit) : durationFieldDefaults;
+}
+function diffDateTimesBig(calendar, startIsoDateTime, endIsoDateTime, sign, largestUnit) {
+	let diffEndDate = endIsoDateTime;
+	let timeNano = timeFieldsToNano(endIsoDateTime) - timeFieldsToNano(startIsoDateTime);
+	return Math.sign(timeNano) === -sign && (diffEndDate = moveByDays(endIsoDateTime, -sign), timeNano += 864e11 * sign), {
+		...diffCalendarDates(calendar, startIsoDateTime, diffEndDate, largestUnit),
+		...nanoToDurationTimeFields(timeNano)
+	};
+}
+function diffCalendarDates(calendar, startIsoDate, endIsoDate, largestUnit) {
+	if (largestUnit <= 7) {
+		const days = diffDays(startIsoDate, endIsoDate);
+		return 7 === largestUnit ? {
+			...durationFieldDefaults,
+			weeks: divTrunc(days, 7),
+			days: modTrunc(days, 7)
+		} : {
+			...durationFieldDefaults,
+			days
+		};
+	}
+	const yearMonthDayStart = computeCalendarDateFields(calendar, startIsoDate);
+	const yearMonthDayEnd = computeCalendarDateFields(calendar, endIsoDate);
+	if (8 === largestUnit) {
+		const { year: year0, month: month0, day: day0 } = yearMonthDayStart;
+		const { year: year1, month: month1, day: day1 } = yearMonthDayEnd;
+		const sign = Math.sign(compareNumbers(year1, year0) || compareNumbers(month1, month0) || diffDays(startIsoDate, endIsoDate));
+		let months = 0;
+		let days = 0;
+		if (sign) {
+			months = calendar ? calendar.ne(year0, month0, year1, month1) : diffIsoMonthSlots(year0, month0, year1, month1);
+			let anchorIsoDate = addDateMonths(calendar, startIsoDate, 0, months, 0);
+			sign * compareNumbers(day0, day1) > 0 && (months -= sign, anchorIsoDate = addDateMonths(calendar, startIsoDate, 0, months, 0)), days = diffDays(anchorIsoDate, endIsoDate);
+		}
+		return {
+			...durationFieldDefaults,
+			months,
+			days
+		};
+	}
+	const { year: year0, month: month0, day: day0 } = yearMonthDayStart;
+	let { year: year1, month: month1, day: day1 } = yearMonthDayEnd;
+	let yearDiff = year1 - year0;
+	let monthDiff = month1 - month0;
+	let dayDiff = day1 - day0;
+	if (yearDiff || monthDiff) {
+		const sign = Math.sign(yearDiff || monthDiff);
+		let daysInMonth1 = computeCalendarDaysInMonthForYearMonth(calendar, year1, month1);
+		let dayCorrect = 0;
+		if (Math.sign(day1 - day0) === -sign) {
+			const origDaysInMonth1 = daysInMonth1;
+			const yearMonthParts = calendar ? calendar.N(year1, month1, -sign) : addIsoMonths(year1, month1, -sign);
+			({year: year1, month: month1} = yearMonthParts), yearDiff = year1 - year0, monthDiff = month1 - month0, daysInMonth1 = computeCalendarDaysInMonthForYearMonth(calendar, year1, month1), dayCorrect = sign < 0 ? -origDaysInMonth1 : daysInMonth1;
+		}
+		if (dayDiff = day1 - Math.min(day0, daysInMonth1) + dayCorrect, yearDiff) {
+			const [monthCodeNumber0, isLeapMonth0] = computeCalendarMonthCodeParts(calendar, year0, month0);
+			const [monthCodeNumber1, isLeapMonth1] = computeCalendarMonthCodeParts(calendar, year1, month1);
+			const leapMonthMeta = calendar ? calendar.m : void 0;
+			if (monthDiff = void 0 !== leapMonthMeta && isLeapMonth0 && !isLeapMonth1 && (leapMonthMeta < 0 ? sign > 0 && monthCodeNumber1 === -leapMonthMeta : sign < 0 && monthCodeNumber1 === monthCodeNumber0) ? 0 : monthCodeNumber1 - monthCodeNumber0 || Number(isLeapMonth1) - Number(isLeapMonth0), Math.sign(monthDiff) === -sign) {
+				const monthCorrect = sign < 0 && -computeCalendarMonthsInYearForYear(calendar, year1);
+				year1 -= sign, yearDiff = year1 - year0, monthDiff = month1 - computeYearMovedMonth(calendar, monthCodeNumber0, isLeapMonth0, calendar ? calendar.q(year1) : void 0, 0) + (monthCorrect || computeCalendarMonthsInYearForYear(calendar, year1));
+			} else if (calendar) {
+				const month0Projected = computeYearMovedMonth(calendar, monthCodeNumber0, isLeapMonth0, calendar.q(year1), 0);
+				monthDiff = calendar.ne(year1, month0Projected, year1, month1);
+			}
+		}
+	}
+	return {
+		...durationFieldDefaults,
+		years: yearDiff,
+		months: monthDiff,
+		days: dayDiff
+	};
+}
+function compareIsoDate(isoDate0, isoDate1) {
+	return compareNumbers(isoDate0.year, isoDate1.year) || compareNumbers(isoDate0.month, isoDate1.month) || compareNumbers(isoDate0.day, isoDate1.day);
+}
+function prepareZonedEpochDiff(timeZone, slots0, slots1, sign) {
+	const startIsoDate = zonedEpochSlotsToIso(slots0);
+	const endIsoDate = zonedEpochSlotsToIso(slots1);
+	const endEpochNano = slots1.epochNanoseconds;
+	let dayCorrection = 0;
+	const timeDiffNano = timeFieldsToNano(endIsoDate) - timeFieldsToNano(startIsoDate);
+	Math.sign(timeDiffNano) === -sign && dayCorrection++;
+	const maxDayCorrection = dayCorrection + (sign > 0 ? 1 : 0);
+	for (; dayCorrection <= maxDayCorrection; dayCorrection++) {
+		const midIsoDate = moveByDays(endIsoDate, dayCorrection * -sign);
+		const midEpochNano = getSingleInstantFor(timeZone, combineDateAndTime(midIsoDate, startIsoDate));
+		if (compareBigInts(endEpochNano, midEpochNano) !== -sign) return [
+			startIsoDate,
+			midIsoDate,
+			Number(endEpochNano - midEpochNano)
+		];
+	}
+}
+function diffEpochNanos(startEpochNano, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode) {
+	return {
+		...durationFieldDefaults,
+		...nanoToDurationDayTimeFields(roundBigNanoToInc(endEpochNano - startEpochNano, computeBigNanoInc(smallestUnit, roundingInc), roundingMode), largestUnit)
+	};
+}
+function diffDays(startIsoDate, endIsoDate) {
+	return isoDateToEpochDays(endIsoDate) - isoDateToEpochDays(startIsoDate);
+}
+function createMarkerMoveOps(marker, markerToEpochNano, moveMarker) {
+	return {
+		i: marker,
+		V: markerToEpochNano,
+		G: moveMarker
+	};
+}
+function createMarkerSpanOps(relativeToSlots) {
+	const { calendar } = relativeToSlots;
+	if (isZonedEpochSlots(relativeToSlots)) {
+		const { timeZone } = relativeToSlots;
+		return {
+			i: relativeToSlots,
+			V: getEpochNano,
+			G: moveZonedEpochSlots,
+			re: bindArgs(diffZonedEpochsExact, timeZone, calendar)
+		};
+	}
+	return {
+		i: normalizeDateTimeMarker(relativeToSlots),
+		V: isoDateTimeToEpochNano,
+		G: bindArgs(moveDateTime, calendar),
+		re: bindArgs(diffDateTimesExact, calendar)
+	};
+}
+function moveMarkerToEpochNano(markerMoveOps, durationFields) {
+	return markerMoveOps.V(markerMoveOps.G(markerMoveOps.i, durationFields));
+}
+function isZonedEpochSlots(marker) {
+	return "timeZone" in marker;
+}
+function checkMarkerSpanInBounds(markerSpanOps, endMarker) {
+	isZonedEpochSlots(markerSpanOps.i) || (checkMarkerInBounds(markerSpanOps.i), checkMarkerInBounds(endMarker));
+}
+function normalizeDateTimeMarker(marker) {
+	return combineDateAndTime(marker, "hour" in marker ? marker : timeFieldDefaults);
+}
+function checkMarkerInBounds(marker) {
+	checkIsoDateTimeInBounds(normalizeDateTimeMarker(marker));
+}
+function isUniformUnit(unit, marker) {
+	return unit <= 6 - (marker && isZonedEpochSlots(marker) ? 1 : 0);
+}
+function nanoToGivenFields(nano, largestUnit, fieldNames) {
+	const fields = {};
+	for (let unit = largestUnit; unit >= 0; unit--) {
+		const divisor = unitNanoMap[unit];
+		fields[fieldNames[unit]] = divTrunc(nano, divisor), nano = modTrunc(nano, divisor);
+	}
+	return fields;
+}
+const maxDurationSeconds = 2 ** 53;
+function addDurations(refineRelativeTo, doSubtract, slots, otherSlots, options) {
+	const relativeToSlots = refineRelativeTo(require_utils.normalizeOptions(options).relativeTo);
+	const maxUnit = Math.max(getMaxDurationUnit(slots), getMaxDurationUnit(otherSlots));
+	if (isUniformUnit(maxUnit, relativeToSlots)) return addDayTimeDurationsChecked(doSubtract, slots, otherSlots, maxUnit);
+	relativeToSlots || throwRangeError("Missing relativeTo"), doSubtract && (otherSlots = negateDurationFields(otherSlots));
+	const markerSpanOps = createMarkerSpanOps(relativeToSlots);
+	const midMarker = markerSpanOps.G(markerSpanOps.i, slots);
+	const endMarker = markerSpanOps.G(midMarker, otherSlots);
+	return createDurationSlots(markerSpanOps.re(markerSpanOps.i, endMarker, maxUnit));
+}
+function addDayTimeDurationsChecked(doSubtract, slots, otherSlots, maxUnit) {
+	return createDurationSlots(validateDurationFields(((a, b, largestUnit, doSubtract) => {
+		const combined = durationDayTimeToBigNano(a) + durationDayTimeToBigNano(b) * BigInt(doSubtract ? -1 : 1);
+		return Number.isFinite(Number(combined / bigNanoInUtcDay)) || throwRangeError("Out-of-bounds date"), {
+			...durationFieldDefaults,
+			...nanoToDurationDayTimeFields(combined, largestUnit)
+		};
+	})(slots, otherSlots, maxUnit, doSubtract)));
+}
+function roundDuration(refineRelativeTo, slots, options) {
+	const durationLargestUnit = getMaxDurationUnit(slots);
+	const [largestUnit, smallestUnit, roundingInc, roundingMode, relativeToSlots] = ((options, defaultLargestUnit, refineRelativeTo) => {
+		options = normalizeOptionsOrString(options, smallestUnitStr);
+		let largestUnit = coerceLargestUnit(options);
+		const relativeToInternals = refineRelativeTo(options.relativeTo);
+		let roundingInc = coerceRoundingIncInteger(options);
+		const roundingMode = coerceRoundingMode(options, 7);
+		let smallestUnit = coerceSmallestUnit(options);
+		return void 0 === largestUnit && void 0 === smallestUnit && throwRangeError("Required smallestUnit or largestUnit"), smallestUnit ??= 0, largestUnit ??= Math.max(smallestUnit, defaultLargestUnit), checkLargestSmallestUnit(largestUnit, smallestUnit), roundingInc = validateRoundingInc(roundingInc, smallestUnit, 1), roundingInc > 1 && smallestUnit > 5 && largestUnit !== smallestUnit && throwRangeError("For calendar units with roundingIncrement > 1, use largestUnit = smallestUnit"), [
+			largestUnit,
+			smallestUnit,
+			roundingInc,
+			roundingMode,
+			relativeToInternals
+		];
+	})(options, durationLargestUnit, refineRelativeTo);
+	if (!relativeToSlots && Math.max(durationLargestUnit, largestUnit) <= 6) return createDurationSlots(validateDurationFields(((durationFields, largestUnit, smallestUnit, roundingInc, roundingMode) => {
+		const roundedBigNano = roundBigNanoToInc(durationDayTimeToBigNano(durationFields), computeBigNanoInc(smallestUnit, roundingInc), roundingMode);
+		return {
+			...durationFieldDefaults,
+			...nanoToDurationDayTimeFields(roundedBigNano, largestUnit)
+		};
+	})(slots, largestUnit, smallestUnit, roundingInc, roundingMode)));
+	const needsZonedDayLength = relativeToSlots && isZonedEpochSlots(relativeToSlots) && largestUnit >= 6 && smallestUnit < 6;
+	if (!slots.sign && !needsZonedDayLength) return slots;
+	relativeToSlots || throwRangeError("Missing relativeTo");
+	const markerSpanOps = createMarkerSpanOps(relativeToSlots);
+	const endMarker = markerSpanOps.G(markerSpanOps.i, slots);
+	checkMarkerSpanInBounds(markerSpanOps, endMarker);
+	let balancedDuration = markerSpanOps.re(markerSpanOps.i, endMarker, largestUnit);
+	return balancedDuration = roundRelativeDuration(balancedDuration, markerSpanOps.V(endMarker), largestUnit, smallestUnit, roundingInc, roundingMode, markerSpanOps), createDurationSlots(balancedDuration);
+}
+function absDuration(slots) {
+	return -1 === slots.sign ? negateDuration(slots) : slots;
+}
+function negateDuration(slots) {
+	return createDurationSlots(negateDurationFields(slots));
+}
+function negateDurationFields(fields) {
+	const res = {};
+	for (const fieldName of durationFieldNamesAsc) res[fieldName] = -1 * fields[fieldName] || 0;
+	return res;
+}
+function computeDurationSign(fields, fieldNames = durationFieldNamesAsc) {
+	let sign = 0;
+	for (const fieldName of fieldNames) {
+		const fieldSign = Math.sign(fields[fieldName]);
+		fieldSign && (sign && sign !== fieldSign && throwRangeError("Cannot mix duration signs"), sign = fieldSign);
+	}
+	return sign;
+}
+function validateDurationFields(fields) {
+	for (const calendarUnit of durationCalendarFieldNamesAsc) clampEntity(calendarUnit, fields[calendarUnit], -4294967295, 4294967295, 1);
+	const bigNano = durationDayTimeToBigNano(fields);
+	return validateDurationTimeUnit(Number(bigNano / bigNanoInSec)), fields;
+}
+function validateDurationTimeUnit(n) {
+	Number.isSafeInteger(n) || throwRangeError("Out-of-bounds duration");
+}
+function durationDayTimeToBigNano(fields) {
+	return BigInt(fields.days) * bigNanoInUtcDay + durationTimeToBigNano(fields);
+}
+function durationTimeToBigNano(fields) {
+	return BigInt(fields.hours) * bigNanoInHour + BigInt(fields.minutes) * bigNanoInMinute + durationSubMinuteToBigNano(fields);
+}
+function durationSubMinuteToBigNano(fields) {
+	return BigInt(fields.seconds) * bigNanoInSec + BigInt(fields.milliseconds) * bigNanoInMilli + BigInt(fields.microseconds) * bigNanoInMicro + BigInt(fields.nanoseconds);
+}
+function nanoToDurationDayTimeFields(bigNano, largestUnit = 6) {
+	const days = Number(bigNano / bigNanoInUtcDay);
+	const timeNano = Number(bigNano % bigNanoInUtcDay);
+	const unitNano = unitNanoMap[largestUnit];
+	const largestUnitVal = largestUnit <= 3 ? Number(bigNano / BigInt(unitNano)) : days * (nanoInUtcDay / unitNano) + divTrunc(timeNano, unitNano);
+	Number.isFinite(largestUnitVal) || throwRangeError("Out-of-bounds date"), largestUnit <= 3 && Math.abs(largestUnitVal) / (nanoInSec / unitNanoMap[largestUnit]) >= maxDurationSeconds && throwRangeError("Out-of-bounds date");
+	const dayTimeFields = nanoToGivenFields(timeNano, largestUnit, durationFieldNamesAsc);
+	return dayTimeFields[durationFieldNamesAsc[largestUnit]] = largestUnitVal, dayTimeFields;
+}
+function nanoToDurationTimeFields(nano, largestUnit = 5) {
+	return nanoToGivenFields(nano, largestUnit, durationFieldNamesAsc);
+}
+function durationHasDateParts(fields) {
+	return Boolean(computeDurationSign(fields, durationDateFieldNamesAsc));
+}
+function getMaxDurationUnit(fields) {
+	let unit = 9;
+	for (; unit > 0 && !fields[durationFieldNamesAsc[unit]]; unit--);
+	return unit;
+}
+function compareInstants(instantSlots0, instantSlots1) {
+	return compareBigInts(instantSlots0.epochNanoseconds, instantSlots1.epochNanoseconds);
+}
+function compareZonedDateTimes(zonedDateTimeSlots0, zonedDateTimeSlots1) {
+	return compareBigInts(zonedDateTimeSlots0.epochNanoseconds, zonedDateTimeSlots1.epochNanoseconds);
+}
+function compareDurations(refineRelativeTo, durationSlots0, durationSlots1, options) {
+	const relativeToSlots = refineRelativeTo(require_utils.normalizeOptions(options).relativeTo);
+	const maxUnit = Math.max(getMaxDurationUnit(durationSlots0), getMaxDurationUnit(durationSlots1));
+	if (allPropsEqual(durationFieldNamesAsc, durationSlots0, durationSlots1)) return 0;
+	if (isUniformUnit(maxUnit, relativeToSlots)) return compareBigInts(durationDayTimeToBigNano(durationSlots0), durationDayTimeToBigNano(durationSlots1));
+	relativeToSlots || throwRangeError("Missing relativeTo");
+	const markerSpanOps = createMarkerSpanOps(relativeToSlots);
+	return compareBigInts(moveMarkerToEpochNano(markerSpanOps, durationSlots0), moveMarkerToEpochNano(markerSpanOps, durationSlots1));
+}
+function compareIsoDateTimeFields(isoDateTime0, isoDateTime1) {
+	return compareIsoDateFields(isoDateTime0, isoDateTime1) || compareTimeFields(isoDateTime0, isoDateTime1);
+}
+function compareIsoDateFields(isoFields0, isoFields1) {
+	return compareNumbers(isoDateToEpochDays(isoFields0), isoDateToEpochDays(isoFields1));
+}
+function compareTimeFields(isoFields0, isoFields1) {
+	return compareNumbers(timeFieldsToNano(isoFields0), timeFieldsToNano(isoFields1));
+}
+function instantsEqual(instantSlots0, instantSlots1) {
+	return !compareInstants(instantSlots0, instantSlots1);
+}
+function zonedDateTimesEqual(zonedDateTimeSlots0, zonedDateTimeSlots1) {
+	return !compareZonedDateTimes(zonedDateTimeSlots0, zonedDateTimeSlots1) && zonedDateTimeSlots0.timeZone.o === zonedDateTimeSlots1.timeZone.o && zonedDateTimeSlots0.calendar === zonedDateTimeSlots1.calendar;
+}
+function plainDateTimesEqual(plainDateTimeSlots0, plainDateTimeSlots1) {
+	return !compareIsoDateTimeFields(plainDateTimeSlots0, plainDateTimeSlots1) && plainDateTimeSlots0.calendar === plainDateTimeSlots1.calendar;
+}
+function plainDatesEqual(plainDateSlots0, plainDateSlots1) {
+	return !compareIsoDateFields(plainDateSlots0, plainDateSlots1) && plainDateSlots0.calendar === plainDateSlots1.calendar;
+}
+function plainYearMonthsEqual(plainYearMonthSlots0, plainYearMonthSlots1) {
+	return !compareIsoDateFields(plainYearMonthSlots0, plainYearMonthSlots1) && plainYearMonthSlots0.calendar === plainYearMonthSlots1.calendar;
+}
+function plainMonthDaysEqual(plainMonthDaySlots0, plainMonthDaySlots1) {
+	return !compareIsoDateFields(plainMonthDaySlots0, plainMonthDaySlots1) && plainMonthDaySlots0.calendar === plainMonthDaySlots1.calendar;
+}
+function plainTimesEqual(plainTimeSlots0, plainTimeSlots1) {
+	return !compareTimeFields(plainTimeSlots0, plainTimeSlots1);
+}
+function getCalendarEraOrigins(calendar) {
+	return 0 === calendar ? gregoryEraOrigins : calendar ? calendar.l : void 0;
+}
+function getCalendarFieldNames(calendar, fieldNames, fieldNamesWithEra = fieldNames) {
+	return getCalendarEraOrigins(calendar) ? fieldNamesWithEra : fieldNames;
+}
+function resolveCalendarYear(calendar, fields) {
+	const exoticCalendar = calendar || void 0;
+	const eraOrigins = getCalendarEraOrigins(calendar);
+	let { era, eraYear, year } = fields;
+	if (void 0 !== year && (year = require_utils.toIntegerWithTrunc(year, "year")), void 0 !== eraYear && (eraYear = require_utils.toIntegerWithTrunc(eraYear, "eraYear")), void 0 !== era || void 0 !== eraYear) {
+		void 0 !== era && void 0 !== eraYear || throwTypeError("Mismatching era/eraYear"), eraOrigins || throwRangeError("Forbidden era/eraYear");
+		const normalizedEra = normalizeEraName(era);
+		const eraOrigin = eraOrigins[normalizedEra];
+		void 0 === eraOrigin && throwRangeError(((era) => `Invalid era: ${era}`)(era));
+		const yearByEra = exoticCalendar?.te ? exoticCalendar.te(eraYear, normalizedEra, eraOrigin) : eraYearToYear(eraYear, eraOrigin);
+		void 0 !== year && year !== yearByEra && throwRangeError("Mismatching year/eraYear"), year = yearByEra;
+	} else void 0 === year && throwTypeError(missingYear(eraOrigins));
+	return year;
+}
+function resolveCalendarMonth(calendar, fields, year, overflow, monthCodeParts) {
+	let { month, monthCode } = fields;
+	if (void 0 !== monthCode) {
+		const monthByCode = ((calendar, monthCode, year, overflow, monthCodeParts = parseMonthCode(monthCode)) => {
+			const leapMonth = calendar ? calendar.q(year) : void 0;
+			const [monthCodeNumber, wantsLeapMonth] = monthCodeParts;
+			let month = monthCodeNumberToMonth(monthCodeNumber, wantsLeapMonth, leapMonth);
+			if (wantsLeapMonth) {
+				const leapMonthMeta = calendar ? calendar.m : void 0;
+				void 0 === leapMonthMeta && throwRangeError(invalidLeapMonth), leapMonthMeta > 0 ? (month > leapMonthMeta && throwRangeError(invalidLeapMonth), leapMonth !== month && (1 === overflow && throwRangeError(invalidLeapMonth), month = monthCodeNumberToMonth(monthCodeNumber, 0, leapMonth))) : (month !== -leapMonthMeta && throwRangeError(invalidLeapMonth), void 0 === leapMonth && 1 === overflow && throwRangeError(invalidLeapMonth));
+			}
+			return month;
+		})(calendar, monthCode, year, overflow, monthCodeParts);
+		void 0 !== month && month !== monthByCode && throwRangeError("Mismatching month/monthCode"), month = monthByCode, overflow = 1;
+	} else void 0 === month && throwTypeError("Missing month/monthCode");
+	return clampEntity("month", month, 1, computeCalendarMonthsInYearForYear(calendar, year), overflow);
+}
+function resolveCalendarDay(calendar, fields, month, year, overflow) {
+	return clampProp(fields, "day", 1, computeCalendarDaysInMonthForYearMonth(calendar, year, month), overflow);
+}
+function eraYearToYear(eraYear, eraOrigin) {
+	return (eraOrigin + eraYear) * (Math.sign(eraOrigin) || 1) || 0;
+}
+function resolveTimeFields(fields, overflow) {
+	return constrainTimeFields(pluckProps(timeFieldNamesAsc, {
+		...timeFieldDefaults,
+		...fields
+	}), overflow);
+}
+const offsetRegExp = /* @__PURE__ */ createRegExp("([+-])(\\d{2})(?::?(\\d{2})(?::?(\\d{2})(?:[.,](\\d{1,9}))?)?)?");
+function parseOffsetNano(s) {
+	const offsetNano = parseOffsetNanoMaybe(s);
+	return void 0 === offsetNano && throwRangeError(failedParse(s)), offsetNano;
+}
+function parseOffsetNanoMaybe(s, onlyHourMinute) {
+	const parts = offsetRegExp.exec(s);
+	if (parts && ((s) => ((s) => {
+		"T" !== s[0] && "t" !== s[0] || (s = s.slice(1));
+		const fractionIndex = s.search(/[.,]/);
+		const main = fractionIndex < 0 ? s : s.slice(0, fractionIndex);
+		const parts = main.split(":");
+		return 1 === parts.length ? /^(?:\d{2}|\d{4}|\d{6})$/i.test(main) : (2 === parts.length || 3 === parts.length) && parts.every((part) => 2 === part.length && /^\d{2}$/i.test(part));
+	})(s.slice(1)))(parts[0])) return ((parts, onlyHourMinute) => {
+		const firstSubMinutePart = parts[4] || parts[5];
+		onlyHourMinute && firstSubMinutePart && throwRangeError(invalidSubstring(firstSubMinutePart));
+		return offsetNano = (parseInt0(parts[2]) * nanoInHour + parseInt0(parts[3]) * nanoInMinute + parseInt0(parts[4]) * nanoInSec + parseSubsecNano(parts[5] || "")) * parseSign(parts[1]), Math.abs(offsetNano) >= 864e11 && throwRangeError("Out-of-bounds offset"), offsetNano;
+		var offsetNano;
+	})(parts, onlyHourMinute);
+}
+const dateFieldRefiners = {
+	era: toStringViaPrimitive,
+	month: require_utils.toPositiveIntegerWithTruncation,
+	monthCode(monthCode, entityName = "monthCode") {
+		return ((monthCode, entityName) => {
+			if ("string" == typeof monthCode) return monthCode;
+			if (monthCode && "object" == typeof monthCode) {
+				const monthCodeToString = monthCode.toString;
+				if ("function" == typeof monthCodeToString) return requireString(monthCodeToString.call(monthCode), entityName);
+			}
+			return requireString(monthCode, entityName);
+		})(monthCode, entityName);
+	},
+	day: require_utils.toPositiveIntegerWithTruncation
+};
+const timeFieldRefiners = /* @__PURE__ */ zipPropsConst(timeFieldNamesAsc, require_utils.toIntegerWithTrunc);
+const durationFieldRefiners = /* @__PURE__ */ zipPropsConst(durationFieldNamesAsc, toStrictInteger);
+const offsetFieldRefiners = { offset(offsetString) {
+	return parseOffsetNano(toStringViaPrimitive(offsetString));
+} };
+const dateTimeFieldRefiners = /* @__PURE__ */ Object.assign({}, dateFieldRefiners, timeFieldRefiners);
+const zonedDateTimeFieldRefiners = /* @__PURE__ */ Object.assign({}, dateTimeFieldRefiners, offsetFieldRefiners);
+function readAndRefineBagFields(bag, validFieldNames, fieldRefiners, requiredFieldNames, disallowEmpty = !requiredFieldNames) {
+	const res = {};
+	let anyMatching = 0;
+	for (const fieldName of validFieldNames) {
+		let fieldVal = bag[fieldName];
+		if (void 0 !== fieldVal) {
+			anyMatching = 1;
+			const refiner = fieldRefiners[fieldName];
+			refiner && (fieldVal = refiner(fieldVal, fieldName)), res[fieldName] = fieldVal;
+		} else requiredFieldNames && requiredFieldNames.includes(fieldName) && throwTypeError(missingField(fieldName));
+	}
+	return disallowEmpty && !anyMatching && throwTypeError(noValidFields(validFieldNames)), res;
+}
+function createPlainDateTimeFromRefinedFields(isoDate, time = timeFieldDefaults, calendar) {
+	const isoDateTime = combineDateAndTime(isoDate, time);
+	return checkIsoDateTimeInBounds(isoDateTime), createDateTimeSlots(isoDateTime, calendar);
+}
+function createPlainDateFromFields(calendar, fields, options) {
+	return createPlainDateFromPreparedFields(calendar, fields, prepareDateFields(calendar, fields), refineOverflowOptions(options));
+}
+function createPlainDateFromFieldsWithOptionsRefiner(calendar, fields, refineOptions) {
+	const prepared = prepareDateFields(calendar, fields);
+	const refinedOptions = refineOptions();
+	return [createPlainDateFromPreparedFields(calendar, fields, prepared, refinedOptions[0]), ...refinedOptions];
+}
+function createPlainDateFromPreparedFields(calendar, fields, prepared, overflow) {
+	const year = prepared[1];
+	const month = resolveCalendarMonth(calendar, fields, year, overflow, prepared[0]);
+	return createDateSlots(checkIsoDateInBounds(computeCalendarIsoFieldsFromParts(calendar, year, month, resolveCalendarDay(calendar, fields, month, year, overflow))), calendar);
+}
+function parseMonthCodeField(fields) {
+	if (void 0 !== fields.monthCode) return parseMonthCode(fields.monthCode);
+}
+function prepareDateFields(calendar, fields) {
+	const eraOrigins = getCalendarEraOrigins(calendar);
+	return void 0 !== fields.year || void 0 !== fields.era && void 0 !== fields.eraYear || throwTypeError(missingYear(eraOrigins)), void 0 === fields.monthCode && void 0 === fields.month && throwTypeError("Missing month/monthCode"), void 0 === fields.day && throwTypeError(missingField("day")), [parseMonthCodeField(fields), resolveCalendarYear(calendar, fields)];
+}
+function createPlainYearMonthFromFields(calendar, fields, options) {
+	const eraOrigins = getCalendarEraOrigins(calendar);
+	void 0 !== fields.year || void 0 !== fields.era && void 0 !== fields.eraYear || throwTypeError(missingYear(eraOrigins)), void 0 === fields.monthCode && void 0 === fields.month && throwTypeError("Missing month/monthCode");
+	const monthCodeParts = parseMonthCodeField(fields);
+	const year = resolveCalendarYear(calendar, fields);
+	return createDateSlots(checkIsoYearMonthInBounds(computeCalendarIsoFieldsFromParts(calendar, year, resolveCalendarMonth(calendar, fields, year, refineOverflowOptions(options), monthCodeParts), 1)), calendar);
+}
+function createPlainMonthDayFromFields(calendar, fields, options) {
+	const isIso = calendar === void 0;
+	const eraOrigins = getCalendarEraOrigins(calendar);
+	void 0 === fields.day && throwTypeError(missingField("day")), isIso || void 0 === fields.month || void 0 !== fields.year || void 0 !== fields.era && void 0 !== fields.eraYear || throwTypeError(missingYear(eraOrigins));
+	const monthCodeParts = parseMonthCodeField(fields);
+	let yearMaybe = void 0 !== fields.eraYear || void 0 !== fields.year ? resolveCalendarYear(calendar, fields) : void 0;
+	const overflow = refineOverflowOptions(options);
+	let day;
+	let monthCodeNumber;
+	let isLeapMonth;
+	if (void 0 === yearMaybe && isIso && (yearMaybe = 1972), void 0 !== yearMaybe) {
+		isIso || checkIsoDateInBounds(computeCalendarIsoFieldsFromParts(calendar, yearMaybe, 1, 1));
+		const month = resolveCalendarMonth(calendar, fields, yearMaybe, overflow, monthCodeParts);
+		day = resolveCalendarDay(calendar, fields, month, yearMaybe, overflow), [monthCodeNumber, isLeapMonth] = computeCalendarMonthCodeParts(calendar, yearMaybe, month);
+	} else {
+		void 0 === fields.monthCode && throwTypeError("Missing month/monthCode"), [monthCodeNumber, isLeapMonth] = monthCodeParts;
+		const referenceYear = calendar ? calendar.ge : 1972;
+		if (void 0 !== referenceYear) day = resolveCalendarDay(calendar, fields, resolveCalendarMonth(calendar, fields, referenceYear, overflow, monthCodeParts), referenceYear, overflow);
+		else {
+			const constrainedDay = 0 === overflow && calendar ? calendar.ke?.(monthCodeNumber, isLeapMonth, fields.day) : void 0;
+			day = void 0 !== constrainedDay ? constrainedDay : fields.day;
+		}
+	}
+	isLeapMonth && ((calendar && calendar.Z?.[monthCodeNumber]) ?? Infinity) < fields.day && (1 === overflow && throwRangeError(invalidLeapMonth), isLeapMonth = 0, day = constrainToRange(fields.day, 1, (calendar && calendar.X) ?? Infinity));
+	let res = calendar ? calendar.v(monthCodeNumber, Boolean(isLeapMonth), day) : computeIsoYearMonthFieldsForMonthDay(monthCodeNumber, Boolean(isLeapMonth));
+	for (; !res && 0 === overflow && day > 1;) day--, res = calendar ? calendar.v(monthCodeNumber, Boolean(isLeapMonth), day) : computeIsoYearMonthFieldsForMonthDay(monthCodeNumber, Boolean(isLeapMonth));
+	res || throwRangeError("Cannot guess year");
+	const { year: finalYear, month: finalMonth } = res;
+	return createDateSlots(checkIsoDateInBounds(computeCalendarIsoFieldsFromParts(calendar, finalYear, finalMonth, day)), calendar);
+}
+const RawDateTimeFormat = Intl.DateTimeFormat;
+function formatEpochMilliToPartsRecord(intlFormat, epochMilli) {
+	epochMilli < -864e13 && throwRangeError("Out-of-bounds date");
+	const parts = intlFormat.formatToParts(epochMilli);
+	const hash = {};
+	for (const part of parts) hash[part.type] = part.value;
+	return hash;
+}
+const timeZonePeriodDaysByName = {
+	"El_Aaiun": 17,
+	"Tucuman": 12,
+	"Tirane": 11,
+	"Riga": 10,
+	"Simferopol": 9,
+	"Vienna": 9,
+	"Tunis": 8,
+	"Boa_Vista": 6,
+	"Fortaleza": 6,
+	"Maceio": 6,
+	"Noronha": 6,
+	"Recife": 6,
+	"Gaza": 6,
+	"Hebron": 6,
+	"DeNoronha": 6
+};
+const minPossibleTransitionSec = -388152e4;
+function refineTimeDisplayTuple(options, maxSmallestUnit = 4) {
+	const subsecDigits = coerceFractionalSecondDigits(options);
+	return [coerceRoundingMode(options, 4), ...resolveSmallestUnitAndSubsecDigits(validateUnitRange(smallestUnitStr, coerceSmallestUnit(options), 0, maxSmallestUnit), subsecDigits)];
+}
+function refineDateDisplayOptions(options) {
+	return coerceCalendarDisplay(require_utils.normalizeOptions(options));
+}
+function refineTimeDisplayOptions(options, maxSmallestUnit) {
+	return refineTimeDisplayTuple(require_utils.normalizeOptions(options), maxSmallestUnit);
+}
+function resolveSmallestUnitAndSubsecDigits(smallestUnit, subsecDigits) {
+	return null != smallestUnit ? [unitNanoMap[smallestUnit], smallestUnit < 4 ? 9 - 3 * smallestUnit : -1] : [void 0 === subsecDigits ? 1 : 10 ** (9 - subsecDigits), subsecDigits];
+}
+function formatInstantIso(refineTimeZoneString, instantSlots, options) {
+	const [timeZoneArg, roundingMode, nanoInc, subsecDigits] = ((options) => {
+		const subsecDigits = coerceFractionalSecondDigits(options = require_utils.normalizeOptions(options));
+		const roundingMode = coerceRoundingMode(options, 4);
+		const smallestUnit = coerceSmallestUnit(options);
+		return [
+			options.timeZone,
+			roundingMode,
+			...resolveSmallestUnitAndSubsecDigits(validateUnitRange(smallestUnitStr, smallestUnit, 0, 4), subsecDigits)
+		];
+	})(options);
+	const providedTimeZone = void 0 !== timeZoneArg;
+	return ((providedTimeZone, timeZone, epochNano, roundingMode, nanoInc, subsecDigits) => {
+		epochNano = roundBigNanoToDayOriginInc(epochNano, BigInt(nanoInc), roundingMode);
+		const offsetNano = timeZone.C(epochNano);
+		return formatIsoDateTimeFields(epochNanoToIsoDateTime(epochNano + BigInt(offsetNano)), subsecDigits) + (providedTimeZone ? formatOffsetNano(roundToMinute(offsetNano)) : "Z");
+	})(providedTimeZone, queryTimeZone(providedTimeZone ? refineTimeZoneString(timeZoneArg) : "UTC"), instantSlots.epochNanoseconds, roundingMode, nanoInc, subsecDigits);
+}
+function formatZonedDateTimeIso(zonedDateTimeSlots0, options) {
+	const displayOptions = ((options) => {
+		options = require_utils.normalizeOptions(options);
+		const calendarDisplay = coerceCalendarDisplay(options);
+		const subsecDigits = coerceFractionalSecondDigits(options);
+		const offsetDisplay = coerceOffsetDisplay(options);
+		const roundingMode = coerceRoundingMode(options, 4);
+		const smallestUnit = coerceSmallestUnit(options);
+		return [
+			calendarDisplay,
+			coerceTimeZoneDisplay(options),
+			offsetDisplay,
+			roundingMode,
+			...resolveSmallestUnitAndSubsecDigits(validateUnitRange(smallestUnitStr, smallestUnit, 0, 4), subsecDigits)
+		];
+	})(options);
+	return ((calendar, timeZoneId, timeZone, epochNano, calendarDisplay, timeZoneDisplay, offsetDisplay, roundingMode, nanoInc, subsecDigits) => {
+		epochNano = roundBigNanoToDayOriginInc(epochNano, BigInt(nanoInc), roundingMode);
+		const offsetNano = timeZone.C(epochNano);
+		return formatIsoDateTimeFields(epochNanoToIsoDateTime(epochNano + BigInt(offsetNano)), subsecDigits) + formatOffsetNano(roundToMinute(offsetNano), offsetDisplay) + formatTimeZone(timeZoneId, timeZoneDisplay) + formatCalendar(calendar, calendarDisplay);
+	})(zonedDateTimeSlots0.calendar, zonedDateTimeSlots0.timeZone.id, zonedDateTimeSlots0.timeZone, zonedDateTimeSlots0.epochNanoseconds, ...displayOptions);
+}
+function formatPlainDateTimeIso(plainDateTimeSlots0, options) {
+	const displayOptions = ((options) => (options = require_utils.normalizeOptions(options), [coerceCalendarDisplay(options), ...refineTimeDisplayTuple(options)]))(options);
+	return ((calendar, isoDateTime, calendarDisplay, roundingMode, nanoInc, subsecDigits) => formatIsoDateTimeFields(roundDateTimeToNano(isoDateTime, nanoInc, roundingMode), subsecDigits) + formatCalendar(calendar, calendarDisplay))(plainDateTimeSlots0.calendar, plainDateTimeSlots0, ...displayOptions);
+}
+function formatPlainDateIso(plainDateSlots, options) {
+	return calendar = plainDateSlots.calendar, isoDate = plainDateSlots, calendarDisplay = refineDateDisplayOptions(options), formatIsoDateFields(isoDate) + formatCalendar(calendar, calendarDisplay);
+	var calendar, isoDate, calendarDisplay;
+}
+function formatPlainYearMonthIso(plainYearMonthSlots, options) {
+	return formatDateLikeIso(plainYearMonthSlots.calendar, formatIsoYearMonthFields, plainYearMonthSlots, refineDateDisplayOptions(options));
+}
+function formatPlainMonthDayIso(plainMonthDaySlots, options) {
+	return formatDateLikeIso(plainMonthDaySlots.calendar, formatIsoMonthDayFields, plainMonthDaySlots, refineDateDisplayOptions(options));
+}
+function formatDateLikeIso(calendar, formatSimple, isoDate, calendarDisplay) {
+	return 1 === calendarDisplay ? calendar === void 0 ? formatSimple(isoDate) : formatIsoDateFields(isoDate) : calendarDisplay > 1 || 0 === calendarDisplay && calendar !== void 0 ? formatIsoDateFields(isoDate) + formatCalendarId(getCalendarSlotId(calendar), 2 === calendarDisplay) : formatSimple(isoDate);
+}
+function formatPlainTimeIso(slots, options) {
+	return ((fields, roundingMode, nanoInc, subsecDigits) => formatTimeFields(roundTimeToNano(fields, nanoInc, roundingMode)[0], subsecDigits))(slots, ...refineTimeDisplayOptions(options));
+}
+function formatDurationIso(slots, options) {
+	const [roundingMode, nanoInc, subsecDigits] = refineTimeDisplayOptions(options, 3);
+	return nanoInc > 1 && validateDurationFields(slots = {
+		...slots,
+		...roundDayTimeDurationByInc(slots, nanoInc, roundingMode)
+	}), formatDurationSlots(slots, subsecDigits);
+}
+function formatDurationSlots(durationSlots, subsecDigits) {
+	const { sign } = durationSlots;
+	const abs = -1 === sign ? negateDurationFields(durationSlots) : durationSlots;
+	const { hours, minutes } = abs;
+	const bigNano = durationSubMinuteToBigNano(abs);
+	const wholeSec = Number(bigNano / bigNanoInSec);
+	const subsecNano = Number(bigNano % bigNanoInSec);
+	validateDurationTimeUnit(wholeSec);
+	const subsecNanoString = formatSubsecNano(subsecNano, subsecDigits);
+	const forceSec = subsecDigits >= 0 || !sign || subsecNanoString;
+	return (sign < 0 ? "-" : "") + "P" + formatDurationFragments({
+		"Y": formatDurationNumber(abs.years),
+		"M": formatDurationNumber(abs.months),
+		"W": formatDurationNumber(abs.weeks),
+		"D": formatDurationNumber(abs.days)
+	}) + (hours || minutes || wholeSec || forceSec ? "T" + formatDurationFragments({
+		"H": formatDurationNumber(hours),
+		"M": formatDurationNumber(minutes),
+		"S": formatDurationNumber(wholeSec, forceSec) + subsecNanoString
+	}) : "");
+}
+function formatDurationFragments(fragObj) {
+	const parts = [];
+	for (const fragName in fragObj) {
+		const fragVal = fragObj[fragName];
+		fragVal && parts.push(fragVal, fragName);
+	}
+	return parts.join("");
+}
+function formatDurationNumber(n, force) {
+	if (!n && !force) return "";
+	const options = Object.create(null);
+	return options.useGrouping = 0, n.toLocaleString("fullwide", options);
+}
+function formatIsoDateTimeFields(isoDateTime, subsecDigits) {
+	return formatIsoDateFields(isoDateTime) + "T" + formatTimeFields(isoDateTime, subsecDigits);
+}
+function formatIsoDateFields(isoDateFields) {
+	return formatIsoYearMonthFields(isoDateFields) + "-" + padNumber2(isoDateFields.day);
+}
+function formatIsoYearMonthFields(isoDateFields) {
+	const { year } = isoDateFields;
+	return (year < 0 || year > 9999 ? getSignStr(year) + padNumber(6, Math.abs(year)) : padNumber(4, year)) + "-" + padNumber2(isoDateFields.month);
+}
+function formatIsoMonthDayFields(isoDateFields) {
+	return padNumber2(isoDateFields.month) + "-" + padNumber2(isoDateFields.day);
+}
+function formatTimeFields(timeFields, subsecDigits) {
+	const parts = [padNumber2(timeFields.hour), padNumber2(timeFields.minute)];
+	return -1 !== subsecDigits && parts.push(padNumber2(timeFields.second) + ((millisecond, microsecond, nanosecond, subsecDigits) => formatSubsecNano(millisecond * nanoInMilli + microsecond * nanoInMicro + nanosecond, subsecDigits))(timeFields.millisecond, timeFields.microsecond, timeFields.nanosecond, subsecDigits)), parts.join(":");
+}
+function formatOffsetNano(offsetNano, offsetDisplay = 0) {
+	if (1 === offsetDisplay) return "";
+	const [hour, nanoRemainder0] = divModFloor(Math.abs(offsetNano), nanoInHour);
+	const [minute, nanoRemainder1] = divModFloor(nanoRemainder0, nanoInMinute);
+	const [second, nanoRemainder2] = divModFloor(nanoRemainder1, nanoInSec);
+	return getSignStr(offsetNano) + padNumber2(hour) + ":" + padNumber2(minute) + (second || nanoRemainder2 ? ":" + padNumber2(second) + formatSubsecNano(nanoRemainder2) : "");
+}
+function formatTimeZone(timeZoneId, timeZoneDisplay) {
+	return 1 !== timeZoneDisplay ? "[" + (2 === timeZoneDisplay ? "!" : "") + timeZoneId + "]" : "";
+}
+function formatCalendar(calendar, calendarDisplay) {
+	return calendarDisplay > 1 || 0 === calendarDisplay && calendar !== void 0 ? formatCalendarId(getCalendarSlotId(calendar), 2 === calendarDisplay) : "";
+}
+function formatCalendarId(calendarId, isCritical) {
+	return "[" + (isCritical ? "!" : "") + "u-ca=" + calendarId + "]";
+}
+const trailingZerosRE = /0+$/;
+function formatSubsecNano(totalNano, subsecDigits) {
+	let s = padNumber(9, totalNano);
+	return s = void 0 === subsecDigits ? s.replace(trailingZerosRE, "") : s.slice(0, subsecDigits), s ? "." + s : "";
+}
+function getSignStr(num) {
+	return num < 0 ? "-" : "+";
+}
+const icuRegExp = /^(AC|AE|AG|AR|AS|BE|BS|CA|CN|CS|CT|EA|EC|IE|IS|JS|MI|NE|NS|PL|PN|PR|PS|SS|VS)T$/;
+const badCharactersRegExp = /[^\w\/:+-]+/;
+function refineTimeZoneId(rawId) {
+	return resolveTimeZoneId(requireString(rawId));
+}
+function resolveTimeZoneId(rawId) {
+	return resolveTimeZoneRecord(rawId).id;
+}
+function resolveTimeZoneRecord(rawId) {
+	const upperRawId = rawId.toUpperCase();
+	const offsetRecord = ((upperRawId) => {
+		const offsetNano = parseOffsetNanoMaybe(upperRawId, 1);
+		if (void 0 !== offsetNano) return {
+			id: formatOffsetNano(offsetNano),
+			_: offsetNano,
+			o: offsetNano
+		};
+	})(upperRawId);
+	if (offsetRecord) return {
+		kind: "fixed",
+		...offsetRecord
+	};
+	return queryNamedTimeZoneRecord("UTC" === upperRawId ? "UTC" : ((rawId) => (badCharactersRegExp.test(rawId) && throwRangeError(invalidTimeZone(rawId)), icuRegExp.test(rawId) && throwRangeError("Forbidden ICU TimeZone"), rawId.toLowerCase().split("/").map((part, partI) => (part.length <= 3 || /\d/.test(part)) && !/etc|yap/.test(part) ? part.toUpperCase() : part.replace(/baja|dumont|[a-z]+/g, (a, i) => a.length <= 2 && !partI || "in" === a || "chat" === a ? a.toUpperCase() : a.length > 2 || !i ? capitalize(a).replace(/island|noronha|murdo|rivadavia|urville/, capitalize) : a)).join("/")))(rawId));
+}
+const queryNamedTimeZoneRecord = /* @__PURE__ */ memoize((normId) => {
+	if ("UTC" === normId) return {
+		kind: "utc",
+		id: normId,
+		o: normId
+	};
+	const format = queryTimeZoneIntlFormat(normId.toUpperCase());
+	return {
+		kind: "named",
+		id: normId,
+		format,
+		o: format.resolvedOptions().timeZone
+	};
+});
+const queryTimeZoneIntlFormat = /* @__PURE__ */ memoize((upperNormId) => new RawDateTimeFormat("en-u-hc-h23", {
+	calendar: "iso8601",
+	timeZone: upperNormId,
+	era: "short",
+	year: "numeric",
+	month: "numeric",
+	day: "numeric",
+	hour: "numeric",
+	minute: "numeric",
+	second: "numeric"
+}));
+function queryTimeZone(rawTimeZoneId) {
+	const record = resolveTimeZoneRecord(rawTimeZoneId);
+	return queryTimeZoneRecord(record.id, record);
+}
+const queryTimeZoneRecord = /* @__PURE__ */ memoize((normTimeZoneId, record) => "named" === record.kind ? new IntlTimeZone(normTimeZoneId, record.o, record.format) : new FixedTimeZone(normTimeZoneId, record.o, "fixed" === record.kind ? record._ : 0));
+var FixedTimeZone = class {
+	constructor(id, compareKey, offsetNano) {
+		this.id = id, this.o = compareKey, this._ = offsetNano;
+	}
+	C() {
+		return this._;
+	}
+	R(isoDateTime) {
+		return [isoDateTimeAndOffsetToEpochNano(isoDateTime, this._)];
+	}
+	U() {}
+};
+var IntlTimeZone = class {
+	constructor(id, compareKey, format) {
+		this.id = id, this.o = compareKey, this.qe = ((computeOffsetSec, periodDays) => {
+			const getSample = memoize(computeOffsetSec);
+			const getSplit = memoize(createSplitTuple);
+			const periodSec = 86400 * periodDays;
+			function getOffsetSec(epochSec) {
+				const [startEpochSec, endEpochSec] = computePeriod(epochSec, periodSec);
+				const clampedStartEpochSec = clampIntlSampleEpochSec(startEpochSec);
+				const clampedEndEpochSec = clampIntlSampleEpochSec(endEpochSec);
+				const startOffsetSec = getSample(clampedStartEpochSec);
+				const endOffsetSec = getSample(clampedEndEpochSec);
+				return startOffsetSec === endOffsetSec ? startOffsetSec : pinch(getSplit(clampedStartEpochSec, clampedEndEpochSec), startOffsetSec, endOffsetSec, epochSec);
+			}
+			function pinch(split, startOffsetSec, endOffsetSec, forEpochSec) {
+				let offsetSec;
+				let splitDurSec;
+				for (; (void 0 === forEpochSec || void 0 === (offsetSec = forEpochSec < split[0] ? startOffsetSec : forEpochSec >= split[1] ? endOffsetSec : void 0)) && (splitDurSec = split[1] - split[0]);) {
+					const middleEpochSec = split[0] + Math.floor(splitDurSec / 2);
+					computeOffsetSec(middleEpochSec) === endOffsetSec ? split[1] = middleEpochSec : split[0] = middleEpochSec + 1;
+				}
+				return offsetSec;
+			}
+			return {
+				Ee(zonedEpochSec) {
+					const wideOffsetSec0 = getOffsetSec(zonedEpochSec - 86400);
+					const wideOffsetSec1 = getOffsetSec(zonedEpochSec + 86400);
+					const wideUtcEpochSec0 = zonedEpochSec - wideOffsetSec0;
+					const wideUtcEpochSec1 = zonedEpochSec - wideOffsetSec1;
+					if (wideOffsetSec0 === wideOffsetSec1) return [wideUtcEpochSec0];
+					const narrowOffsetSec0 = getOffsetSec(wideUtcEpochSec0);
+					return narrowOffsetSec0 === getOffsetSec(wideUtcEpochSec1) ? [zonedEpochSec - narrowOffsetSec0] : wideOffsetSec0 > wideOffsetSec1 ? [wideUtcEpochSec0, wideUtcEpochSec1] : [];
+				},
+				De: getOffsetSec,
+				U: function getTransition(epochSec, direction) {
+					if (direction > 0 && epochSec >= 864e10) return;
+					if (direction < 0) {
+						if (epochSec <= minPossibleTransitionSec) return;
+						const lookaheadEpochSec = getCurrentEpochSec() + 94867200;
+						if (epochSec > lookaheadEpochSec) return getTransition(lookaheadEpochSec, -1);
+					}
+					let [startEpochSec, endEpochSec] = computePeriod(direction > 0 ? Math.max(epochSec, minPossibleTransitionSec) : epochSec, periodSec);
+					const inc = periodSec * direction;
+					const searchLimit = direction > 0 ? Math.max(epochSec, getCurrentEpochSec()) + 94867200 : minPossibleTransitionSec;
+					const inBounds = () => direction < 0 ? endEpochSec > searchLimit : startEpochSec < searchLimit;
+					for (; inBounds();) {
+						const clampedStartEpochSec = clampIntlSampleEpochSec(startEpochSec);
+						const clampedEndEpochSec = clampIntlSampleEpochSec(endEpochSec);
+						const startOffsetSec = getSample(clampedStartEpochSec);
+						const endOffsetSec = getSample(clampedEndEpochSec);
+						if (startOffsetSec !== endOffsetSec) {
+							const split = getSplit(clampedStartEpochSec, clampedEndEpochSec);
+							pinch(split, startOffsetSec, endOffsetSec);
+							const transitionEpochSec = split[0];
+							if ((compareNumbers(transitionEpochSec, epochSec) || 1) === direction) return transitionEpochSec;
+						}
+						startEpochSec += inc, endEpochSec += inc;
+					}
+				}
+			};
+		})(((format) => (epochSec) => {
+			const intlParts = formatEpochMilliToPartsRecord(format, 1e3 * epochSec);
+			return 86400 * isoArgsToEpochDays(((intlParts) => {
+				const relatedYear = intlParts.relatedYear;
+				if (void 0 !== relatedYear) return parseInt(relatedYear);
+				const year = parseInt(intlParts.year);
+				return void 0 !== intlParts.era && "bce" === normalizeEraName(intlParts.era) ? 1 - year : year;
+			})(intlParts), parseInt(intlParts.month), parseInt(intlParts.day)) + 3600 * parseInt(intlParts.hour) + 60 * parseInt(intlParts.minute) + parseInt(intlParts.second) - epochSec;
+		})(format), ((timeZoneId) => {
+			return timeZonePeriodDaysByName[timeZoneId.split("/").pop()] || 60;
+		})(id));
+	}
+	C(epochNano) {
+		return this.qe.De(((epochNano) => epochNanoToSecMod(epochNano)[0])(epochNano)) * nanoInSec;
+	}
+	R(isoDateTime) {
+		const zonedEpochSec = 86400 * isoDateToEpochDays(isoDateTime) + timeFieldsToSec(isoDateTime);
+		const subsecNano = timeFieldsToSubsecNano(isoDateTime);
+		return this.qe.Ee(zonedEpochSec).map((epochSec) => checkEpochNanoInBounds(BigInt(epochSec) * bigNanoInSec + BigInt(subsecNano)));
+	}
+	U(epochNano, direction) {
+		const [epochSec, subsecNano] = epochNanoToSecMod(epochNano);
+		const resEpochSec = this.qe.U(epochSec + (direction > 0 || subsecNano ? 1 : 0), direction);
+		if (void 0 !== resEpochSec) return BigInt(resEpochSec) * bigNanoInSec;
+	}
+};
+function getCurrentEpochSec() {
+	return Math.floor(Date.now() / 1e3);
+}
+function createSplitTuple(startEpochSec, endEpochSec) {
+	return [startEpochSec, endEpochSec];
+}
+function computePeriod(epochSec, periodSec) {
+	const startEpochSec = Math.floor(epochSec / periodSec) * periodSec;
+	return [startEpochSec, startEpochSec + periodSec];
+}
+function clampIntlSampleEpochSec(epochSec) {
+	return constrainToRange(epochSec, -1e10, 864e10);
+}
+function refineMaybeZonedDateTimeObjectLike(refineTimeZoneString, calendar, bag) {
+	const fields = readAndRefineBagFields(bag, getCalendarFieldNames(calendar, dateTimeAndZoneFieldNamesAlpha, dateTimeAndZoneFieldNamesWithEraAlpha), zonedDateTimeFieldRefiners, [], 0);
+	if (void 0 !== fields.timeZone) {
+		const isoDateFields = createPlainDateFromFields(calendar, fields);
+		const timeFields = resolveTimeFields(fields);
+		const timeZone = queryTimeZone(refineTimeZoneString(fields.timeZone));
+		return {
+			epochNanoseconds: getMatchingInstantFor(timeZone, combineDateAndTime(isoDateFields, timeFields), fields.offset),
+			timeZone,
+			calendar
+		};
+	}
+	return createPlainDateFromFields(calendar, fields);
+}
+function refineZonedDateTimeObjectLike(refineTimeZoneString, calendar, bag, options) {
+	const fields = readAndRefineBagFields(bag, getCalendarFieldNames(calendar, dateTimeAndZoneFieldNamesAlpha, dateTimeAndZoneFieldNamesWithEraAlpha), zonedDateTimeFieldRefiners, timeZoneFieldNames, 0);
+	const timeZoneId = refineTimeZoneString(fields.timeZone);
+	const [isoDateFields, overflow, offsetDisambig, epochDisambig] = createPlainDateFromFieldsWithOptionsRefiner(calendar, fields, () => refineZonedFieldOptions(options));
+	const timeFields = resolveTimeFields(fields, overflow);
+	const timeZone = queryTimeZone(timeZoneId);
+	return createZonedEpochNanoSlots(getMatchingInstantFor(timeZone, combineDateAndTime(isoDateFields, timeFields), fields.offset, offsetDisambig, epochDisambig), timeZone, calendar);
+}
+function refinePlainDateTimeObjectLike(calendar, bag, options) {
+	const fields = readAndRefineBagFields(bag, getCalendarFieldNames(calendar, dateTimeFieldNamesAlpha, dateTimeFieldNamesWithEraAlpha), dateTimeFieldRefiners, [], 0);
+	const [isoDateInternals, overflow] = createPlainDateFromFieldsWithOptionsRefiner(calendar, fields, () => [refineOverflowOptions(options)]);
+	return createPlainDateTimeFromRefinedFields(isoDateInternals, resolveTimeFields(fields, overflow), calendar);
+}
+function refinePlainDateObjectLike(calendar, bag, options, requireFields = []) {
+	return createPlainDateFromFields(calendar, readAndRefineBagFields(bag, getCalendarFieldNames(calendar, dateFieldNamesAlpha, dateFieldNamesWithEraAlpha), dateFieldRefiners, requireFields), options);
+}
+function refinePlainYearMonthObjectLike(calendar, bag, options, requireFields) {
+	return createPlainYearMonthFromFields(calendar, readAndRefineBagFields(bag, getCalendarFieldNames(calendar, yearMonthFieldNamesAlpha, yearMonthFieldNamesWithEraAlpha), dateFieldRefiners, requireFields), options);
+}
+function refinePlainMonthDayObjectLike(calendar, calendarAbsent, bag, options) {
+	const fields = readAndRefineBagFields(bag, getCalendarFieldNames(calendar, dateFieldNamesAlpha, dateFieldNamesWithEraAlpha), dateFieldRefiners, dayFieldNamesAsc, 0);
+	return calendarAbsent && void 0 !== fields.month && void 0 === fields.monthCode && void 0 === fields.year && (fields.year = 1972), createPlainMonthDayFromFields(calendar, fields, options);
+}
+function refinePlainTimeObjectLike(bag, options) {
+	return resolveTimeFields(readAndRefineBagFields(bag, timeFieldNamesAlpha, timeFieldRefiners, [], 1), refineOverflowOptions(options));
+}
+function refineDurationObjectLike(bag) {
+	const durationFields = readAndRefineBagFields(bag, durationFieldNamesAlpha, durationFieldRefiners);
+	return createDurationSlots(validateDurationFields({
+		...durationFieldDefaults,
+		...durationFields
+	}));
+}
+function throwFailedParse(s) {
+	throwRangeError(failedParse(s));
+}
+function parseInstant(s) {
+	const organized = parseDateTimeLike(s = toStringViaPrimitive(s));
+	let offsetNano;
+	return organized || throwFailedParse(s), organized.F ? offsetNano = 0 : organized.offset ? offsetNano = parseOffsetNano(organized.offset) : throwFailedParse(s), organized.timeZoneId && parseOffsetNanoMaybe(organized.timeZoneId, 1), validateIsoDateTimeFields(organized), createEpochNanoSlots(isoDateTimeAndOffsetToEpochNano(organized, offsetNano));
+}
+function parseRelativeToSlots(s, resolveCalendar) {
+	const organized = parseDateTimeLike(requireString(s));
+	return organized || throwFailedParse(s), organized.timeZoneId ? finalizeZonedDateTime(organized, resolveCalendar, void 0) : (organized.F && throwFailedParse(s), finalizeDate(organized, resolveCalendar));
+}
+function parseZonedDateTime(s, resolveCalendar, options) {
+	const organized = parseDateTimeLike(requireString(s));
+	return organized && organized.timeZoneId || throwFailedParse(s), finalizeZonedDateTime(organized, resolveCalendar, options);
+}
+function parsePlainDateTime(s, resolveCalendar) {
+	const organized = parseDateTimeLike(requireString(s));
+	return organized && !organized.F || throwFailedParse(s), finalizeDateTime(organized, resolveCalendar);
+}
+function parsePlainDate(s, resolveCalendar) {
+	const slots = finalizeDateLike(parsePlainDateLike(requireString(s)), void 0, resolveCalendar);
+	return createDateSlots(slots, slots.calendar);
+}
+function parsePlainYearMonth(s, resolveCalendar) {
+	const organized = parseYearMonthOnly(requireString(s));
+	if (organized) return requireIsoCalendar(organized), createDateSlots(checkIsoYearMonthInBounds(validateIsoDateFields(organized)), resolveCalendar(organized.calendarId));
+	const dateSlots = finalizeDateLike(parsePlainDateLike(s), projectIsoYearMonthDate, resolveCalendar);
+	const { calendar } = dateSlots;
+	return createDateSlots(moveToStartOfMonth(calendar, dateSlots), calendar);
+}
+function requireIsoCalendar(organized) {
+	"iso8601" !== organized.calendarId && throwRangeError(invalidSubstring(organized.calendarId));
+}
+function parsePlainMonthDay(s, resolveCalendar) {
+	const organized = parseMonthDayOnly(requireString(s));
+	if (organized) return requireIsoCalendar(organized), createDateSlots(validateIsoDateFields(organized), resolveCalendar(organized.calendarId));
+	const dateSlots = finalizeDateLike(parsePlainDateLike(s), projectIsoMonthDayDate, resolveCalendar);
+	const { calendar } = dateSlots;
+	const { year: origYear, month: origMonth, day } = computeCalendarDateFields(calendar, dateSlots);
+	const [monthCodeNumber, isLeapMonth] = computeCalendarMonthCodeParts(calendar, origYear, origMonth);
+	const { year, month } = ((calendar, monthCodeNumber, isLeapMonth, day) => {
+		const yearMonthFields = calendar ? calendar.v(monthCodeNumber, isLeapMonth, day) : computeIsoYearMonthFieldsForMonthDay(monthCodeNumber, isLeapMonth);
+		return yearMonthFields || throwRangeError("Cannot guess year"), yearMonthFields;
+	})(calendar, monthCodeNumber, isLeapMonth, day);
+	return createDateSlots(checkIsoDateInBounds(computeCalendarIsoFieldsFromParts(calendar, year, month, day)), calendar);
+}
+function parsePlainTime(s) {
+	let organized = ((s) => {
+		const parts = parseTimeOnlyParts(s);
+		return parts ? (organizeAnnotationParts(parts[13]), organizeTimeParts(parts, 1)) : void 0;
+	})(s = requireString(s));
+	let altParsed;
+	return organized || (organized = parseDateTimeLike(s), organized ? (organized.fe || throwFailedParse(s), organized.F && throwRangeError(invalidSubstring("Z")), requireIsoCalendar(organized)) : throwFailedParse(s)), (altParsed = parseYearMonthOnly(s)) && isIsoDateFieldsValid(altParsed) && throwFailedParse(s), (altParsed = parseMonthDayOnly(s)) && isIsoDateFieldsValid(altParsed) && throwFailedParse(s), createTimeSlots(validateTimeFields(organized));
+}
+function parseDuration(s) {
+	const parsed = ((s) => {
+		const parts = durationRegExp.exec(s);
+		return parts ? ((parts) => {
+			let hasAny = 0;
+			let hasAnyFrac = 0;
+			let leftoverNano = 0;
+			let durationFields = {
+				years: parseUnit(parts[2]),
+				months: parseUnit(parts[3]),
+				weeks: parseUnit(parts[4]),
+				days: parseUnit(parts[5]),
+				hours: parseUnit(parts[6], parts[7], 5),
+				minutes: parseUnit(parts[8], parts[9], 4),
+				seconds: parseUnit(parts[10], parts[11], 3),
+				...nanoToGivenFields(leftoverNano, 2, durationFieldNamesAsc)
+			};
+			return hasAny || throwRangeError(noValidFields(durationFieldNamesAsc)), parseSign(parts[1]) < 0 && (durationFields = negateDurationFields(durationFields)), durationFields;
+			function parseUnit(wholeStr, fracStr, timeUnit) {
+				let leftoverUnits = 0;
+				let wholeUnits = 0;
+				return timeUnit && ([leftoverUnits, leftoverNano] = divModFloor(leftoverNano, unitNanoMap[timeUnit])), void 0 !== wholeStr && (hasAnyFrac && throwRangeError(invalidSubstring(wholeStr)), wholeUnits = ((s) => {
+					const n = parseInt(s);
+					return Number.isFinite(n) || throwRangeError(invalidSubstring(s)), n;
+				})(wholeStr), hasAny = 1, fracStr && (leftoverNano = parseSubsecNano(fracStr) * (unitNanoMap[timeUnit] / nanoInSec), hasAnyFrac = 1)), leftoverUnits + wholeUnits;
+			}
+		})(parts) : void 0;
+	})(requireString(s));
+	return parsed || throwFailedParse(s), createDurationSlots(validateDurationFields(parsed));
+}
+function parseCalendarId(s) {
+	const res = parseDateTimeLike(s) || parseYearMonthOnly(s) || parseMonthDayOnly(s);
+	if (res) return res.calendarId;
+	const timeParts = parseTimeOnlyParts(s);
+	return timeParts ? organizeAnnotationParts(timeParts[13]).calendarId : s;
+}
+function parseTimeZoneId(s) {
+	const parsed = parseDateTimeLike(s);
+	return parsed && (parsed.timeZoneId || parsed.F && "UTC" || parsed.offset) || s;
+}
+function parsePlainDateLike(s) {
+	const organized = parseDateTimeLike(s);
+	return organized && !organized.F || throwFailedParse(s), organized;
+}
+function finalizeDateLike(organized, isoDateProjector, resolveCalendar) {
+	return isoDateProjector && "iso8601" === organized.calendarId ? (validateIsoDateFields(organized), organized.fe && validateTimeFields(organized), finalizeDate(isoDateProjector(organized), resolveCalendar)) : organized.fe ? finalizeDateTime(organized, resolveCalendar) : finalizeDate(organized, resolveCalendar);
+}
+function projectIsoYearMonthDate(organized) {
+	const day = 12 * organized.year + organized.month === isoYearMonthIndexMin ? 20 : 1;
+	return {
+		...organized,
+		day
+	};
+}
+function projectIsoMonthDayDate(organized) {
+	return {
+		...organized,
+		year: 1972
+	};
+}
+function finalizeZonedDateTime(organized, resolveCalendar, options) {
+	const timeZone = queryTimeZone(resolveTimeZoneId(organized.timeZoneId));
+	let epochNano;
+	if (validateIsoDateTimeFields(organized), organized.fe) {
+		const offsetNano = organized.offset ? parseOffsetNano(organized.offset) : void 0;
+		const [, offsetDisambig, epochDisambig] = refineZonedFieldOptions(options);
+		epochNano = getMatchingInstantFor(timeZone, organized, offsetNano, offsetDisambig, epochDisambig, !(timeZone._ || void 0 === organized.offset || (offset = organized.offset, offset.replace(/\D/g, "").length > 4)), organized.F);
+	} else refineZonedFieldOptions(options), epochNano = getStartOfDayInstantFor(timeZone, organized);
+	var offset;
+	return checkEpochNanoInBounds(epochNano), createZonedEpochNanoSlots(epochNano, timeZone, resolveCalendar(organized.calendarId));
+}
+function finalizeDateTime(organized, resolveCalendar) {
+	return validateIsoDateTimeFields(organized), checkIsoDateTimeInBounds(organized), {
+		...combineDateAndTime(organized, organized),
+		calendar: resolveCalendar(organized.calendarId)
+	};
+}
+function finalizeDate(organized, resolveCalendar) {
+	return validateIsoDateFields(organized), checkIsoDateInBounds(organized), {
+		calendar: resolveCalendar(organized.calendarId),
+		year: organized.year,
+		month: organized.month,
+		day: organized.day
+	};
+}
+function timeRegExpStr(separatorIndex) {
+	return `(\\d{2})(?:(:?)(\\d{2})(?:\\${separatorIndex}(\\d{2})(?:[.,](\\d{1,9}))?)?)?`;
+}
+function offsetRegExpStr(separatorIndex) {
+	return "([+-])" + timeRegExpStr(separatorIndex);
+}
+const dateTimeRegExpStr = "(?:(?:([+-])(\\d{6}))|(\\d{4}))(-?)(\\d{2})\\4(\\d{2})(?:[T ]" + timeRegExpStr(8) + "(Z|" + offsetRegExpStr(15) + ")?)?";
+const yearMonthRegExp = /* @__PURE__ */ createRegExp("(?:(?:([+-])(\\d{6}))|(\\d{4}))-?(\\d{2})((?:\\[(!?)([^\\]]*)\\]){0,9})");
+const monthDayRegExp = /* @__PURE__ */ createRegExp("(?:--)?(\\d{2})-?(\\d{2})((?:\\[(!?)([^\\]]*)\\]){0,9})");
+const dateTimeRegExp = /* @__PURE__ */ createRegExp(dateTimeRegExpStr + "((?:\\[(!?)([^\\]]*)\\]){0,9})");
+const timeRegExp = /* @__PURE__ */ createRegExp("T?" + timeRegExpStr(2) + `(${offsetRegExpStr(9)})?((?:\\[(!?)([^\\]]*)\\]){0,9})`);
+const annotationRegExp = /* @__PURE__ */ new RegExp("\\[(!?)([^\\]]*)\\]", "g");
+const durationRegExp = /* @__PURE__ */ createRegExp("([+-])?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)?)?");
+function parseDateTimeLike(s) {
+	const parts = dateTimeRegExp.exec(s);
+	return parts ? ((parts) => {
+		const zOrOffset = parts[12];
+		const hasZ = "Z" === (zOrOffset || "").toUpperCase();
+		return {
+			year: organizeIsoYearParts(parts),
+			month: parseInt(parts[5]),
+			day: parseInt(parts[6]),
+			...organizeTimeParts(parts, 7),
+			...organizeAnnotationParts(parts[19]),
+			fe: Boolean(parts[7]),
+			F: hasZ,
+			offset: hasZ ? void 0 : zOrOffset
+		};
+	})(parts) : void 0;
+}
+function parseYearMonthOnly(s) {
+	const parts = yearMonthRegExp.exec(s);
+	if (parts) return ((parts) => ({
+		year: organizeIsoYearParts(parts),
+		month: parseInt(parts[4]),
+		day: 1,
+		...organizeAnnotationParts(parts[5])
+	}))(parts);
+}
+function parseMonthDayOnly(s) {
+	const parts = monthDayRegExp.exec(s);
+	return parts ? ((parts) => ({
+		year: 1972,
+		month: parseInt(parts[1]),
+		day: parseInt(parts[2]),
+		...organizeAnnotationParts(parts[3])
+	}))(parts) : void 0;
+}
+function parseTimeOnlyParts(s) {
+	const parts = timeRegExp.exec(s);
+	if (parts) return parts[6] && parseOffsetNano(parts[6]), parts;
+}
+function organizeTimeParts(parts, hourIndex) {
+	const second = parseInt0(parts[hourIndex + 3]);
+	return {
+		...nanoToTimeAndDay(parseSubsecNano(parts[hourIndex + 4] || ""))[0],
+		hour: parseInt0(parts[hourIndex]),
+		minute: parseInt0(parts[hourIndex + 2]),
+		second: 60 === second ? 59 : second
+	};
+}
+function organizeIsoYearParts(parts) {
+	const yearSign = parseSign(parts[1]);
+	const year = parseInt(parts[2] || parts[3]);
+	return yearSign < 0 && !year && throwRangeError(invalidSubstring(-0)), yearSign * year;
+}
+function organizeAnnotationParts(s) {
+	let calendarIsCritical;
+	let timeZoneId;
+	const calendarIds = [];
+	return s.replace(annotationRegExp, (whole, criticalStr, mainStr) => {
+		const isCritical = Boolean(criticalStr);
+		const [val, name] = mainStr.split("=").reverse();
+		return name ? "u-ca" === name ? (calendarIds.push(val.toLowerCase()), calendarIsCritical || (calendarIsCritical = isCritical)) : (isCritical || /[A-Z]/.test(name)) && throwRangeError(invalidSubstring(whole)) : (timeZoneId && throwRangeError(invalidSubstring(whole)), timeZoneId = val), "";
+	}), calendarIds.length > 1 && calendarIsCritical && throwRangeError(invalidSubstring(s)), {
+		timeZoneId,
+		calendarId: calendarIds[0] || "iso8601"
+	};
+}
+function mergeCalendarFields(calendar, baseFields, additionalFields) {
+	const merged = Object.assign(Object.create(null), baseFields);
+	return spliceFields(merged, additionalFields, monthFieldNames), getCalendarEraOrigins(calendar) && (spliceFields(merged, additionalFields, allYearFieldNames), calendar && calendar.le && spliceFields(merged, additionalFields, monthDayFieldNames, eraYearFieldNames)), merged;
+}
+function spliceFields(dest, additional, allPropNames, deletablePropNames) {
+	let anyMatching = 0;
+	const nonMatchingPropNames = [];
+	for (const propName of allPropNames) void 0 !== additional[propName] ? anyMatching = 1 : nonMatchingPropNames.push(propName);
+	if (Object.assign(dest, additional), anyMatching) for (const deletablePropName of deletablePropNames || nonMatchingPropNames) delete dest[deletablePropName];
+}
+function mergeZonedDateTimeFields(zonedDateTimeSlots, modFields, options) {
+	const { calendar, timeZone } = zonedDateTimeSlots;
+	const validFieldNames = getCalendarFieldNames(calendar, dateTimeAndOffsetFieldNamesAlpha, dateTimeAndOffsetFieldNamesWithEraAlpha);
+	const zonedSlots = zonedEpochSlotsToIso(zonedDateTimeSlots);
+	const { year, month, day } = computeCalendarDateFields(calendar, zonedSlots);
+	const origFields = {
+		year,
+		monthCode: computeMonthCode(calendar, year, month),
+		day,
+		hour: zonedSlots.hour,
+		minute: zonedSlots.minute,
+		second: zonedSlots.second,
+		millisecond: zonedSlots.millisecond,
+		microsecond: zonedSlots.microsecond,
+		nanosecond: zonedSlots.nanosecond,
+		offset: zonedSlots.offsetNanoseconds
+	};
+	const partialFields = readAndRefineBagFields(modFields, validFieldNames, zonedDateTimeFieldRefiners);
+	const mergedCalendarFields = mergeCalendarFields(calendar, origFields, partialFields);
+	const mergedAllFields = {
+		...origFields,
+		...partialFields
+	};
+	const [isoDateFields, overflow, offsetDisambig, epochDisambig] = createPlainDateFromFieldsWithOptionsRefiner(calendar, mergedCalendarFields, () => refineZonedFieldOptions(options, 2));
+	return createZonedEpochNanoSlots(getMatchingInstantFor(timeZone, combineDateAndTime(isoDateFields, constrainTimeFields(mergedAllFields, overflow)), mergedAllFields.offset, offsetDisambig, epochDisambig), timeZone, calendar);
+}
+function mergePlainDateTimeFields(plainDateTimeSlots, modFields, options) {
+	const { calendar } = plainDateTimeSlots;
+	const validFieldNames = getCalendarFieldNames(calendar, dateTimeFieldNamesAlpha, dateTimeFieldNamesWithEraAlpha);
+	const { year, month, day } = computeCalendarDateFields(calendar, plainDateTimeSlots);
+	const origFields = {
+		year,
+		monthCode: computeMonthCode(calendar, year, month),
+		day,
+		hour: plainDateTimeSlots.hour,
+		minute: plainDateTimeSlots.minute,
+		second: plainDateTimeSlots.second,
+		millisecond: plainDateTimeSlots.millisecond,
+		microsecond: plainDateTimeSlots.microsecond,
+		nanosecond: plainDateTimeSlots.nanosecond
+	};
+	const partialFields = readAndRefineBagFields(modFields, validFieldNames, dateTimeFieldRefiners);
+	const mergedCalendarFields = mergeCalendarFields(calendar, origFields, partialFields);
+	const mergedAllFields = {
+		...origFields,
+		...partialFields
+	};
+	const [plainDateSlots, overflow] = createPlainDateFromFieldsWithOptionsRefiner(calendar, mergedCalendarFields, () => [refineOverflowOptions(options)]);
+	return createPlainDateTimeFromRefinedFields(plainDateSlots, constrainTimeFields(mergedAllFields, overflow), calendar);
+}
+function mergePlainDateFields(plainDateSlots, modFields, options) {
+	const { calendar } = plainDateSlots;
+	const validFieldNames = getCalendarFieldNames(calendar, dateFieldNamesAlpha, dateFieldNamesWithEraAlpha);
+	const { year, month, day } = computeCalendarDateFields(calendar, plainDateSlots);
+	return createPlainDateFromFields(calendar, mergeCalendarFields(calendar, {
+		year,
+		monthCode: computeMonthCode(calendar, year, month),
+		day
+	}, readAndRefineBagFields(modFields, validFieldNames, dateFieldRefiners)), options);
+}
+function mergePlainYearMonthFields(plainYearMonthSlots, modFields, options) {
+	const { calendar } = plainYearMonthSlots;
+	const validFieldNames = getCalendarFieldNames(calendar, yearMonthFieldNamesAlpha, yearMonthFieldNamesWithEraAlpha);
+	const { year, month } = computeCalendarDateFields(calendar, plainYearMonthSlots);
+	return createPlainYearMonthFromFields(calendar, mergeCalendarFields(calendar, {
+		year,
+		monthCode: computeMonthCode(calendar, year, month)
+	}, readAndRefineBagFields(modFields, validFieldNames, dateFieldRefiners)), options);
+}
+function mergePlainMonthDayFields(plainMonthDaySlots, modFields, options) {
+	const { calendar } = plainMonthDaySlots;
+	const validFieldNames = getCalendarFieldNames(calendar, dateFieldNamesAlpha, dateFieldNamesWithEraAlpha);
+	const { year, month, day } = computeCalendarDateFields(calendar, plainMonthDaySlots);
+	return createPlainMonthDayFromFields(calendar, mergeCalendarFields(calendar, {
+		monthCode: computeMonthCode(calendar, year, month),
+		day
+	}, readAndRefineBagFields(modFields, validFieldNames, dateFieldRefiners)), options);
+}
+function mergePlainTimeFields(initialFields, mod, options) {
+	return ((initialFields, modFields, options) => resolveTimeFields({
+		...pluckProps(timeFieldNamesAlpha, initialFields),
+		...readAndRefineBagFields(modFields, timeFieldNamesAlpha, timeFieldRefiners)
+	}, refineOverflowOptions(options)))(initialFields, mod, options);
+}
+function mergeDurationFields(slots, fields) {
+	return createDurationSlots((initialFields = slots, modFields = fields, validateDurationFields({
+		...initialFields,
+		...readAndRefineBagFields(modFields, durationFieldNamesAlpha, durationFieldRefiners)
+	})));
+	var initialFields, modFields;
+}
+function computeMonthCode(calendar, year, month) {
+	const [monthCodeNumber, isLeapMonth] = computeCalendarMonthCodeParts(calendar, year, month);
+	return formatMonthCode(monthCodeNumber, isLeapMonth);
+}
+function instantToZonedDateTime(instantSlots, timeZone, calendar) {
+	return createZonedEpochNanoSlots(instantSlots.epochNanoseconds, timeZone, calendar);
+}
+function zonedDateTimeToInstant(zonedDateTimeSlots0) {
+	return createEpochNanoSlots(zonedDateTimeSlots0.epochNanoseconds);
+}
+function zonedDateTimeToPlainDateTime(zonedDateTimeSlots0) {
+	return createDateTimeSlots(zonedEpochSlotsToIso(zonedDateTimeSlots0), zonedDateTimeSlots0.calendar);
+}
+function zonedDateTimeToPlainDate(zonedDateTimeSlots0) {
+	return createDateSlots(zonedEpochSlotsToIso(zonedDateTimeSlots0), zonedDateTimeSlots0.calendar);
+}
+function zonedDateTimeToPlainTime(zonedDateTimeSlots0) {
+	return createTimeSlots(zonedEpochSlotsToIso(zonedDateTimeSlots0));
+}
+function plainDateTimeToZonedDateTime(plainDateTimeSlots, timeZone, options) {
+	return createZonedEpochNanoSlots(checkEpochNanoInBounds(((timeZone, isoDateTime, options) => {
+		return getSingleInstantFor(timeZone, isoDateTime, ((options) => coerceEpochDisambig(require_utils.normalizeOptions(options)))(options));
+	})(timeZone, plainDateTimeSlots, options)), timeZone, plainDateTimeSlots.calendar);
+}
+function plainDateToZonedDateTime(refineTimeZoneString, refinePlainTimeArg, plainDateSlots, options) {
+	const timeZoneId = refineTimeZoneString(options.timeZone);
+	const plainTimeArg = options.plainTime;
+	const timeFields = void 0 !== plainTimeArg ? refinePlainTimeArg(plainTimeArg) : void 0;
+	const timeZone = queryTimeZone(timeZoneId);
+	let epochNano;
+	return epochNano = timeFields ? getSingleInstantFor(timeZone, combineDateAndTime(plainDateSlots, timeFields)) : getStartOfDayInstantFor(timeZone, combineDateAndTime(plainDateSlots, timeFieldDefaults)), createZonedEpochNanoSlots(epochNano, timeZone, plainDateSlots.calendar);
+}
+function convertPlainYearMonthToDate(calendar, input, bag) {
+	return createPlainDateFromMergedFields(calendar, pluckProps(getCalendarFieldNames(calendar, yearMonthCodeFieldNamesAlpha, yearMonthCodeFieldNamesWithEraAlpha), input), readAndRefineBagFields(require_utils.requireObjectLike(bag), dayFieldNamesAsc, dateFieldRefiners, []));
+}
+function convertPlainMonthDayToDate(calendar, input, bag) {
+	const extraFieldNames = getCalendarFieldNames(calendar, yearFieldNamesAsc, yearFieldNamesWithEraAlpha);
+	return createPlainDateFromMergedFields(calendar, pluckProps(monthCodeDayFieldNamesAlpha, input), readAndRefineBagFields(require_utils.requireObjectLike(bag), extraFieldNames, dateFieldRefiners, []));
+}
+function convertToPlainMonthDay(calendar, input) {
+	return createPlainMonthDayFromFields(calendar, readAndRefineBagFields(input, monthCodeDayFieldNamesAlpha, dateFieldRefiners));
+}
+function convertToPlainYearMonth(calendar, input, options) {
+	return createPlainYearMonthFromFields(calendar, readAndRefineBagFields(input, getCalendarFieldNames(calendar, yearMonthCodeFieldNamesAlpha, yearMonthCodeFieldNamesWithEraAlpha), dateFieldRefiners), options);
+}
+function createPlainDateFromMergedFields(calendar, inputFields, extraFields) {
+	const mergedFieldNames = getCalendarFieldNames(calendar, yearMonthCodeDayFieldNamesAlpha, yearMonthCodeDayFieldNamesWithEraAlpha);
+	let mergedFields = mergeCalendarFields(calendar, inputFields, extraFields);
+	return mergedFields = readAndRefineBagFields(mergedFields, mergedFieldNames, dateFieldRefiners, []), createPlainDateFromFields(calendar, mergedFields);
+}
+function epochMilliToInstant(epochMilli) {
+	return createEpochNanoSlots(checkEpochNanoInBounds(BigInt(toStrictInteger(epochMilli)) * bigNanoInMilli));
+}
+function epochNanoToInstant(epochNano) {
+	return createEpochNanoSlots(checkEpochNanoInBounds(toBigInt(epochNano)));
+}
+function applyPlainFormatTimeZone(options) {
+	return options.timeZone = "UTC", ["full", "long"].includes(options.timeStyle) && (options.timeStyle = "medium"), options;
+}
+function applyZonedFormatTimeZone(options, timeZoneId) {
+	return void 0 !== options.timeZone && throwTypeError("Cannot specify TimeZone"), options.timeZone = timeZoneId, options;
+}
+function checkResolvedCalendarCompatible(format, slots, strictCalendarCheck) {
+	const resolvedCalendarId = format.resolvedOptions().calendar;
+	!strictCalendarCheck && slots.calendar === void 0 || getCalendarSlotId(slots.calendar) === resolvedCalendarId || throwRangeError("Mismatching Calendars");
+}
+function createOptionsTransformer(shapeFieldNames, invalidShapeFieldNames, ignoredFieldNames, defaultShapeFields, dateStyleReplacementFields) {
+	const shapeFieldNameSet = new Set(shapeFieldNames);
+	const invalidShapeFieldNameSet = new Set(invalidShapeFieldNames);
+	const ignoredFieldNameSet = new Set(ignoredFieldNames);
+	return (options, allowPartialOverlap) => {
+		const analysis = ((options, shapeFieldNameSet, invalidShapeFieldNameSet, ignoredFieldNameSet) => {
+			const analysis = {
+				dateStyle: void 0,
+				timeStyle: void 0,
+				me: {},
+				pe: {},
+				xe: {},
+				oe: 0,
+				ue: 0
+			};
+			for (const name of Object.keys(options)) {
+				const value = options[name];
+				void 0 === value || ignoredFieldNameSet.has(name) || (shapeFieldNameSet.has(name) ? "dateStyle" === name ? analysis.dateStyle = value : "timeStyle" === name ? analysis.timeStyle = value : analysis.me[name] = value : "era" === name ? analysis.pe[name] = value : invalidShapeFieldNameSet.has(name) ? "dateStyle" === name || "timeStyle" === name ? analysis.ue = 1 : analysis.oe = 1 : analysis.xe[name] = value);
+			}
+			return analysis;
+		})(options, shapeFieldNameSet, invalidShapeFieldNameSet, ignoredFieldNameSet);
+		const hasDateStyle = void 0 !== analysis.dateStyle;
+		const hasTimeStyle = void 0 !== analysis.timeStyle;
+		const hasAnyStyle = hasDateStyle || hasTimeStyle;
+		const hasGranularShapeFields = Object.keys(analysis.me).length > 0;
+		const hasInvalids = analysis.oe || analysis.ue;
+		const hasShapeFields = hasGranularShapeFields || hasDateStyle || hasTimeStyle;
+		const hasModifierFields = Object.keys(analysis.pe).length > 0;
+		const hasStyleConflictFields = hasGranularShapeFields || hasModifierFields || analysis.oe;
+		(!allowPartialOverlap && hasInvalids || allowPartialOverlap && hasInvalids && !hasShapeFields || hasAnyStyle && hasStyleConflictFields) && throwTypeError("Invalid formatting options");
+		const transformedOptions = {};
+		return hasAnyStyle || hasShapeFields || Object.assign(transformedOptions, defaultShapeFields), Object.assign(transformedOptions, analysis.me, analysis.pe, analysis.xe), hasDateStyle && (dateStyleReplacementFields ? Object.assign(transformedOptions, dateStyleReplacementFields[analysis.dateStyle]) : transformedOptions.dateStyle = analysis.dateStyle), hasTimeStyle && (transformedOptions.timeStyle = analysis.timeStyle), transformedOptions;
+	};
+}
+const dateDefaultShapeFields = {
+	year: "numeric",
+	month: "numeric",
+	day: "numeric"
+};
+const timeDefaultShapeFields = {
+	hour: "numeric",
+	minute: "numeric",
+	second: "numeric"
+};
+const dateTimeDefaultShapeFields = /* @__PURE__ */ Object.assign({}, dateDefaultShapeFields, timeDefaultShapeFields);
+const zonedDateTimeDefaultShapeFields = /* @__PURE__ */ Object.assign({}, dateTimeDefaultShapeFields, { timeZoneName: "short" });
+const yearMonthDefaultShapeFields = {
+	year: "numeric",
+	month: "numeric"
+};
+const monthDayDefaultShapeFields = {
+	month: "numeric",
+	day: "numeric"
+};
+const dateShapeFieldNames = [
+	"weekday",
+	"year",
+	"month",
+	"day",
+	"dateStyle"
+];
+const timeShapeFieldNames = [
+	"dayPeriod",
+	"hour",
+	"minute",
+	"second",
+	"fractionalSecondDigits",
+	"timeStyle"
+];
+const dateTimeShapeFieldNames = /* @__PURE__ */ dateShapeFieldNames.concat(timeShapeFieldNames);
+const yearMonthIgnoredFieldNames = /* @__PURE__ */ ["weekday", "day"].concat(timeShapeFieldNames);
+const monthDayIgnoredFieldNames = /* @__PURE__ */ ["weekday", "year"].concat(timeShapeFieldNames);
+const transformInstantOptions = /* @__PURE__ */ createOptionsTransformer(dateTimeShapeFieldNames, [], [], dateTimeDefaultShapeFields);
+const transformZonedOptions = /* @__PURE__ */ createOptionsTransformer(dateTimeShapeFieldNames, [], [], zonedDateTimeDefaultShapeFields);
+const transformDateTimeOptions = /* @__PURE__ */ createOptionsTransformer(dateTimeShapeFieldNames, [], ["timeZoneName"], dateTimeDefaultShapeFields);
+const transformDateOptions = /* @__PURE__ */ createOptionsTransformer(dateShapeFieldNames, timeShapeFieldNames, ["timeZoneName"], dateDefaultShapeFields);
+const transformTimeOptions = /* @__PURE__ */ createOptionsTransformer(timeShapeFieldNames, dateShapeFieldNames, ["timeZoneName", "era"], timeDefaultShapeFields);
+const transformYearMonthOptions = /* @__PURE__ */ createOptionsTransformer([
+	"year",
+	"month",
+	"dateStyle"
+], yearMonthIgnoredFieldNames, ["timeZoneName"], yearMonthDefaultShapeFields, {
+	full: {
+		year: "numeric",
+		month: "long"
+	},
+	long: {
+		year: "numeric",
+		month: "long"
+	},
+	medium: {
+		year: "numeric",
+		month: "short"
+	},
+	short: {
+		year: "2-digit",
+		month: "numeric"
+	}
+});
+const transformMonthDayOptions = /* @__PURE__ */ createOptionsTransformer([
+	"month",
+	"day",
+	"dateStyle"
+], monthDayIgnoredFieldNames, ["timeZoneName", "era"], monthDayDefaultShapeFields, {
+	full: {
+		month: "long",
+		day: "numeric"
+	},
+	long: {
+		month: "long",
+		day: "numeric"
+	},
+	medium: {
+		month: "short",
+		day: "numeric"
+	},
+	short: {
+		month: "numeric",
+		day: "numeric"
+	}
+});
+function zonedDateTimeWithPlainTime(zonedDateTimeSlots, plainTimeFields) {
+	const { timeZone } = zonedDateTimeSlots;
+	const isoDateTime = zonedEpochSlotsToIso(zonedDateTimeSlots);
+	const { offsetNanoseconds } = isoDateTime;
+	const time = plainTimeFields || timeFieldDefaults;
+	let epochNano;
+	return epochNano = plainTimeFields ? getMatchingInstantFor(timeZone, combineDateAndTime(isoDateTime, time), offsetNanoseconds, 2) : getStartOfDayInstantFor(timeZone, combineDateAndTime(isoDateTime, time)), createZonedEpochNanoSlots(epochNano, timeZone, zonedDateTimeSlots.calendar);
+}
+function getCurrentIsoDateTime(timeZone) {
+	const epochNano = getCurrentEpochNano();
+	const offsetNano = timeZone.C(epochNano);
+	return epochNanoToIsoDateTime(epochNano + BigInt(offsetNano));
+}
+function getCurrentEpochNano() {
+	return BigInt(Date.now()) * bigNanoInMilli;
+}
+function getCurrentTimeZoneId() {
+	return new RawDateTimeFormat().resolvedOptions().timeZone;
+}
+//#endregion
+exports.RawDateTimeFormat = RawDateTimeFormat;
+exports.absDuration = absDuration;
+exports.addDurations = addDurations;
+exports.applyPlainFormatTimeZone = applyPlainFormatTimeZone;
+exports.applyZonedFormatTimeZone = applyZonedFormatTimeZone;
+exports.bigNanoInMilli = bigNanoInMilli;
+exports.checkEpochNanoInBounds = checkEpochNanoInBounds;
+exports.checkIsoDateInBounds = checkIsoDateInBounds;
+exports.checkIsoDateTimeInBounds = checkIsoDateTimeInBounds;
+exports.checkIsoYearMonthInBounds = checkIsoYearMonthInBounds;
+exports.checkResolvedCalendarCompatible = checkResolvedCalendarCompatible;
+exports.combineDateAndTime = combineDateAndTime;
+exports.compareDurations = compareDurations;
+exports.compareInstants = compareInstants;
+exports.compareIsoDateFields = compareIsoDateFields;
+exports.compareIsoDateTimeFields = compareIsoDateTimeFields;
+exports.compareTimeFields = compareTimeFields;
+exports.compareZonedDateTimes = compareZonedDateTimes;
+exports.computeBigNanoInc = computeBigNanoInc;
+exports.computeCalendarDateFields = computeCalendarDateFields;
+exports.computeCalendarDayOfYear = computeCalendarDayOfYear;
+exports.computeCalendarDaysInMonth = computeCalendarDaysInMonth;
+exports.computeCalendarDaysInYear = computeCalendarDaysInYear;
+exports.computeCalendarEraFields = computeCalendarEraFields;
+exports.computeCalendarInLeapYear = computeCalendarInLeapYear;
+exports.computeCalendarMonthCode = computeCalendarMonthCode;
+exports.computeCalendarMonthsInYear = computeCalendarMonthsInYear;
+exports.computeCalendarWeekOfYear = computeCalendarWeekOfYear;
+exports.computeCalendarYearOfWeek = computeCalendarYearOfWeek;
+exports.computeIsoDayOfWeek = computeIsoDayOfWeek;
+exports.computeNanoInc = computeNanoInc;
+exports.computeZonedHoursInDay = computeZonedHoursInDay;
+exports.computeZonedStartOfDay = computeZonedStartOfDay;
+exports.convertPlainMonthDayToDate = convertPlainMonthDayToDate;
+exports.convertPlainYearMonthToDate = convertPlainYearMonthToDate;
+exports.convertToPlainMonthDay = convertToPlainMonthDay;
+exports.convertToPlainYearMonth = convertToPlainYearMonth;
+exports.createDateSlots = createDateSlots;
+exports.createDateTimeSlots = createDateTimeSlots;
+exports.createDurationSlots = createDurationSlots;
+exports.createEpochNanoSlots = createEpochNanoSlots;
+exports.createNameDescriptors = createNameDescriptors;
+exports.createPlainDateTimeFromRefinedFields = createPlainDateTimeFromRefinedFields;
+exports.createPropDescriptors = createPropDescriptors;
+exports.createPropGetters = createPropGetters;
+exports.createStringTagDescriptors = createStringTagDescriptors;
+exports.createTimeSlots = createTimeSlots;
+exports.createZonedEpochNanoSlots = createZonedEpochNanoSlots;
+exports.diffInstants = diffInstants;
+exports.diffPlainDateTimes = diffPlainDateTimes;
+exports.diffPlainDates = diffPlainDates;
+exports.diffPlainTimes = diffPlainTimes;
+exports.diffPlainYearMonth = diffPlainYearMonth;
+exports.diffZonedDateTimes = diffZonedDateTimes;
+exports.durationGetters = durationGetters;
+exports.epochMilliToInstant = epochMilliToInstant;
+exports.epochNanoToInstant = epochNanoToInstant;
+exports.exoticCalendarRequired = exoticCalendarRequired;
+exports.forbiddenValueOf = forbiddenValueOf;
+exports.formatDurationIso = formatDurationIso;
+exports.formatInstantIso = formatInstantIso;
+exports.formatOffsetNano = formatOffsetNano;
+exports.formatPlainDateIso = formatPlainDateIso;
+exports.formatPlainDateTimeIso = formatPlainDateTimeIso;
+exports.formatPlainMonthDayIso = formatPlainMonthDayIso;
+exports.formatPlainTimeIso = formatPlainTimeIso;
+exports.formatPlainYearMonthIso = formatPlainYearMonthIso;
+exports.formatZonedDateTimeIso = formatZonedDateTimeIso;
+exports.getCalendarSlotId = getCalendarSlotId;
+exports.getCommonCalendar = getCommonCalendar;
+exports.getCurrentEpochNano = getCurrentEpochNano;
+exports.getCurrentIsoDateTime = getCurrentIsoDateTime;
+exports.getCurrentTimeZoneId = getCurrentTimeZoneId;
+exports.getEpochMilli = getEpochMilli;
+exports.getEpochNano = getEpochNano;
+exports.getTimeZoneTransitionEpochNanoseconds = getTimeZoneTransitionEpochNanoseconds;
+exports.getZonedTimeZoneId = getZonedTimeZoneId;
+exports.gregoryCalendarId = gregoryCalendarId;
+exports.instantToZonedDateTime = instantToZonedDateTime;
+exports.instantsEqual = instantsEqual;
+exports.invalidBag = invalidBag;
+exports.invalidCalendar = invalidCalendar;
+exports.invalidCallingContext = invalidCallingContext;
+exports.invalidTimeZone = invalidTimeZone;
+exports.isObjectLike = isObjectLike;
+exports.isoCalendarId = isoCalendarId;
+exports.isoDateTimeToEpochMilli = isoDateTimeToEpochMilli;
+exports.isoDateToEpochMilli = isoDateToEpochMilli;
+exports.isoEpochFirstLeapYear = isoEpochFirstLeapYear;
+exports.mapProps = mapProps;
+exports.mergeDurationFields = mergeDurationFields;
+exports.mergePlainDateFields = mergePlainDateFields;
+exports.mergePlainDateTimeFields = mergePlainDateTimeFields;
+exports.mergePlainMonthDayFields = mergePlainMonthDayFields;
+exports.mergePlainTimeFields = mergePlainTimeFields;
+exports.mergePlainYearMonthFields = mergePlainYearMonthFields;
+exports.mergeZonedDateTimeFields = mergeZonedDateTimeFields;
+exports.moveDate = moveDate;
+exports.moveDateTime = moveDateTime;
+exports.moveEpochNano = moveEpochNano;
+exports.moveTime = moveTime;
+exports.moveYearMonth = moveYearMonth;
+exports.moveZonedEpochSlots = moveZonedEpochSlots;
+exports.negateDuration = negateDuration;
+exports.negateDurationFields = negateDurationFields;
+exports.noop = noop;
+exports.parseCalendarId = parseCalendarId;
+exports.parseDuration = parseDuration;
+exports.parseInstant = parseInstant;
+exports.parsePlainDate = parsePlainDate;
+exports.parsePlainDateTime = parsePlainDateTime;
+exports.parsePlainMonthDay = parsePlainMonthDay;
+exports.parsePlainTime = parsePlainTime;
+exports.parsePlainYearMonth = parsePlainYearMonth;
+exports.parseRelativeToSlots = parseRelativeToSlots;
+exports.parseTimeZoneId = parseTimeZoneId;
+exports.parseZonedDateTime = parseZonedDateTime;
+exports.plainDateTimeToZonedDateTime = plainDateTimeToZonedDateTime;
+exports.plainDateTimesEqual = plainDateTimesEqual;
+exports.plainDateToZonedDateTime = plainDateToZonedDateTime;
+exports.plainDatesEqual = plainDatesEqual;
+exports.plainMonthDaysEqual = plainMonthDaysEqual;
+exports.plainTimesEqual = plainTimesEqual;
+exports.plainYearMonthsEqual = plainYearMonthsEqual;
+exports.queryTimeZone = queryTimeZone;
+exports.refineDurationObjectLike = refineDurationObjectLike;
+exports.refineMaybeZonedDateTimeObjectLike = refineMaybeZonedDateTimeObjectLike;
+exports.refineOverflowOptions = refineOverflowOptions;
+exports.refinePlainDateObjectLike = refinePlainDateObjectLike;
+exports.refinePlainDateTimeObjectLike = refinePlainDateTimeObjectLike;
+exports.refinePlainMonthDayObjectLike = refinePlainMonthDayObjectLike;
+exports.refinePlainTimeObjectLike = refinePlainTimeObjectLike;
+exports.refinePlainYearMonthObjectLike = refinePlainYearMonthObjectLike;
+exports.refineRoundingOptions = refineRoundingOptions;
+exports.refineTimeZoneId = refineTimeZoneId;
+exports.refineZonedDateTimeObjectLike = refineZonedDateTimeObjectLike;
+exports.refineZonedFieldOptions = refineZonedFieldOptions;
+exports.requireNumberIsInteger = requireNumberIsInteger;
+exports.requireString = requireString;
+exports.resolveTimeZoneId = resolveTimeZoneId;
+exports.roundBigNanoToDayOriginInc = roundBigNanoToDayOriginInc;
+exports.roundDateTimeToNano = roundDateTimeToNano;
+exports.roundDuration = roundDuration;
+exports.roundTimeToNano = roundTimeToNano;
+exports.roundZonedEpochSlotsToUnit = roundZonedEpochSlotsToUnit;
+exports.throwRangeError = throwRangeError;
+exports.throwTypeError = throwTypeError;
+exports.timeFieldDefaults = timeFieldDefaults;
+exports.timeFieldsToMilli = timeFieldsToMilli;
+exports.timeGetters = timeGetters;
+exports.toBigInt = toBigInt;
+exports.toStrictInteger = toStrictInteger;
+exports.totalDuration = totalDuration;
+exports.transformDateOptions = transformDateOptions;
+exports.transformDateTimeOptions = transformDateTimeOptions;
+exports.transformInstantOptions = transformInstantOptions;
+exports.transformMonthDayOptions = transformMonthDayOptions;
+exports.transformTimeOptions = transformTimeOptions;
+exports.transformYearMonthOptions = transformYearMonthOptions;
+exports.transformZonedOptions = transformZonedOptions;
+exports.validateDurationFields = validateDurationFields;
+exports.validateIsoDateFields = validateIsoDateFields;
+exports.validateIsoDateTimeFields = validateIsoDateTimeFields;
+exports.validateTimeFields = validateTimeFields;
+exports.zonedDateTimeToInstant = zonedDateTimeToInstant;
+exports.zonedDateTimeToPlainDate = zonedDateTimeToPlainDate;
+exports.zonedDateTimeToPlainDateTime = zonedDateTimeToPlainDateTime;
+exports.zonedDateTimeToPlainTime = zonedDateTimeToPlainTime;
+exports.zonedDateTimeWithPlainTime = zonedDateTimeWithPlainTime;
+exports.zonedDateTimesEqual = zonedDateTimesEqual;
+exports.zonedEpochSlotsToIso = zonedEpochSlotsToIso;