@hebcal/core 6.9.3 → 6.10.0

package/dist/bundle.js

@@ -1,9 +1,9 @@
-/*! @hebcal/core v6.9.3, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+/*! @hebcal/core v6.10.0, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
 var hebcal = (function (exports) {
 'use strict';
 
 /** DO NOT EDIT THIS AUTO-GENERATED FILE! */
-const version = '6.9.3';
+const version = '6.10.0';
 
 /*! @hebcal/hdate v0.22.8, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
 /** @private */
@@ -2487,6 +2487,13 @@ const flags = {
     /** BeHaB fast days on Monday, Thursday and Monday after Pesach and Sukkot */
     BEHAB: 0x10000000,
 };
+const flagEntries = Object.entries(flags);
+function flagBit(name) {
+    if (!Object.hasOwn(flags, name)) {
+        throw new RangeError(`Unknown flag name: ${String(name)}`);
+    }
+    return flags[name];
+}
 const flagToCategory = [
     [flags.MAJOR_FAST, 'holiday', 'major', 'fast'],
     [flags.CHANUKAH_CANDLES, 'holiday', 'minor'],
@@ -2567,10 +2574,62 @@ class Event {
     }
     /**
      * Bitmask of optional event flags. See {@link flags}
+     * @deprecated Use {@link Event.hasFlag} to test for a flag, or
+     * {@link Event.flagNames} to list them. Code that genuinely needs the
+     * raw bitmask can read {@link Event.mask}.
      */
     getFlags() {
         return this.mask;
     }
+    /**
+     * Does this event have the given flag?
+     *
+     * A readable alternative to testing the bitmask with `&`.
+     * @example
+     * import {Event, HDate, flags} from '@hebcal/core';
+     * const ev = new Event(new HDate(7, 'Sivan', 5749), 'Shavuot II',
+     *   flags.CHAG | flags.CHUL_ONLY);
+     * ev.hasFlag('CHAG');        // true
+     * ev.hasFlag('CHUL_ONLY');   // true
+     * ev.hasFlag('MINOR_FAST');  // false
+     * @param name flag name, one of the keys of {@link flags}
+     * @throws {RangeError} if `name` is not a key of {@link flags}
+     */
+    hasFlag(name) {
+        return (this.mask & flagBit(name)) !== 0;
+    }
+    /**
+     * Does this event have at least one of the given flags?
+     *
+     * Returns `false` when called with no arguments.
+     * @example
+     * import {Event, HDate, flags} from '@hebcal/core';
+     * const ev = new Event(new HDate(10, 'Tishrei', 5784), 'Yom Kippur',
+     *   flags.CHAG | flags.MAJOR_FAST);
+     * ev.hasAnyFlag('MAJOR_FAST', 'MINOR_FAST');  // true
+     * ev.hasAnyFlag('ROSH_CHODESH', 'MINOR_FAST'); // false
+     * @param names flag names, each one of the keys of {@link flags}
+     * @throws {RangeError} if any name is not a key of {@link flags}
+     */
+    hasAnyFlag(...names) {
+        let bits = 0;
+        for (const name of names) {
+            bits |= flagBit(name);
+        }
+        return (this.mask & bits) !== 0;
+    }
+    /**
+     * Names of all {@link flags} set on this event, in ascending bit order.
+     * Returns an empty array for an event with no flags.
+     * @example
+     * import {Event, HDate, flags} from '@hebcal/core';
+     * const ev = new Event(new HDate(7, 'Sivan', 5749), 'Shavuot II',
+     *   flags.CHAG | flags.CHUL_ONLY);
+     * ev.flagNames(); // ['CHAG', 'CHUL_ONLY']
+     */
+    flagNames() {
+        return flagEntries.filter(([, bit]) => this.mask & bit).map(([name]) => name);
+    }
     /**
      * Returns (translated) description of this event
      * @example
@@ -2645,7 +2704,7 @@ class Event {
      * ev2.observedInIsrael(); // true
      */
     observedInIsrael() {
-        return !(this.mask & flags.CHUL_ONLY);
+        return !this.hasFlag('CHUL_ONLY');
     }
     /**
      * Is this event observed in the Diaspora?
@@ -2656,7 +2715,7 @@ class Event {
      * ev2.observedInDiaspora(); // true
      */
     observedInDiaspora() {
-        return !(this.mask & flags.IL_ONLY);
+        return !this.hasFlag('IL_ONLY');
     }
     /**
      * Is this event observed in Israel/Diaspora?
@@ -2687,7 +2746,7 @@ class Event {
      *   .getCategories(); // ['roshchodesh']
      */
     getCategories() {
-        const mask = this.getFlags();
+        const mask = this.mask;
         for (const attrs of flagToCategory) {
             const attr0 = attrs[0];
             if (mask & attr0) {
@@ -2829,6 +2888,259 @@ function requireObjectLike(arg) {
     return arg;
 }
 
+function normalizeOptionsOrString(options, optionName) {
+  return "string" == typeof options ? ((optionName, optionVal) => {
+    const res = Object.create(null);
+    return res[optionName] = optionVal, res;
+  })(optionName, options) : 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, roundHalfFloor, Math.ceil, roundHalfCeil, Math.trunc, roundHalfTrunc, roundExpand, roundHalfExpand, roundHalfEven ];
+
+const directionMap = {
+  previous: -1,
+  next: 1
+};
+
+function coerceRoundingIncInteger(options) {
+  const roundingInc = options.roundingIncrement;
+  return void 0 === roundingInc ? 1 : 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 = durationFieldNamesAsc.indexOf(unitStr)), unit < 0 && 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(flippedSmallestLargestUnit);
+}
+
+function refineDiffOptions(roundingModeInvert, options, defaultLargestUnit, maxUnit = 9, minUnit = 0, defaultRoundingMode = 4) {
+  options = 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 refineDurationRoundOptions(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(missingSmallestLargestUnit), 
+  null == smallestUnit && (smallestUnit = 0), null == largestUnit && (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 ];
+}
+
+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 refineTotalOptions(options, refineRelativeTo) {
+  const relativeToInternals = refineRelativeTo((options = normalizeOptionsOrString(options, "unit")).relativeTo);
+  let totalUnit = coerceTotalUnit(options);
+  return totalUnit = requirePropDefined("unit", totalUnit), [ totalUnit, relativeToInternals ];
+}
+
+function refineOverflowOptions(options) {
+  return void 0 === options ? 0 : coerceOverflow(requireObjectLike(options));
+}
+
+function refineZonedFieldOptions(options, defaultOffsetDisambig = 0) {
+  options = normalizeOptions(options);
+  const epochDisambig = coerceEpochDisambig(options);
+  const offsetDisambig = coerceOffsetDisambig(options, defaultOffsetDisambig);
+  return [ coerceOverflow(options), offsetDisambig, epochDisambig ];
+}
+
+function refineEpochDisambigOptions(options) {
+  return coerceEpochDisambig(normalizeOptions(options));
+}
+
+function refineTimeDisplayTuple(options, maxSmallestUnit = 4) {
+  const subsecDigits = coerceFractionalSecondDigits(options);
+  const roundingMode = coerceRoundingMode(options, 4);
+  const smallestUnit = coerceSmallestUnit(options);
+  return [ roundingMode, ...resolveSmallestUnitAndSubsecDigits(validateUnitRange(smallestUnitStr, smallestUnit, 0, maxSmallestUnit), subsecDigits) ];
+}
+
+function refineDateTimeDisplayOptions(options) {
+  return options = normalizeOptions(options), [ coerceCalendarDisplay(options), ...refineTimeDisplayTuple(options) ];
+}
+
+function refineDateDisplayOptions(options) {
+  return coerceCalendarDisplay(normalizeOptions(options));
+}
+
+function refineTimeDisplayOptions(options, maxSmallestUnit) {
+  return refineTimeDisplayTuple(normalizeOptions(options), maxSmallestUnit);
+}
+
+function refineZonedDateTimeDisplayOptions(options) {
+  options = 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) ];
+}
+
+function refineInstantDisplayOptions(options) {
+  const subsecDigits = coerceFractionalSecondDigits(options = normalizeOptions(options));
+  const roundingMode = coerceRoundingMode(options, 4);
+  const smallestUnit = coerceSmallestUnit(options);
+  return [ options.timeZone, roundingMode, ...resolveSmallestUnitAndSubsecDigits(validateUnitRange(smallestUnitStr, smallestUnit, 0, 4), subsecDigits) ];
+}
+
+function resolveSmallestUnitAndSubsecDigits(smallestUnit, subsecDigits) {
+  return null != smallestUnit ? [ unitNanoMap[smallestUnit], smallestUnit < 4 ? 9 - 3 * smallestUnit : -1 ] : [ void 0 === subsecDigits ? 1 : 10 ** (9 - subsecDigits), subsecDigits ];
+}
+
+function refineDirectionOptions(options) {
+  const normalizedOptions = normalizeOptionsOrString(options, "direction");
+  const res = coerceDirection(normalizedOptions, 0);
+  return res || throwRangeError(invalidEntity("direction", res)), res;
+}
+
 const invalidEntity = invalidEntity$1;
 
 const missingField = fieldName => `Missing ${fieldName}`;
@@ -2855,6 +3167,10 @@ const invalidTimeZone = calendarId => invalidEntity$1("TimeZone", calendarId);
 
 const outOfBoundsDate = "Out-of-bounds date";
 
+const missingSmallestLargestUnit = "Required smallestUnit or largestUnit";
+
+const flippedSmallestLargestUnit = "smallestUnit > largestUnit";
+
 const failedParse = s => `Cannot parse: ${s}`;
 
 const invalidSubstring = substring => `Invalid substring: ${substring}`;
@@ -3040,21 +3356,45 @@ function modTrunc(num, divisor) {
   return num % divisor || 0;
 }
 
+function roundExpand(num) {
+  return num < 0 ? Math.floor(num) : Math.ceil(num);
+}
+
 function fabricateNearHalfFraction(halfCompare, sign = 1) {
   return sign * (.5 + halfCompare / 5);
 }
 
-function hasHalf(num) {
-  return .5 === Math.abs(num % 1);
+function roundHalfExpand(num) {
+  return Math.sign(num) * Math.round(Math.abs(num)) || 0;
 }
 
-const isoCalendarId = "iso8601";
+function roundHalfFloor(num) {
+  return hasHalf(num) ? Math.floor(num) : Math.round(num);
+}
 
-const gregoryCalendarId = "gregory";
+function roundHalfCeil(num) {
+  return hasHalf(num) ? Math.ceil(num) : Math.round(num);
+}
 
-const gregoryEraOrigins = {
-  "bce": -1,
-  "ce": 0
+function roundHalfTrunc(num) {
+  return hasHalf(num) ? Math.trunc(num) || 0 : Math.round(num);
+}
+
+function roundHalfEven(num) {
+  return hasHalf(num) ? (num = Math.trunc(num) || 0) + num % 2 : Math.round(num);
+}
+
+function hasHalf(num) {
+  return .5 === Math.abs(num % 1);
+}
+
+const isoCalendarId = "iso8601";
+
+const gregoryCalendarId = "gregory";
+
+const gregoryEraOrigins = {
+  "bce": -1,
+  "ce": 0
 };
 
 function normalizeEraName(era) {
@@ -3255,6 +3595,10 @@ function epochNanoToSecMod(epochNano) {
   return [ Number(epochSec), Number(nano) ];
 }
 
+function epochNanoToMilli(epochNano) {
+  return Number(divFloorBigInt(epochNano, bigNanoInMilli));
+}
+
 function isoDateTimeToEpochNano(isoDateTime) {
   return isoDateToEpochNano(isoDateTime) + BigInt(timeFieldsToNano(isoDateTime));
 }
@@ -3272,10 +3616,10 @@ function isoDateToEpochMilli(isoDate) {
 }
 
 function isoDateToEpochDays(isoDate) {
-  return isoArgsToEpochDays(isoDate.year, isoDate.month, isoDate.day);
+  return isoPartsToEpochDays(isoDate.year, isoDate.month, isoDate.day);
 }
 
-function isoArgsToEpochDays(isoYear, isoMonth = 1, isoDay = 1) {
+function isoPartsToEpochDays(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;
@@ -3355,23 +3699,23 @@ 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 computeIsoDayOfWeek(isoDate) {
+  return modFloor(isoPartsToEpochDays(isoDate.year, isoDate.month, isoDate.day) + 4, 7) || 7;
 }
 
-function computeIsoDayOfYear(isoDateFields) {
-  return isoArgsToEpochDays(isoDateFields.year, isoDateFields.month, isoDateFields.day) - isoArgsToEpochDays(isoDateFields.year) + 1;
+function computeIsoDayOfYear(isoDate) {
+  return isoPartsToEpochDays(isoDate.year, isoDate.month, isoDate.day) - isoPartsToEpochDays(isoDate.year) + 1;
 }
 
-function computeIsoWeekFields(isoDateFields) {
-  let yearOfWeek = isoDateFields.year;
-  let weekOfYear = Math.floor((computeIsoDayOfYear(isoDateFields) - computeIsoDayOfWeek(isoDateFields) + 10) / 7);
+function computeIsoWeekFields(isoDate) {
+  let yearOfWeek = isoDate.year;
+  let weekOfYear = Math.floor((computeIsoDayOfYear(isoDate) - computeIsoDayOfWeek(isoDate) + 10) / 7);
   let weeksInYear = computeIsoWeeksInYear(yearOfWeek);
   return weekOfYear < 1 ? weekOfYear = weeksInYear = computeIsoWeeksInYear(--yearOfWeek) : weekOfYear > weeksInYear && (weekOfYear = 1, 
   weeksInYear = computeIsoWeeksInYear(++yearOfWeek)), {
     weekOfYear: weekOfYear,
     yearOfWeek: yearOfWeek,
-    Be: weeksInYear
+    De: weeksInYear
   };
 }
 
@@ -3417,11 +3761,11 @@ function constrainIsoDateFields(isoDate, overflow) {
 }
 
 function computeCalendarDateFields(calendar, isoDate) {
-  return calendar ? calendar.ae(isoDate) : isoDate;
+  return calendar ? calendar.de(isoDate) : isoDate;
 }
 
 function computeCalendarMonthCodeParts(calendar, year, month) {
-  return calendar ? calendar.L(year, month) : computeIsoMonthCodeParts(month);
+  return calendar ? calendar.N(year, month) : computeIsoMonthCodeParts(month);
 }
 
 function computeCalendarEraFields(calendar, isoDate) {
@@ -3429,7 +3773,7 @@ function computeCalendarEraFields(calendar, isoDate) {
 }
 
 function computeCalendarIsoFieldsFromParts(calendar, year, month, day) {
-  return calendar ? calendar.de(year, month, day) : computeIsoFieldsFromParts(year, month, day);
+  return calendar ? calendar.fe(year, month, day) : computeIsoFieldsFromParts(year, month, day);
 }
 
 function computeCalendarMonthsInYearForYear(calendar, year) {
@@ -3522,8 +3866,17 @@ function toString(arg) {
   String(arg);
 }
 
-function toStringViaPrimitive(arg, entityName) {
-  return isObjectLike$1(arg) ? String(arg) : requireString(arg, entityName);
+function toPrimitiveWithStringHint(arg) {
+  if (!isObjectLike$1(arg)) {
+    return arg;
+  }
+  const exoticToPrimitive = arg[Symbol.toPrimitive];
+  if (null != exoticToPrimitive) {
+    "function" != typeof exoticToPrimitive && throwTypeError();
+    const primitive = Reflect.apply(exoticToPrimitive, arg, [ "string" ]);
+    return isObjectLike$1(primitive) && throwTypeError(), primitive;
+  }
+  return Date.prototype[Symbol.toPrimitive].call(arg, "string");
 }
 
 function toBigInt(bi) {
@@ -3535,193 +3888,10 @@ function toStrictInteger(arg, entityName) {
   return requireNumberIsInteger(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) : 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 : 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 = durationFieldNamesAsc.indexOf(unitStr)), unit < 0 && 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 = 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(requireObjectLike(options));
-}
-
-function refineZonedFieldOptions(options, defaultOffsetDisambig = 0) {
-  options = 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;
@@ -3737,18 +3907,18 @@ function checkIsoYearMonthInBounds(isoDate) {
 }
 
 function checkIsoDateInBounds(isoDate, allowPlainDateLowerEdge = 1) {
-  return checkIsoDateEpochNanoInBounds(isoDateToEpochNano(isoDate), allowPlainDateLowerEdge), 
+  const epochNano = isoDateToEpochNano(isoDate);
+  return (epochNano < (allowPlainDateLowerEdge ? plainDateEpochNanoMin : epochNanoMin) || epochNano > epochNanoMax) && throwRangeError(outOfBoundsDate), 
   isoDate;
 }
 
 function checkIsoDateTimeInBounds(isoDateTime) {
-  const epochNano = isoDateToEpochNano(isoDateTime);
-  return checkIsoDateEpochNanoInBounds(epochNano), epochNano !== plainDateEpochNanoMin || timeFieldsToNano(isoDateTime) || throwRangeError(outOfBoundsDate), 
-  isoDateTime;
+  return checkIsoDateTimeEpochNanoInBounds(isoDateTimeToEpochNano(isoDateTime)), isoDateTime;
 }
 
-function checkIsoDateEpochNanoInBounds(epochNano, allowPlainDateLowerEdge = 1) {
-  (epochNano < (allowPlainDateLowerEdge ? plainDateEpochNanoMin : epochNanoMin) || epochNano > epochNanoMax) && throwRangeError(outOfBoundsDate);
+function checkIsoDateTimeEpochNanoInBounds(epochNano) {
+  return (epochNano <= plainDateEpochNanoMin || epochNano >= epochNanoMax + bigNanoInUtcDay) && throwRangeError(outOfBoundsDate), 
+  epochNano;
 }
 
 function checkEpochNanoInBounds(epochNano) {
@@ -3760,108 +3930,41 @@ 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: calendar,
-    timeZone: timeZone,
-    epochNanoseconds: epochNano
-  };
-}
-
-function createDateTimeSlots(isoDateTime, calendar) {
-  return pluckProps(timeFieldNamesAsc, isoDateTime, createDateSlots(isoDateTime, calendar));
-}
-
-function createDateSlots(isoDate, calendar) {
-  return pluckProps(calendarDateFieldNamesAsc, isoDate, {
-    calendar: 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 roundNumberToInc(num, roundingInc, roundingMode) {
+  return roundWithMode(num / roundingInc, roundingMode) * roundingInc;
 }
 
-function getEpochNano(slots) {
-  return slots.epochNanoseconds;
+function roundWithMode(num, roundingMode) {
+  return roundingModeFuncs[roundingMode](num);
 }
 
-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);
-  const maxUnit = Math.max(totalUnit, maxDurationUnit);
-  const isZoned = relativeToSlots && isZonedEpochSlots(relativeToSlots);
-  if (!relativeToSlots && isUniformUnit(maxUnit, isZoned)) {
-    return totalDayTimeDuration(slots, totalUnit);
-  }
-  if (relativeToSlots || throwRangeError("Missing relativeTo"), !slots.sign && isUniformUnit(totalUnit, isZoned)) {
-    return 0;
-  }
-  const [balancedDuration, endEpochNano, relativeOps] = spanRelativeDuration(relativeToSlots, slots, totalUnit);
-  return isUniformUnit(totalUnit, isZoned) ? totalDayTimeDuration(balancedDuration, totalUnit) : totalRelativeDuration(balancedDuration, endEpochNano, totalUnit, relativeOps);
+function totalRelativeUnit(wholeValue, sign, endEpochNano, moveValueToEpochNano) {
+  const unitWindow = clampRelativeUnitValue(wholeValue, sign, moveValueToEpochNano, endEpochNano);
+  return interpolateRelativeUnitWindow(unitWindow, Number(endEpochNano - unitWindow.I) / Number(unitWindow.O - unitWindow.I));
 }
 
-function totalRelativeDuration(durationFields, endEpochNano, totalUnit, relativeOps) {
-  const sign = computeDurationSign(durationFields) || 1;
-  const nudgeWindow = clampRelativeDuration(clearDurationFields(totalUnit, durationFields), totalUnit, sign, relativeOps, endEpochNano);
-  const epochNano0 = nudgeWindow.ee;
-  const epochNano1 = nudgeWindow.te;
-  const denom = Number(epochNano1 - epochNano0);
-  const numerator = Number(endEpochNano - epochNano0);
-  return nudgeWindow.pe[durationFieldNamesAsc[totalUnit]] + numerator / denom * sign;
+function roundRelativeUnitWindow(unitWindow, endEpochNano, roundingInc, roundingMode) {
+  return roundNumberToInc(interpolateRelativeUnitWindow(unitWindow, computeEpochNanoFrac(endEpochNano, unitWindow.I, unitWindow.O)), roundingInc, roundingMode);
 }
 
-function totalDayTimeDuration(durationFields, totalUnit) {
-  return divideBigNanoToExactNumber(durationDayTimeToBigNano(durationFields), unitNanoMap[totalUnit]);
+function clampRelativeUnitValue(startValue, valueDelta, moveValueToEpochNano, epochNanoProgress) {
+  let unitWindow = computeRelativeUnitWindow(startValue, valueDelta, moveValueToEpochNano);
+  return ((epochNanoProgress, epochNano0, epochNano1, sign) => sign > 0 ? epochNano0 <= epochNanoProgress && epochNanoProgress <= epochNano1 : epochNano1 <= epochNanoProgress && epochNanoProgress <= epochNano0)(epochNanoProgress, unitWindow.I, unitWindow.O, Math.sign(valueDelta)) || (unitWindow = computeRelativeUnitWindow(startValue + valueDelta, valueDelta, moveValueToEpochNano)), 
+  unitWindow;
 }
 
-function clampRelativeDuration(durationFields, clampUnit, clampDistance, relativeOps, epochNanoProgress) {
-  const unitName = durationFieldNamesAsc[clampUnit];
-  let startDurationFields = durationFields;
-  let shifted = 0;
-  let window = computeRelativeDurationWindow(startDurationFields, unitName, clampDistance, relativeOps);
-  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.ee, window.te, Math.sign(clampDistance)) && (startDurationFields = {
-    ...durationFields,
-    [unitName]: durationFields[unitName] + clampDistance
-  }, shifted = 1, window = computeRelativeDurationWindow(startDurationFields, unitName, clampDistance, relativeOps)), 
-  {
-    ...window,
-    pe: startDurationFields,
-    Ae: shifted
+function computeRelativeUnitWindow(startValue, valueDelta, moveValueToEpochNano) {
+  const endValue = startValue + valueDelta;
+  return {
+    ve: startValue,
+    qe: endValue,
+    I: moveValueToEpochNano(startValue),
+    O: moveValueToEpochNano(endValue)
   };
 }
 
-function computeRelativeDurationWindow(startDurationFields, unitName, clampDistance, relativeOps) {
-  const endDurationFields = {
-    ...startDurationFields,
-    [unitName]: startDurationFields[unitName] + clampDistance
-  };
-  return {
-    ee: moveRelativeToEpochNano(relativeOps, startDurationFields),
-    te: moveRelativeToEpochNano(relativeOps, endDurationFields),
-    se: endDurationFields
-  };
+function interpolateRelativeUnitWindow(unitWindow, fraction) {
+  return unitWindow.ve + fraction * (unitWindow.qe - unitWindow.ve);
 }
 
 function computeEpochNanoFrac(epochNanoProgress, epochNano0, epochNano1) {
@@ -3876,76 +3979,52 @@ function computeEpochNanoFrac(epochNanoProgress, epochNano0, epochNano1) {
   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: epochNanoseconds} = slots;
-  const {timeZone: timeZone, calendar: calendar} = slots;
-  if (0 === smallestUnit && 1 === roundingInc) {
-    return {
-      epochNanoseconds: epochNanoseconds,
-      timeZone: timeZone,
-      calendar: 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(computeZonedDayRoundFrac(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);
-  }
+function createEpochNanoSlots(epochNano) {
   return {
-    epochNanoseconds: epochNanoseconds,
-    timeZone: timeZone,
-    calendar: calendar
+    epochNanoseconds: epochNano
   };
 }
 
-function computeZonedHoursInDay(slots) {
-  const {timeZone: 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: timeZone, calendar: calendar} = slots;
-  return createZonedEpochNanoSlots(getStartOfDayInstantFor(timeZone, combineDateAndTime(zonedEpochSlotsToIso(slots), timeFieldDefaults)), timeZone, calendar);
+function createZonedEpochNanoSlots(epochNano, timeZone, calendar) {
+  return {
+    calendar: calendar,
+    timeZone: timeZone,
+    epochNanoseconds: epochNano
+  };
 }
 
-function computeZonedDayRoundFrac(epochNano, epochNano0, epochNano1) {
-  return computeEpochNanoFrac(epochNano < epochNano1 ? epochNano : epochNano1 - 1n, epochNano0, epochNano1);
+function createDateTimeSlots(isoDateTime, calendar) {
+  return pluckProps(timeFieldNamesAsc, isoDateTime, createDateSlots(isoDateTime, 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 createDateSlots(isoDate, calendar) {
+  return pluckProps(calendarDateFieldNamesAsc, isoDate, {
+    calendar: calendar
+  });
 }
 
-function roundTimeToNano(timeFields, nanoInc, roundingMode) {
-  return nanoToTimeAndDay(roundNumberToInc(timeFieldsToNano(timeFields), nanoInc, roundingMode));
+function createTimeSlots(time) {
+  return pluckProps(timeFieldNamesAsc, time);
 }
 
-function roundToMinute(offsetNano) {
-  return roundNumberToInc(offsetNano, nanoInMinute, 7);
+function createDurationSlots(durationFields) {
+  return pluckProps(durationFieldNamesAsc, durationFields, {
+    sign: computeDurationSign(durationFields)
+  });
 }
 
-function computeNanoInc(smallestUnit, roundingInc) {
-  return unitNanoMap[smallestUnit] * roundingInc;
+function roundZonedEpochSlotsToUnit(slots, smallestUnit, roundingInc, roundingMode) {
+  return createZonedEpochNanoSlots(6 === smallestUnit ? roundZonedEpochToDay(slots, roundingMode) : roundZonedEpochToTime(slots, smallestUnit, roundingInc, roundingMode), slots.timeZone, slots.calendar);
 }
 
-function computeBigNanoInc(smallestUnit, roundingInc) {
-  return BigInt(unitNanoMap[smallestUnit]) * BigInt(roundingInc);
+function computeZonedHoursInDay(slots) {
+  const [epochNano0, epochNano1] = computeZonedDayEpochInterval(slots);
+  return divideBigNanoToExactNumber(epochNano1 - epochNano0, nanoInHour);
 }
 
-function roundDayTimeDurationByInc(durationFields, nanoInc, roundingMode) {
-  const maxUnit = Math.min(getMaxDurationUnit(durationFields), 6);
-  return nanoToDurationDayTimeFields(roundBigNanoToInc(durationDayTimeToBigNano(durationFields), BigInt(nanoInc), roundingMode), maxUnit);
+function computeZonedStartOfDay(slots) {
+  const {timeZone: timeZone, calendar: calendar} = slots;
+  return createZonedEpochNanoSlots(getStartOfDayInstantFor(timeZone, combineDateAndTime(zonedEpochSlotsToIso(slots), timeFieldDefaults)), timeZone, calendar);
 }
 
 function roundRelativeDuration(durationFields, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode, relativeOps, isZoned) {
@@ -3962,7 +4041,7 @@ function roundRelativeDuration(durationFields, endEpochNano, largestUnit, smalle
       }
       const baseDurationFields = clearDurationFields(currentUnit, durationFields);
       baseDurationFields[durationFieldNamesAsc[currentUnit]] += sign;
-      const thresholdCompare = compareBigInts(endEpochNano, moveRelativeToEpochNano(relativeOps, baseDurationFields));
+      const thresholdCompare = compareBigInts(endEpochNano, moveRelativeMarkerToEpochNano(relativeOps, baseDurationFields));
       if (thresholdCompare && thresholdCompare !== sign) {
         break;
       }
@@ -3973,55 +4052,60 @@ function roundRelativeDuration(durationFields, endEpochNano, largestUnit, smalle
   roundedDurationFields;
 }
 
-function roundBigNanoToInc(bigNano, bigNanoInc, roundingMode) {
-  return roundBigNanoToIncWithTail(bigNano, bigNanoInc, roundingMode, bigNano / bigNanoInc % 2n);
+function roundDayTimeDurationByInc(durationFields, nanoInc, roundingMode) {
+  const maxUnit = Math.min(getMaxDurationUnit(durationFields), 6);
+  return nanoToDurationDayTimeFields(roundBigNanoToInc(durationDayTimeToBigNano(durationFields), BigInt(nanoInc), roundingMode), maxUnit);
 }
 
-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 roundZonedEpochToDay(slots, roundingMode) {
+  const [epochNano0, epochNano1] = computeZonedDayEpochInterval(slots);
+  return roundZonedEpochToBounds(slots.epochNanoseconds, epochNano0, epochNano1, roundingMode);
 }
 
-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 roundZonedEpochToTime(slots, smallestUnit, roundingInc, roundingMode) {
+  if (0 === smallestUnit && 1 === roundingInc) {
+    return slots.epochNanoseconds;
+  }
+  const isoDateTime = zonedEpochSlotsToIso(slots);
+  return getMatchingInstantFor(slots.timeZone, roundDateTimeToInc(isoDateTime, computeNanoInc(smallestUnit, roundingInc), roundingMode), isoDateTime.offsetNanoseconds, 2, 0, 1);
 }
 
-function roundNumberToInc(num, roundingInc, roundingMode) {
-  return roundWithMode(num / roundingInc, roundingMode) * roundingInc;
+function roundDateTimeToInc(isoDateTime, nanoInc, roundingMode) {
+  const [roundedTimeFields, dayDelta] = roundTimeToInc(isoDateTime, nanoInc, roundingMode);
+  const roundedIsoDateTime = combineDateAndTime(moveDateByDays(isoDateTime, dayDelta), roundedTimeFields);
+  return checkIsoDateTimeInBounds(roundedIsoDateTime), roundedIsoDateTime;
 }
 
-function roundWithMode(num, roundingMode) {
-  return roundingModeFuncs[roundingMode](num);
+function roundTimeToInc(timeFields, nanoInc, roundingMode) {
+  return nanoToTimeAndDay(roundNumberToInc(timeFieldsToNano(timeFields), nanoInc, roundingMode));
 }
 
-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 [ {
+function nudgeRelativeDuration(sign, durationFields, endEpochNano, _largestUnit, smallestUnit, roundingInc, roundingMode, relativeOps) {
+  const smallestUnitFieldName = durationFieldNamesAsc[smallestUnit];
+  const baseDurationFields = clearDurationFields(smallestUnit, durationFields);
+  7 === smallestUnit && (durationFields = {
     ...durationFields,
-    ...roundedDayTimeFields
-  }, endEpochNano + nanoDiff, expandedBigUnit ];
+    weeks: durationFields.weeks + Math.trunc(durationFields.days / 7)
+  });
+  const truncedVal = divTrunc(durationFields[smallestUnitFieldName], roundingInc) * roundingInc;
+  const nudgeWindow = clampRelativeUnitValue(truncedVal, roundingInc * sign, value => (baseDurationFields[smallestUnitFieldName] = value, 
+  moveRelativeMarkerToEpochNano(relativeOps, baseDurationFields)), endEpochNano);
+  const roundedVal = roundRelativeUnitWindow(nudgeWindow, endEpochNano, roundingInc, roundingMode);
+  return baseDurationFields[smallestUnitFieldName] = roundedVal, [ baseDurationFields, roundedVal === nudgeWindow.qe ? nudgeWindow.O : nudgeWindow.I, roundedVal !== truncedVal ];
 }
 
 function nudgeZonedTimeDuration(sign, durationFields, endEpochNano, _largestUnit, smallestUnit, roundingInc, roundingMode, relativeOps) {
   const timeNano = Number(durationTimeToBigNano(durationFields));
   const nanoInc = computeNanoInc(smallestUnit, roundingInc);
   let roundedTimeNano = roundNumberToInc(timeNano, nanoInc, roundingMode);
-  const dayWindow = clampRelativeDuration({
+  const dateDurationFields = {
     ...durationFields,
     ...durationTimeFieldDefaults
-  }, 6, sign, relativeOps, endEpochNano);
-  const dayEpochNano0 = dayWindow.ee;
-  const dayEpochNano1 = dayWindow.te;
+  };
+  const dayWindow = clampRelativeUnitValue(dateDurationFields.days, sign, days => (dateDurationFields.days = days, 
+  moveRelativeMarkerToEpochNano(relativeOps, dateDurationFields)), endEpochNano);
+  const dayEpochNano0 = dayWindow.I;
+  const dayEpochNano1 = dayWindow.O;
   const beyondDayNano = roundedTimeNano - Number(dayEpochNano1 - dayEpochNano0);
   let dayDelta = 0;
   beyondDayNano && Math.sign(beyondDayNano) !== sign ? endEpochNano = dayEpochNano0 + BigInt(roundedTimeNano) : (dayDelta += sign, 
@@ -4034,32 +4118,58 @@ function nudgeZonedTimeDuration(sign, durationFields, endEpochNano, _largestUnit
   }, endEpochNano, Boolean(dayDelta) ];
 }
 
-function nudgeRelativeDuration(sign, durationFields, endEpochNano, _largestUnit, smallestUnit, roundingInc, roundingMode, relativeOps) {
-  const smallestUnitFieldName = durationFieldNamesAsc[smallestUnit];
-  const baseDurationFields = clearDurationFields(smallestUnit, durationFields);
-  7 === smallestUnit && (durationFields = {
+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,
-    weeks: durationFields.weeks + Math.trunc(durationFields.days / 7)
-  });
-  const truncedVal = divTrunc(durationFields[smallestUnitFieldName], roundingInc) * roundingInc;
-  baseDurationFields[smallestUnitFieldName] = truncedVal;
-  const nudgeWindow = clampRelativeDuration(baseDurationFields, smallestUnit, roundingInc * sign, relativeOps, endEpochNano);
-  const epochNano0 = nudgeWindow.ee;
-  const epochNano1 = nudgeWindow.te;
-  const frac = computeEpochNanoFrac(endEpochNano, epochNano0, epochNano1);
-  const windowStartVal = nudgeWindow.pe[smallestUnitFieldName];
-  const windowEndVal = nudgeWindow.se[smallestUnitFieldName];
-  const roundedVal = roundNumberToInc(windowStartVal + frac * sign * roundingInc, roundingInc, roundingMode);
-  const roundedToEnd = roundedVal === windowEndVal;
-  return baseDurationFields[smallestUnitFieldName] = roundedVal, [ baseDurationFields, roundedToEnd ? epochNano1 : epochNano0, nudgeWindow.Ae || roundedToEnd ];
-}
-
-function getTimeZoneTransitionEpochNanoseconds(slots, options) {
-  return slots.timeZone.O(slots.epochNanoseconds, (options => {
-    const normalizedOptions = normalizeOptionsOrString(options, "direction");
-    const res = coerceDirection(normalizedOptions, 0);
-    return res || throwRangeError(invalidEntity("direction", res)), res;
-  })(options));
+    ...roundedDayTimeFields
+  }, endEpochNano + nanoDiff, expandedBigUnit ];
+}
+
+function computeZonedDayEpochInterval(slots) {
+  const {timeZone: timeZone} = slots;
+  const isoDateTime0 = combineDateAndTime(zonedEpochSlotsToIso(slots), timeFieldDefaults);
+  const isoDateTime1 = combineDateAndTime(moveDateByDays(isoDateTime0, 1), timeFieldDefaults);
+  return [ getStartOfDayInstantFor(timeZone, isoDateTime0), getStartOfDayInstantFor(timeZone, isoDateTime1) ];
+}
+
+function roundZonedEpochToBounds(epochNano, epochNano0, epochNano1, roundingMode) {
+  return roundWithMode(computeEpochNanoFrac(epochNano < epochNano1 ? epochNano : epochNano1 - 1n, epochNano0, epochNano1), roundingMode) ? epochNano1 : epochNano0;
+}
+
+function roundToMinute(offsetNano) {
+  return roundNumberToInc(offsetNano, nanoInMinute, 7);
+}
+
+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 computeNanoInc(smallestUnit, roundingInc) {
+  return unitNanoMap[smallestUnit] * roundingInc;
+}
+
+function computeBigNanoInc(smallestUnit, roundingInc) {
+  return BigInt(unitNanoMap[smallestUnit]) * BigInt(roundingInc);
 }
 
 const zonedEpochSlotsToIso = /*@__PURE__*/ memoize(_zonedEpochSlotsToIso, WeakMap);
@@ -4078,7 +4188,7 @@ function getMatchingInstantFor(timeZone, isoDateTime, offsetNano, offsetDisambig
     return isoDateTimeAndOffsetToEpochNano(isoDateTime, offsetNano);
   }
   2 !== offsetDisambig && 0 !== offsetDisambig || checkIsoDateInBounds(isoDateTime, 0);
-  const possibleEpochNanos = timeZone.N(isoDateTime);
+  const possibleEpochNanos = timeZone.R(isoDateTime);
   if (void 0 !== offsetNano && 3 !== offsetDisambig) {
     const matchingEpochNano = ((possibleEpochNanos, isoDateTime, offsetNano, fuzzy) => {
       const zonedEpochNano = isoDateTimeToEpochNano(isoDateTime);
@@ -4098,7 +4208,7 @@ function getMatchingInstantFor(timeZone, isoDateTime, offsetNano, offsetDisambig
   return hasZ ? isoDateTimeToEpochNano(isoDateTime) : getSingleInstantFor(timeZone, isoDateTime, epochDisambig, possibleEpochNanos);
 }
 
-function getSingleInstantFor(timeZone, isoDateTime, disambig = 0, possibleEpochNanos = timeZone.N(isoDateTime)) {
+function getSingleInstantFor(timeZone, isoDateTime, disambig = 0, possibleEpochNanos = timeZone.R(isoDateTime)) {
   if (1 === possibleEpochNanos.length) {
     return possibleEpochNanos[0];
   }
@@ -4112,32 +4222,25 @@ function getSingleInstantFor(timeZone, isoDateTime, disambig = 0, possibleEpochN
     gapNano))(timeZone.B(zonedEpochNano + bigNanoInUtcDay) - startOffsetNano);
   })(timeZone, zonedEpochNano);
   const shiftedIsoDateTime = epochNanoToIsoDateTime(zonedEpochNano + BigInt(gapNano * (2 === disambig ? -1 : 1)));
-  return (possibleEpochNanos = timeZone.N(shiftedIsoDateTime))[2 === disambig ? 0 : possibleEpochNanos.length - 1];
+  return (possibleEpochNanos = timeZone.R(shiftedIsoDateTime))[2 === disambig ? 0 : possibleEpochNanos.length - 1];
 }
 
 function getStartOfDayInstantFor(timeZone, isoDateTime) {
-  const possibleEpochNanos = timeZone.N(isoDateTime);
+  const possibleEpochNanos = timeZone.R(isoDateTime);
   if (possibleEpochNanos.length) {
     return possibleEpochNanos[0];
   }
   const zonedEpochNanoDayBefore = isoDateTimeToEpochNano(isoDateTime) - bigNanoInUtcDay;
-  return timeZone.O(zonedEpochNanoDayBefore, 1);
+  return timeZone.C(zonedEpochNanoDayBefore, 1);
 }
 
-function moveYearMonth(doSubtract, calendar, isoDateFields, durationSlots, options) {
-  const overflow = refineOverflowOptions(options);
-  durationSlots.sign && getMaxDurationUnit(durationSlots) < 8 && throwRangeError("Cannot use small units");
-  const startOfMonthFields = checkIsoDateInBounds(moveToStartOfMonth(calendar, isoDateFields));
-  return moveToStartOfMonth(calendar, dateAddWithOverflow(calendar, startOfMonthFields, 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 moveYearMonth(calendar, isoDate, durationSlots, overflow = 0) {
+  computeDurationSign(durationSlots) && getMaxDurationUnit(durationSlots) < 8 && throwRangeError("Cannot use small units");
+  const first = checkIsoDateInBounds(moveToStartOfMonth(calendar, isoDate));
+  return moveToStartOfMonth(calendar, moveDate(calendar, first, durationSlots, overflow));
 }
 
-function moveZonedEpochSlots(slots, durationFields, options) {
+function moveZonedEpochSlots(slots, durationFields, overflow = 0) {
   const {calendar: calendar, epochNanoseconds: epochNano, timeZone: timeZone} = slots;
   const timeOnlyNano = durationTimeToBigNano(durationFields);
   let movedEpochNano = epochNano;
@@ -4146,9 +4249,9 @@ function moveZonedEpochSlots(slots, durationFields, options) {
     movedEpochNano = getSingleInstantFor(timeZone, combineDateAndTime(moveDate(calendar, isoDateTime, {
       ...durationFields,
       ...durationTimeFieldDefaults
-    }, options), isoDateTime)) + timeOnlyNano;
+    }, overflow), isoDateTime)) + timeOnlyNano;
   } else {
-    movedEpochNano += timeOnlyNano, refineOverflowOptions(options);
+    movedEpochNano += timeOnlyNano;
   }
   return {
     ...slots,
@@ -4156,77 +4259,86 @@ function moveZonedEpochSlots(slots, durationFields, options) {
   };
 }
 
-function moveDateTime(calendar, isoDateTimeFields, durationFields, options) {
-  const [movedTimeFields, dayDelta] = moveTime(isoDateTimeFields, durationFields);
-  return checkIsoDateTimeInBounds(combineDateAndTime(moveDate(calendar, isoDateTimeFields, {
+function moveDateTime(calendar, isoDateTime, durationFields, overflow = 0) {
+  const [movedTimeFields, dayDelta] = moveTime(isoDateTime, durationFields);
+  return checkIsoDateTimeInBounds(combineDateAndTime(moveDate(calendar, isoDateTime, {
     ...durationFields,
     ...durationTimeFieldDefaults,
     days: durationFields.days + dayDelta
-  }, options), movedTimeFields));
-}
-
-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);
+  }, overflow), movedTimeFields));
 }
 
 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 ];
+  return moveTimeByNano(timeFields, durationTimeToBigNano(durationFields));
 }
 
-function moveByDays(isoDate, days) {
-  return days ? epochDaysToIsoDate(isoDateToEpochDays(isoDate) + days) : isoDate;
+function moveEpochNano(epochNano, durationFields) {
+  return moveEpochNanoByNano(epochNano, (durationHasDateParts(fields = durationFields) && throwRangeError("Cannot use large units"), 
+  durationTimeToBigNano(fields)));
+  var fields;
 }
 
-function dateAddWithOverflow(calendar, isoDateFields, durationFields, overflow) {
+function moveDate(calendar, isoDate, durationFields, overflow = 0) {
   let {years: years, months: months, weeks: weeks, days: days} = durationFields;
-  let isoDate;
+  let movedIsoDate;
   if (days += Number(durationTimeToBigNano(durationFields) / bigNanoInUtcDay), years || months) {
-    isoDate = addDateMonths(calendar, isoDateFields, years, months, overflow);
+    movedIsoDate = moveDateByCalendarUnits(calendar, isoDate, years, months, overflow);
   } else {
     if (!weeks && !days) {
-      return isoDateFields;
+      return isoDate;
     }
-    isoDate = isoDateFields;
+    movedIsoDate = isoDate;
   }
-  return (weeks || days) && (isoDate = moveByDays(isoDate, 7 * weeks + days)), checkIsoDateInBounds(isoDate);
+  return (weeks || days) && (movedIsoDate = moveDateByDays(movedIsoDate, 7 * weeks + days)), 
+  checkIsoDateInBounds(movedIsoDate);
 }
 
-function addDateMonths(calendar, isoDateFields, years, months, overflow) {
-  const dateParts = computeCalendarDateFields(calendar, isoDateFields);
+function moveToStartOfMonth(calendar, isoDate) {
+  return moveDateByDays(isoDate, 1 - computeCalendarDateFields(calendar, isoDate).day);
+}
+
+function moveDateByCalendarUnits(calendar, isoDate, years, months, overflow) {
+  const dateParts = computeCalendarDateFields(calendar, isoDate);
   let {year: year, month: month, day: day} = dateParts;
   if (years) {
     const [monthCodeNumber, isLeapMonth] = computeCalendarMonthCodeParts(calendar, year, month);
-    year += years, month = computeYearMovedMonth(calendar, monthCodeNumber, isLeapMonth, calendar ? calendar.p(year) : void 0, overflow), 
+    year += years, month = resolveMonthInMovedYear(calendar, monthCodeNumber, isLeapMonth, calendar ? calendar.p(year) : void 0, overflow), 
     month = clampEntity("month", month, 1, computeCalendarMonthsInYearForYear(calendar, year), overflow);
   }
   if (months) {
-    const yearMonthParts = calendar ? calendar.K(year, month, months) : addIsoMonths(year, month, months);
+    const yearMonthParts = addCalendarMonths(calendar, 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.l : 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 addCalendarMonths(calendar, year, month, monthDelta) {
+  return calendar ? calendar.ae(year, month, monthDelta) : addIsoMonths(year, month, monthDelta);
+}
+
+function resolveMonthInMovedYear(calendar, monthCodeNumber, isLeapMonth, targetLeapMonth, overflow) {
+  if (isLeapMonth) {
+    const leapMonthMeta = calendar ? calendar.l : 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 moveTimeByNano(timeFields, durationBigNano) {
+  const durDays = Number(durationBigNano / bigNanoInUtcDay);
+  const durTimeNano = Number(durationBigNano % bigNanoInUtcDay);
+  const [newTimeFields, overflowDays] = nanoToTimeAndDay(timeFieldsToNano(timeFields) + durTimeNano);
+  return [ newTimeFields, durDays + overflowDays ];
+}
+
+function moveEpochNanoByNano(epochNano, deltaNano) {
+  return checkEpochNanoInBounds(epochNano + deltaNano);
+}
+
+function moveDateByDays(isoDate, days) {
+  return days ? epochDaysToIsoDate(isoDateToEpochDays(isoDate) + days) : isoDate;
 }
 
 function getCommonCalendar(a, b) {
@@ -4243,98 +4355,94 @@ 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 diffZonedDateTimesRounded(calendar, startZoned, endZoned, largestUnit, smallestUnit, roundingInc, roundingMode) {
+  return largestUnit < 6 ? diffEpochNanosRounded(startZoned.epochNanoseconds, endZoned.epochNanoseconds, largestUnit, smallestUnit, roundingInc, roundingMode) : ((calendar, startZoned, endZoned, largestUnit, smallestUnit, roundingInc, roundingMode) => {
+    const endEpochNano = endZoned.epochNanoseconds;
+    if (endEpochNano === startZoned.epochNanoseconds) {
+      return durationFieldDefaults;
+    }
+    let durationFields;
+    const timeZone = getCommonTimeZone(startZoned.timeZone, endZoned.timeZone);
+    return durationFields = diffZonedEpochsExact(timeZone, calendar, startZoned, endZoned, largestUnit), 
+    durationFields = roundRelativeDuration(durationFields, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode, createZonedRelativeOps(calendar, timeZone, startZoned), 1), 
+    durationFields;
+  })(calendar, startZoned, endZoned, largestUnit, smallestUnit, roundingInc, roundingMode);
 }
 
-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;
-  if (compareBigInts(epochNano1, epochNano0)) {
-    if (largestUnit < 6) {
-      durationFields = diffEpochNanos(epochNano0, epochNano1, largestUnit, smallestUnit, roundingInc, roundingMode);
-    } else {
-      const timeZone = getCommonTimeZone(slots0.timeZone, slots1.timeZone);
-      durationFields = diffZonedEpochsExact(timeZone, calendar, slots0, slots1, largestUnit), 
-      durationFields = roundRelativeDuration(durationFields, epochNano1, largestUnit, smallestUnit, roundingInc, roundingMode, createZonedRelativeOps(calendar, timeZone, slots0), 1);
+function diffDateTimesRounded(calendar, startIsoDateTime, endIsoDateTime, largestUnit, smallestUnit, roundingInc, roundingMode) {
+  return largestUnit <= 6 ? diffEpochNanosRounded(isoDateTimeToEpochNano(startIsoDateTime), isoDateTimeToEpochNano(endIsoDateTime), largestUnit, smallestUnit, roundingInc, roundingMode) : ((calendar, startIsoDateTime, endIsoDateTime, largestUnit, smallestUnit, roundingInc, roundingMode) => {
+    const endEpochNano = isoDateTimeToEpochNano(endIsoDateTime);
+    const sign = compareBigInts(endEpochNano, isoDateTimeToEpochNano(startIsoDateTime));
+    if (!sign) {
+      return durationFieldDefaults;
     }
-  } else {
-    durationFields = durationFieldDefaults;
-  }
-  return createDurationSlots(invert ? negateDurationFields(durationFields) : durationFields);
+    let durationFields;
+    return durationFields = diffDateTimesBig(calendar, startIsoDateTime, endIsoDateTime, sign, largestUnit), 
+    durationFields = roundRelativeDuration(durationFields, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode, ((calendar, origin) => ({
+      ne: isoDateTimeToEpochNano(origin),
+      ke: duration => isoDateTimeToEpochNano(combineDateAndTime(moveDate(calendar, origin, duration), origin))
+    }))(calendar, startIsoDateTime)), durationFields;
+  })(calendar, startIsoDateTime, endIsoDateTime, largestUnit, smallestUnit, roundingInc, roundingMode);
 }
 
-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, createDateTimeRelativeOps(calendar, plainDateTimeSlots0))) : durationFields = durationFieldDefaults, 
-  createDurationSlots(invert ? negateDurationFields(durationFields) : durationFields);
+function diffYearMonthsRounded(calendar, startIsoDate, endIsoDate, largestUnit, smallestUnit, roundingInc, roundingMode) {
+  const firstOfMonth0 = moveToStartOfMonth(calendar, startIsoDate);
+  const firstOfMonth1 = moveToStartOfMonth(calendar, endIsoDate);
+  return compareIsoDates(firstOfMonth0, firstOfMonth1) ? diffDateCalendarUnitsRounded(calendar, checkIsoDateInBounds(firstOfMonth0), checkIsoDateInBounds(firstOfMonth1), largestUnit, smallestUnit, roundingInc, roundingMode, 8) : durationFieldDefaults;
 }
 
-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 diffDatesRounded(calendar, startIsoDate, endIsoDate, largestUnit, smallestUnit, roundingInc, roundingMode, smallestPrecision = 6) {
+  return 6 === largestUnit ? diffEpochNanosRounded(isoDateToEpochNano(startIsoDate), isoDateToEpochNano(endIsoDate), largestUnit, smallestUnit, roundingInc, roundingMode) : diffDateCalendarUnitsRounded(calendar, startIsoDate, endIsoDate, largestUnit, smallestUnit, roundingInc, roundingMode, smallestPrecision);
 }
 
-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 diffTimesRounded(plainTimeSlots0, plainTimeSlots1, largestUnit, smallestUnit, roundingInc, roundingMode) {
+  const timeDiffNano = roundNumberToInc(timeFieldsToNano(plainTimeSlots1) - timeFieldsToNano(plainTimeSlots0), computeNanoInc(smallestUnit, roundingInc), roundingMode);
+  return {
+    ...durationFieldDefaults,
+    ...nanoToDurationTimeFields(timeDiffNano, largestUnit)
+  };
 }
 
-function diffDateLike(invert, calendar, startIsoDate, endIsoDate, largestUnit, smallestUnit, roundingInc, roundingMode, smallestPrecision = 6) {
-  const startEpochNano = isoDateToEpochNano(startIsoDate);
+function diffDateCalendarUnitsRounded(calendar, startIsoDate, endIsoDate, largestUnit, smallestUnit, roundingInc, roundingMode, smallestPrecision = 6) {
   const endEpochNano = isoDateToEpochNano(endIsoDate);
+  if (!compareIsoDates(startIsoDate, endIsoDate)) {
+    return durationFieldDefaults;
+  }
   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, createDateRelativeOps(calendar, startIsoDate)))) : durationFields = durationFieldDefaults, 
-  createDurationSlots(invert ? negateDurationFields(durationFields) : durationFields);
+  return durationFields = diffCalendarDates(calendar, startIsoDate, endIsoDate, largestUnit), 
+  smallestUnit === smallestPrecision && 1 === roundingInc || (durationFields = roundRelativeDuration(durationFields, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode, createDateRelativeOps(calendar, startIsoDate))), 
+  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 = {
+function diffEpochNanosRounded(startEpochNano, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode) {
+  return {
     ...durationFieldDefaults,
-    ...nanoToDurationTimeFields(timeDiffNano, largestUnit)
+    ...nanoToDurationDayTimeFields(roundBigNanoToInc(endEpochNano - startEpochNano, computeBigNanoInc(smallestUnit, roundingInc), roundingMode), 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))) {
+function diffZonedEpochsExact(timeZone, calendar, startZoned, endZoned, largestUnit) {
+  return largestUnit < 6 ? {
+    ...durationFieldDefaults,
+    ...nanoToDurationDayTimeFields(endZoned.epochNanoseconds - startZoned.epochNanoseconds, largestUnit)
+  } : ((timeZone, startZoned, endZoned) => {
+    const sign = compareBigInts(endZoned.epochNanoseconds, startZoned.epochNanoseconds);
+    if (!sign) {
+      return durationFieldDefaults;
+    }
+    if (!compareIsoDates(zonedEpochSlotsToIso(startZoned), zonedEpochSlotsToIso(endZoned))) {
+      return {
+        ...durationFieldDefaults,
+        ...nanoToDurationDayTimeFields(endZoned.epochNanoseconds - startZoned.epochNanoseconds, 5)
+      };
+    }
+    const [startIsoDateTime, endIsoDate, remainderNano] = prepareZonedEpochDiff(timeZone, startZoned, endZoned, sign);
     return {
-      ...durationFieldDefaults,
-      ...nanoToDurationDayTimeFields(slots1.epochNanoseconds - slots0.epochNanoseconds, 5)
+      ...(start = startIsoDateTime, end = endIsoDate, diffCalendarDates(calendar, start, end, largestUnit)),
+      ...nanoToDurationTimeFields(remainderNano)
     };
-  }
-  const [isoFields0, isoFields1, remainderNano] = prepareZonedEpochDiff(timeZone, slots0, slots1, sign);
-  return {
-    ...6 === largestUnit ? {
-      ...durationFieldDefaults,
-      days: diffDays(isoFields0, isoFields1)
-    } : diffCalendarDates(calendar, isoFields0, isoFields1, largestUnit),
-    ...nanoToDurationTimeFields(remainderNano)
-  };
+    var start, end;
+  })(timeZone, startZoned, endZoned);
 }
 
 function diffDateTimesExact(calendar, startIsoDateTime, endIsoDateTime, largestUnit) {
@@ -4350,38 +4458,57 @@ function diffDateTimesExact(calendar, startIsoDateTime, endIsoDateTime, largestU
 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), 
+  return Math.sign(timeNano) === -sign && (diffEndDate = moveDateByDays(endIsoDateTime, -sign), 
   timeNano += nanoInUtcDay * sign), {
     ...diffCalendarDates(calendar, startIsoDateTime, diffEndDate, largestUnit),
     ...nanoToDurationTimeFields(timeNano)
   };
 }
 
+function prepareZonedEpochDiff(timeZone, startZoned, endZoned, sign) {
+  const startIsoDate = zonedEpochSlotsToIso(startZoned);
+  const endIsoDate = zonedEpochSlotsToIso(endZoned);
+  const endEpochNano = endZoned.epochNanoseconds;
+  let dayCorrection = 0;
+  const timeDiffNano = timeFieldsToNano(endIsoDate) - timeFieldsToNano(startIsoDate);
+  Math.sign(timeDiffNano) === -sign && dayCorrection++;
+  const maxDayCorrection = dayCorrection + (sign > 0 ? 1 : 0);
+  for (;;dayCorrection++) {
+    const midIsoDate = moveDateByDays(endIsoDate, dayCorrection * -sign);
+    const midEpochNano = getSingleInstantFor(timeZone, combineDateAndTime(midIsoDate, startIsoDate));
+    if (dayCorrection === maxDayCorrection || compareBigInts(endEpochNano, midEpochNano) !== -sign) {
+      return [ startIsoDate, midIsoDate, Number(endEpochNano - midEpochNano) ];
+    }
+  }
+}
+
 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: days
-    };
+    return ((asWeeks, start, end) => {
+      const days = countIsoDays(start, end);
+      return asWeeks ? {
+        ...durationFieldDefaults,
+        weeks: divTrunc(days, 7),
+        days: modTrunc(days, 7)
+      } : {
+        ...durationFieldDefaults,
+        days: days
+      };
+    })(7 === largestUnit, startIsoDate, endIsoDate);
   }
   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));
+    const sign = Math.sign(compareNumbers(year1, year0) || compareNumbers(month1, month0) || countIsoDays(startIsoDate, endIsoDate));
     let months = 0;
     let days = 0;
     if (sign) {
-      months = calendar ? calendar._(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);
+      months = calendar ? calendar.ee(year0, month0, year1, month1) : diffIsoMonthSlots(year0, month0, year1, month1);
+      let anchorIsoDate = moveDateByCalendarUnits(calendar, startIsoDate, 0, months, 0);
+      sign * compareNumbers(day0, day1) > 0 && (months -= sign, anchorIsoDate = moveDateByCalendarUnits(calendar, startIsoDate, 0, months, 0)), 
+      days = countIsoDays(anchorIsoDate, endIsoDate);
     }
     return {
       ...durationFieldDefaults,
@@ -4400,7 +4527,7 @@ function diffCalendarDates(calendar, startIsoDate, endIsoDate, largestUnit) {
     let dayCorrect = 0;
     if (Math.sign(day1 - day0) === -sign) {
       const origDaysInMonth1 = daysInMonth1;
-      const yearMonthParts = calendar ? calendar.K(year1, month1, -sign) : addIsoMonths(year1, month1, -sign);
+      const yearMonthParts = addCalendarMonths(calendar, year1, month1, -sign);
       (({year: year1, month: month1} = yearMonthParts)), yearDiff = year1 - year0, monthDiff = month1 - month0, 
       daysInMonth1 = computeCalendarDaysInMonthForYearMonth(calendar, year1, month1), 
       dayCorrect = sign < 0 ? -origDaysInMonth1 : daysInMonth1;
@@ -4412,10 +4539,10 @@ function diffCalendarDates(calendar, startIsoDate, endIsoDate, largestUnit) {
       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.p(year1) : void 0, 0) + (monthCorrect || computeCalendarMonthsInYearForYear(calendar, year1));
+        year1 -= sign, yearDiff = year1 - year0, monthDiff = month1 - resolveMonthInMovedYear(calendar, monthCodeNumber0, isLeapMonth0, calendar ? calendar.p(year1) : void 0, 0) + (monthCorrect || computeCalendarMonthsInYearForYear(calendar, year1));
       } else if (calendar) {
-        const month0Projected = computeYearMovedMonth(calendar, monthCodeNumber0, isLeapMonth0, calendar.p(year1), 0);
-        monthDiff = calendar._(year1, month0Projected, year1, month1);
+        const month0Projected = resolveMonthInMovedYear(calendar, monthCodeNumber0, isLeapMonth0, calendar.p(year1), 0);
+        monthDiff = calendar.ee(year1, month0Projected, year1, month1);
       }
     }
   }
@@ -4427,84 +4554,48 @@ function diffCalendarDates(calendar, startIsoDate, endIsoDate, largestUnit) {
   };
 }
 
-function compareIsoDate(isoDate0, isoDate1) {
+function compareIsoDates(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 countIsoDays(startIsoDate, endIsoDate) {
+  return isoDateToEpochDays(endIsoDate) - isoDateToEpochDays(startIsoDate);
 }
 
-function diffDays(startIsoDate, endIsoDate) {
-  return isoDateToEpochDays(endIsoDate) - isoDateToEpochDays(startIsoDate);
+function spanRelativeDuration(relativeToSlots, durationFields, largestUnit) {
+  return isZonedEpochSlots(relativeToSlots) ? ((relativeToSlots, durationFields, largestUnit) => {
+    const {calendar: calendar, timeZone: timeZone} = relativeToSlots;
+    const endSlots = moveZonedEpochSlots(relativeToSlots, durationFields);
+    return [ diffZonedEpochsExact(timeZone, calendar, relativeToSlots, endSlots, largestUnit), endSlots.epochNanoseconds, createZonedRelativeOps(calendar, timeZone, relativeToSlots) ];
+  })(relativeToSlots, durationFields, largestUnit) : ((relativeToSlots, durationFields, largestUnit) => {
+    const {calendar: calendar} = relativeToSlots;
+    const origin = checkIsoDateTimeInBounds(combineDateAndTime(relativeToSlots, timeFieldDefaults));
+    const end = moveDateTime(calendar, origin, durationFields);
+    return [ diffDateTimesExact(calendar, origin, end, largestUnit), isoDateTimeToEpochNano(end), createDateRelativeOps(calendar, relativeToSlots) ];
+  })(relativeToSlots, durationFields, largestUnit);
 }
 
-function createDateRelativeOps(calendar, origin) {
-  return {
-    origin: origin,
-    ie: isoDateToEpochNano(origin),
-    calendar: calendar,
-    he: isoDateToEpochNano
-  };
+function moveRelativeEndpointToEpochNano(relativeToSlots, durationFields) {
+  return isZonedEpochSlots(relativeToSlots) ? moveZonedEpochSlots(relativeToSlots, durationFields).epochNanoseconds : isoDateTimeToEpochNano(moveDateTime(relativeToSlots.calendar, combineDateAndTime(relativeToSlots, timeFieldDefaults), durationFields));
 }
 
-function createDateTimeRelativeOps(calendar, origin) {
-  return {
-    origin: origin,
-    ie: isoDateTimeToEpochNano(origin),
-    calendar: calendar,
-    he: movedIsoDate => isoDateTimeToEpochNano(combineDateAndTime(movedIsoDate, origin))
-  };
+function moveRelativeMarkerToEpochNano(relativeOps, dateDuration) {
+  return durationHasDateParts(dateDuration) ? relativeOps.ke(dateDuration) : relativeOps.ne;
 }
 
 function createZonedRelativeOps(calendar, timeZone, slots) {
   const origin = zonedEpochSlotsToIso(slots);
   return {
-    origin: origin,
-    ie: slots.epochNanoseconds,
-    calendar: calendar,
-    he: movedIsoDate => getSingleInstantFor(timeZone, combineDateAndTime(movedIsoDate, origin))
+    ne: slots.epochNanoseconds,
+    ke: duration => getSingleInstantFor(timeZone, combineDateAndTime(moveDate(calendar, origin, duration), origin))
   };
 }
 
-function moveRelativeToEpochNano(relativeOps, dateDuration) {
-  return durationHasDateParts(dateDuration) ? relativeOps.he(moveDate(relativeOps.calendar, relativeOps.origin, dateDuration)) : relativeOps.ie;
-}
-
-function spanRelativeDuration(relativeToSlots, durationFields, largestUnit) {
-  const {calendar: calendar} = relativeToSlots;
-  if (isZonedEpochSlots(relativeToSlots)) {
-    const {timeZone: timeZone} = relativeToSlots;
-    const endSlots = moveZonedEpochSlots(relativeToSlots, durationFields);
-    return [ diffZonedEpochsExact(timeZone, calendar, relativeToSlots, endSlots, largestUnit), endSlots.epochNanoseconds, createZonedRelativeOps(calendar, timeZone, relativeToSlots) ];
-  }
-  const origin = checkIsoDateTimeInBounds(combineDateAndTime(relativeToSlots, timeFieldDefaults));
-  const end = moveDateTime(calendar, origin, durationFields);
-  return [ diffDateTimesExact(calendar, origin, end, largestUnit), isoDateTimeToEpochNano(end), createDateRelativeOps(calendar, relativeToSlots) ];
-}
-
-function moveRelativeEndpointToEpochNano(relativeToSlots, durationFields) {
-  return isZonedEpochSlots(relativeToSlots) ? moveZonedEpochSlots(relativeToSlots, durationFields).epochNanoseconds : isoDateTimeToEpochNano(moveDateTime(relativeToSlots.calendar, combineDateAndTime(relativeToSlots, timeFieldDefaults), durationFields));
+function createDateRelativeOps(calendar, origin) {
+  return {
+    ne: isoDateToEpochNano(origin),
+    ke: duration => isoDateToEpochNano(moveDate(calendar, origin, duration))
+  };
 }
 
 function isZonedEpochSlots(slots) {
@@ -4526,49 +4617,21 @@ function nanoToGivenFields(nano, largestUnit, fieldNames) {
 
 const maxDurationSeconds = 2 ** 53;
 
-function addDurations(refineRelativeTo, doSubtract, slots, otherSlots, options) {
-  const relativeToSlots = refineRelativeTo(normalizeOptions(options).relativeTo);
+function addDurationsWithoutRelativeTo(doSubtract, slots, otherSlots) {
   const maxUnit = Math.max(getMaxDurationUnit(slots), getMaxDurationUnit(otherSlots));
-  return isUniformUnit(maxUnit, relativeToSlots && isZonedEpochSlots(relativeToSlots)) ? addDayTimeDurationsChecked(doSubtract, slots, otherSlots, maxUnit) : (relativeToSlots || throwRangeError("Missing relativeTo"), 
-  doSubtract && (otherSlots = negateDurationFields(otherSlots)), createDurationSlots(((relativeToSlots, durationFields0, durationFields1, largestUnit) => {
-    const {calendar: calendar} = relativeToSlots;
-    if (isZonedEpochSlots(relativeToSlots)) {
-      const {timeZone: timeZone} = relativeToSlots;
-      const midSlots = moveZonedEpochSlots(relativeToSlots, durationFields0);
-      return diffZonedEpochsExact(timeZone, calendar, relativeToSlots, moveZonedEpochSlots(midSlots, durationFields1), largestUnit);
-    }
-    const origin = combineDateAndTime(relativeToSlots, timeFieldDefaults);
-    const mid = moveDateTime(calendar, origin, durationFields0);
-    return diffDateTimesExact(calendar, origin, moveDateTime(calendar, mid, durationFields1), largestUnit);
-  })(relativeToSlots, slots, otherSlots, maxUnit)));
-}
-
-function addDayTimeDurationsChecked(doSubtract, slots, otherSlots, maxUnit) {
-  return createDurationSlots(validateDurationFields(((a, b, largestUnit, doSubtract) => {
+  return maxUnit > 6 && throwRangeError("Cannot use large units"), ((doSubtract, slots, otherSlots, maxUnit) => createDurationSlots(validateDurationFields(((a, b, largestUnit, doSubtract) => {
     const combined = durationDayTimeToBigNano(a) + durationDayTimeToBigNano(b) * BigInt(doSubtract ? -1 : 1);
     return Number.isFinite(Number(combined / bigNanoInUtcDay)) || throwRangeError(outOfBoundsDate), 
     {
       ...durationFieldDefaults,
       ...nanoToDurationDayTimeFields(combined, largestUnit)
     };
-  })(slots, otherSlots, maxUnit, doSubtract)));
+  })(slots, otherSlots, maxUnit, doSubtract))))(doSubtract, slots, otherSlots, maxUnit);
 }
 
 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"), 
-    null == smallestUnit && (smallestUnit = 0), null == largestUnit && (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);
+  const [largestUnit, smallestUnit, roundingInc, roundingMode, relativeToSlots] = refineDurationRoundOptions(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);
@@ -4578,12 +4641,11 @@ function roundDuration(refineRelativeTo, slots, options) {
       };
     })(slots, largestUnit, smallestUnit, roundingInc, roundingMode)));
   }
-  const isZoned = relativeToSlots && isZonedEpochSlots(relativeToSlots);
-  const needsZonedDayLength = isZoned && largestUnit >= 6 && smallestUnit < 6;
-  if (!slots.sign && !needsZonedDayLength) {
+  relativeToSlots || throwRangeError("Missing relativeTo");
+  const isZoned = isZonedEpochSlots(relativeToSlots);
+  if (!slots.sign && (!isZoned || largestUnit < 6)) {
     return slots;
   }
-  relativeToSlots || throwRangeError("Missing relativeTo");
   const [balancedDuration, endEpochNano, relativeOps] = spanRelativeDuration(relativeToSlots, slots, largestUnit);
   return createDurationSlots(roundRelativeDuration(balancedDuration, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode, relativeOps, isZoned));
 }
@@ -4616,12 +4678,16 @@ function computeDurationSign(fields, fieldNames = durationFieldNamesAsc) {
 
 function validateDurationFields(fields) {
   for (const calendarUnit of durationCalendarFieldNamesAsc) {
-    clampEntity(calendarUnit, fields[calendarUnit], -4294967295, 4294967295, 1);
+    validateDurationCalendarUnit(calendarUnit, fields[calendarUnit]);
   }
   const bigNano = durationDayTimeToBigNano(fields);
   return validateDurationTimeUnit(Number(bigNano / bigNanoInSec)), fields;
 }
 
+function validateDurationCalendarUnit(unit, value) {
+  return clampEntity(unit, value, -4294967295, 4294967295, 1);
+}
+
 function validateDurationTimeUnit(n) {
   Number.isSafeInteger(n) || throwRangeError("Out-of-bounds duration");
 }
@@ -4677,12 +4743,12 @@ function compareIsoDateTimeFields(isoDateTime0, isoDateTime1) {
   return compareIsoDateFields(isoDateTime0, isoDateTime1) || compareTimeFields(isoDateTime0, isoDateTime1);
 }
 
-function compareIsoDateFields(isoFields0, isoFields1) {
-  return compareNumbers(isoDateToEpochDays(isoFields0), isoDateToEpochDays(isoFields1));
+function compareIsoDateFields(isoDate0, isoDate1) {
+  return compareNumbers(isoDateToEpochDays(isoDate0), isoDateToEpochDays(isoDate1));
 }
 
-function compareTimeFields(isoFields0, isoFields1) {
-  return compareNumbers(timeFieldsToNano(isoFields0), timeFieldsToNano(isoFields1));
+function compareTimeFields(timeFields0, timeFields1) {
+  return compareNumbers(timeFieldsToNano(timeFields0), timeFieldsToNano(timeFields1));
 }
 
 function instantsEqual(instantSlots0, instantSlots1) {
@@ -4721,7 +4787,7 @@ function getCalendarFieldNames(calendar, fieldNames, fieldNamesWithEra = fieldNa
   return getCalendarEraOrigins(calendar) ? fieldNamesWithEra : fieldNames;
 }
 
-function resolveCalendarYear(calendar, fields) {
+function resolveCalendarYear(fields, calendar) {
   const exoticCalendar = calendar || void 0;
   const eraOrigins = getCalendarEraOrigins(calendar);
   let {era: era, eraYear: eraYear, year: year} = fields;
@@ -4732,7 +4798,7 @@ function resolveCalendarYear(calendar, fields) {
     const normalizedEra = normalizeEraName(era);
     const eraOrigin = eraOrigins[normalizedEra];
     void 0 === eraOrigin && throwRangeError((era => `Invalid era: ${era}`)(era));
-    const yearByEra = exoticCalendar?.$ ? exoticCalendar.$(eraYear, normalizedEra, eraOrigin) : eraYearToYear(eraYear, eraOrigin);
+    const yearByEra = exoticCalendar?._ ? exoticCalendar._(eraYear, normalizedEra, eraOrigin) : eraYearToYear(eraYear, eraOrigin);
     void 0 !== year && year !== yearByEra && throwRangeError("Mismatching year/eraYear"), 
     year = yearByEra;
   } else {
@@ -4741,7 +4807,7 @@ function resolveCalendarYear(calendar, fields) {
   return year;
 }
 
-function resolveCalendarMonth(calendar, fields, year, overflow, monthCodeParts) {
+function resolveCalendarMonth(fields, calendar, year, monthCodeParts, overflow) {
   let {month: month, monthCode: monthCode} = fields;
   if (void 0 !== monthCode) {
     const monthByCode = ((calendar, monthCode, year, overflow, monthCodeParts = parseMonthCode(monthCode)) => {
@@ -4764,7 +4830,7 @@ function resolveCalendarMonth(calendar, fields, year, overflow, monthCodeParts)
   return clampEntity("month", month, 1, computeCalendarMonthsInYearForYear(calendar, year), overflow);
 }
 
-function resolveCalendarDay(calendar, fields, month, year, overflow) {
+function resolveCalendarDay(fields, calendar, year, month, overflow) {
   return clampProp(fields, "day", 1, computeCalendarDaysInMonthForYearMonth(calendar, year, month), overflow);
 }
 
@@ -4807,19 +4873,10 @@ function parseOffsetNanoMaybe(s, onlyHourMinute) {
 }
 
 const dateFieldRefiners = {
-  era: toStringViaPrimitive,
+  era: toString,
   month: toPositiveIntegerWithTruncation,
-  monthCode(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(monthCode, fieldName) {
+    return requireString(toPrimitiveWithStringHint(monthCode), fieldName);
   },
   day: toPositiveIntegerWithTruncation
 };
@@ -4832,7 +4889,7 @@ const dateTimeFieldRefiners = /*@__PURE__*/ Object.assign({}, dateFieldRefiners,
 
 const zonedDateTimeFieldRefiners = {
   offset(offsetString) {
-    return parseOffsetNano(toStringViaPrimitive(offsetString));
+    return parseOffsetNano(requireString(toPrimitiveWithStringHint(offsetString)));
   },
   ...dateTimeFieldRefiners
 };
@@ -4854,75 +4911,68 @@ function readAndRefineBagFields(bag, validFieldNames, fieldRefiners, requiredFie
   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 refineCalendarDateFields(fields, calendar, allowMissingDay) {
+  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"), 
+  allowMissingDay || void 0 !== fields.day || throwTypeError(missingField("day"));
+  const monthCodeParts = parseMonthCodeField(fields);
+  return [ resolveCalendarYear(fields, calendar), monthCodeParts ];
 }
 
-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 refineMonthDayFields(fields, calendar) {
+  const isIso = calendar === isoCalendarImpl;
+  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);
+  return [ void 0 !== fields.eraYear || void 0 !== fields.year ? resolveCalendarYear(fields, calendar) : void 0, monthCodeParts ];
 }
 
-function parseMonthCodeField(fields) {
-  if (void 0 !== fields.monthCode) {
-    return parseMonthCode(fields.monthCode);
-  }
+function createDateTimeFromRefinedFields(isoDate, timeFields = timeFieldDefaults, calendar) {
+  const isoDateTime = combineDateAndTime(isoDate, timeFields);
+  return checkIsoDateTimeInBounds(isoDateTime), createDateTimeSlots(isoDateTime, calendar);
 }
 
-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 createDateFromRefinedFields(fields, calendar, year, monthCodeParts, overflow) {
+  const month = resolveCalendarMonth(fields, calendar, year, monthCodeParts, overflow);
+  return createDateSlots(checkIsoDateInBounds(computeCalendarIsoFieldsFromParts(calendar, year, month, resolveCalendarDay(fields, calendar, year, month, overflow))), calendar);
 }
 
-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 createYearMonthFromRefinedFields(fields, calendar, year, monthCodeParts, overflow) {
+  return createYearMonthFromCalendarParts(calendar, year, resolveCalendarMonth(fields, calendar, year, monthCodeParts, overflow));
 }
 
-function createPlainMonthDayFromFields(calendar, fields, options) {
+function createMonthDayFromRefinedFields(fields, calendar, year, monthCodeParts, overflow) {
   const isIso = calendar === isoCalendarImpl;
-  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 yearMaybe = year;
   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);
+    const month = resolveCalendarMonth(fields, calendar, yearMaybe, monthCodeParts, overflow);
+    day = resolveCalendarDay(fields, calendar, yearMaybe, month, overflow), [monthCodeNumber, isLeapMonth] = computeCalendarMonthCodeParts(calendar, yearMaybe, month);
   } else {
     void 0 === fields.monthCode && throwTypeError("Missing month/monthCode"), [monthCodeNumber, isLeapMonth] = monthCodeParts;
-    const referenceYear = calendar ? calendar.ne : 1972;
+    const referenceYear = calendar ? calendar.re : 1972;
     if (void 0 !== referenceYear) {
-      day = resolveCalendarDay(calendar, fields, resolveCalendarMonth(calendar, fields, referenceYear, overflow, monthCodeParts), referenceYear, overflow);
+      day = resolveCalendarDay(fields, calendar, referenceYear, resolveCalendarMonth(fields, calendar, referenceYear, monthCodeParts, overflow), overflow);
     } else {
-      const constrainedDay = 0 === overflow && calendar ? calendar.fe?.(monthCodeNumber, isLeapMonth, fields.day) : void 0;
+      const constrainedDay = 0 === overflow && calendar ? calendar.ge?.(monthCodeNumber, isLeapMonth, fields.day) : void 0;
       day = void 0 !== constrainedDay ? constrainedDay : fields.day;
     }
   }
-  isLeapMonth && ((calendar && calendar.U?.[monthCodeNumber]) ?? 1 / 0) < fields.day && (1 === overflow && throwRangeError(invalidLeapMonth), 
-  isLeapMonth = 0, day = constrainToRange(fields.day, 1, (calendar && calendar.R) ?? 1 / 0));
+  return createMonthDayFromMonthCodeParts(calendar, monthCodeNumber, isLeapMonth, day, fields.day, overflow);
+}
+
+function createYearMonthFromCalendarParts(calendar, year, month) {
+  return createDateSlots(checkIsoYearMonthInBounds(computeCalendarIsoFieldsFromParts(calendar, year, month, 1)), calendar);
+}
+
+function createMonthDayFromMonthCodeParts(calendar, monthCodeNumber, isLeapMonthArg, day, requestedDay, overflow) {
+  let isLeapMonth = isLeapMonthArg;
+  isLeapMonth && ((calendar && calendar.V?.[monthCodeNumber]) ?? 1 / 0) < requestedDay && (1 === overflow && throwRangeError(invalidLeapMonth), 
+  isLeapMonth = 0, day = constrainToRange(requestedDay, 1, (calendar && calendar.U) ?? 1 / 0));
   let res = calendar ? calendar.u(monthCodeNumber, Boolean(isLeapMonth), day) : computeIsoYearMonthFieldsForMonthDay(monthCodeNumber, Boolean(isLeapMonth));
   for (;!res && 0 === overflow && day > 1; ) {
     day--, res = calendar ? calendar.u(monthCodeNumber, Boolean(isLeapMonth), day) : computeIsoYearMonthFieldsForMonthDay(monthCodeNumber, Boolean(isLeapMonth));
@@ -4932,6 +4982,12 @@ function createPlainMonthDayFromFields(calendar, fields, options) {
   return createDateSlots(checkIsoDateInBounds(computeCalendarIsoFieldsFromParts(calendar, finalYear, finalMonth, day)), calendar);
 }
 
+function parseMonthCodeField(fields) {
+  if (void 0 !== fields.monthCode) {
+    return parseMonthCode(fields.monthCode);
+  }
+}
+
 const RawDateTimeFormat = Intl.DateTimeFormat;
 
 function formatEpochMilliToPartsRecord(intlFormat, epochMilli) {
@@ -4964,32 +5020,8 @@ const timeZonePeriodDaysByName = {
 
 const minPossibleTransitionSec = -388152e4;
 
-function refineTimeDisplayTuple(options, maxSmallestUnit = 4) {
-  const subsecDigits = coerceFractionalSecondDigits(options);
-  const roundingMode = coerceRoundingMode(options, 4);
-  const smallestUnit = coerceSmallestUnit(options);
-  return [ roundingMode, ...resolveSmallestUnitAndSubsecDigits(validateUnitRange(smallestUnitStr, smallestUnit, 0, maxSmallestUnit), subsecDigits) ];
-}
-
-function refineDateDisplayOptions(options) {
-  return coerceCalendarDisplay(normalizeOptions(options));
-}
-
-function refineTimeDisplayOptions(options, maxSmallestUnit) {
-  return refineTimeDisplayTuple(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 = normalizeOptions(options));
-    const roundingMode = coerceRoundingMode(options, 4);
-    const smallestUnit = coerceSmallestUnit(options);
-    return [ options.timeZone, roundingMode, ...resolveSmallestUnitAndSubsecDigits(validateUnitRange(smallestUnitStr, smallestUnit, 0, 4), subsecDigits) ];
-  })(options);
+  const [timeZoneArg, roundingMode, nanoInc, subsecDigits] = refineInstantDisplayOptions(options);
   const providedTimeZone = void 0 !== timeZoneArg;
   return ((providedTimeZone, timeZone, epochNano, roundingMode, nanoInc, subsecDigits) => {
     epochNano = roundBigNanoToDayOriginInc(epochNano, BigInt(nanoInc), roundingMode);
@@ -4999,15 +5031,7 @@ function formatInstantIso(refineTimeZoneString, instantSlots, options) {
 }
 
 function formatZonedDateTimeIso(zonedDateTimeSlots0, options) {
-  const displayOptions = (options => {
-    options = 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);
+  const displayOptions = refineZonedDateTimeDisplayOptions(options);
   return ((calendar, timeZoneId, timeZone, epochNano, calendarDisplay, timeZoneDisplay, offsetDisplay, roundingMode, nanoInc, subsecDigits) => {
     epochNano = roundBigNanoToDayOriginInc(epochNano, BigInt(nanoInc), roundingMode);
     const offsetNano = timeZone.B(epochNano);
@@ -5016,8 +5040,8 @@ function formatZonedDateTimeIso(zonedDateTimeSlots0, options) {
 }
 
 function formatPlainDateTimeIso(plainDateTimeSlots0, options) {
-  const displayOptions = (options => (options = 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);
+  const displayOptions = refineDateTimeDisplayOptions(options);
+  return ((calendar, isoDateTime, calendarDisplay, roundingMode, nanoInc, subsecDigits) => formatIsoDateTimeFields(roundDateTimeToInc(isoDateTime, nanoInc, roundingMode), subsecDigits) + formatCalendar(calendar, calendarDisplay))(plainDateTimeSlots0.calendar, plainDateTimeSlots0, ...displayOptions);
 }
 
 function formatPlainDateIso(plainDateSlots, options) {
@@ -5040,7 +5064,7 @@ function formatDateLikeIso(calendar, formatSimple, isoDate, calendarDisplay) {
 }
 
 function formatPlainTimeIso(slots, options) {
-  return ((fields, roundingMode, nanoInc, subsecDigits) => formatTimeFields(roundTimeToNano(fields, nanoInc, roundingMode)[0], subsecDigits))(slots, ...refineTimeDisplayOptions(options));
+  return ((fields, roundingMode, nanoInc, subsecDigits) => formatTimeFields(roundTimeToInc(fields, nanoInc, roundingMode)[0], subsecDigits))(slots, ...refineTimeDisplayOptions(options));
 }
 
 function formatDurationIso(slots, options) {
@@ -5094,17 +5118,17 @@ function formatIsoDateTimeFields(isoDateTime, subsecDigits) {
   return formatIsoDateFields(isoDateTime) + "T" + formatTimeFields(isoDateTime, subsecDigits);
 }
 
-function formatIsoDateFields(isoDateFields) {
-  return formatIsoYearMonthFields(isoDateFields) + "-" + padNumber2(isoDateFields.day);
+function formatIsoDateFields(isoDate) {
+  return formatIsoYearMonthFields(isoDate) + "-" + padNumber2(isoDate.day);
 }
 
-function formatIsoYearMonthFields(isoDateFields) {
-  const {year: year} = isoDateFields;
-  return (year < 0 || year > 9999 ? getSignStr(year) + padNumber(6, Math.abs(year)) : padNumber(4, year)) + "-" + padNumber2(isoDateFields.month);
+function formatIsoYearMonthFields(isoDate) {
+  const {year: year} = isoDate;
+  return (year < 0 || year > 9999 ? getSignStr(year) + padNumber(6, Math.abs(year)) : padNumber(4, year)) + "-" + padNumber2(isoDate.month);
 }
 
-function formatIsoMonthDayFields(isoDateFields) {
-  return padNumber2(isoDateFields.month) + "-" + padNumber2(isoDateFields.day);
+function formatIsoMonthDayFields(isoDate) {
+  return padNumber2(isoDate.month) + "-" + padNumber2(isoDate.day);
 }
 
 function formatTimeFields(timeFields, subsecDigits) {
@@ -5166,7 +5190,7 @@ function resolveTimeZoneRecord(rawId) {
     if (void 0 !== offsetNano) {
       return {
         id: formatOffsetNano(offsetNano),
-        X: offsetNano,
+        Z: offsetNano,
         m: offsetNano
       };
     }
@@ -5217,24 +5241,24 @@ function queryTimeZone(rawTimeZoneId) {
   return queryTimeZoneRecord(record.id, record);
 }
 
-const queryTimeZoneRecord = /*@__PURE__*/ memoize((normTimeZoneId, record) => "named" === record.kind ? new IntlTimeZone(normTimeZoneId, record.m, record.format) : new FixedTimeZone(normTimeZoneId, record.m, "fixed" === record.kind ? record.X : 0));
+const queryTimeZoneRecord = /*@__PURE__*/ memoize((normTimeZoneId, record) => "named" === record.kind ? new IntlTimeZone(normTimeZoneId, record.m, record.format) : new FixedTimeZone(normTimeZoneId, record.m, "fixed" === record.kind ? record.Z : 0));
 
 class FixedTimeZone {
   constructor(id, compareKey, offsetNano) {
-    this.id = id, this.m = compareKey, this.X = offsetNano;
+    this.id = id, this.m = compareKey, this.Z = offsetNano;
   }
   B() {
-    return this.X;
+    return this.Z;
   }
-  N(isoDateTime) {
-    return [ isoDateTimeAndOffsetToEpochNano(isoDateTime, this.X) ];
+  R(isoDateTime) {
+    return [ isoDateTimeAndOffsetToEpochNano(isoDateTime, this.Z) ];
   }
-  O() {}
+  C() {}
 }
 
 class IntlTimeZone {
   constructor(id, compareKey, format) {
-    this.id = id, this.m = compareKey, this.ke = ((computeOffsetSec, periodDays) => {
+    this.id = id, this.m = compareKey, this.oe = ((computeOffsetSec, periodDays) => {
       const getSample = memoize(computeOffsetSec);
       const getSplit = memoize(createSplitTuple);
       const periodSec = 86400 * periodDays;
@@ -5256,7 +5280,7 @@ class IntlTimeZone {
         return offsetSec;
       }
       return {
-        xe(zonedEpochSec) {
+        Ae(zonedEpochSec) {
           const wideOffsetSec0 = getOffsetSec(zonedEpochSec - 86400);
           const wideOffsetSec1 = getOffsetSec(zonedEpochSec + 86400);
           const wideUtcEpochSec0 = zonedEpochSec - wideOffsetSec0;
@@ -5267,8 +5291,8 @@ class IntlTimeZone {
           const narrowOffsetSec0 = getOffsetSec(wideUtcEpochSec0);
           return narrowOffsetSec0 === getOffsetSec(wideUtcEpochSec1) ? [ zonedEpochSec - narrowOffsetSec0 ] : wideOffsetSec0 > wideOffsetSec1 ? [ wideUtcEpochSec0, wideUtcEpochSec1 ] : [];
         },
-        we: getOffsetSec,
-        O: function getTransition(epochSec, direction) {
+        ze: getOffsetSec,
+        C: function getTransition(epochSec, direction) {
           if (direction > 0 && epochSec >= 864e10) {
             return;
           }
@@ -5305,7 +5329,7 @@ class IntlTimeZone {
       };
     })((format => epochSec => {
       const intlParts = formatEpochMilliToPartsRecord(format, 1e3 * epochSec);
-      return 86400 * isoArgsToEpochDays((intlParts => {
+      return 86400 * isoPartsToEpochDays((intlParts => {
         const relatedYear = intlParts.relatedYear;
         if (void 0 !== relatedYear) {
           return parseInt(relatedYear);
@@ -5319,16 +5343,16 @@ class IntlTimeZone {
     })(id));
   }
   B(epochNano) {
-    return this.ke.we((epochNano => epochNanoToSecMod(epochNano)[0])(epochNano)) * nanoInSec;
+    return this.oe.ze((epochNano => epochNanoToSecMod(epochNano)[0])(epochNano)) * nanoInSec;
   }
-  N(isoDateTime) {
+  R(isoDateTime) {
     const zonedEpochSec = 86400 * isoDateToEpochDays(isoDateTime) + timeFieldsToSec(isoDateTime);
     const subsecNano = timeFieldsToSubsecNano(isoDateTime);
-    return this.ke.xe(zonedEpochSec).map(epochSec => checkEpochNanoInBounds(BigInt(epochSec) * bigNanoInSec + BigInt(subsecNano)));
+    return this.oe.Ae(zonedEpochSec).map(epochSec => checkEpochNanoInBounds(BigInt(epochSec) * bigNanoInSec + BigInt(subsecNano)));
   }
-  O(epochNano, direction) {
+  C(epochNano, direction) {
     const [epochSec, subsecNano] = epochNanoToSecMod(epochNano);
-    const resEpochSec = this.ke.O(epochSec + (direction > 0 || subsecNano ? 1 : 0), direction);
+    const resEpochSec = this.oe.C(epochSec + (direction > 0 || subsecNano ? 1 : 0), direction);
     if (void 0 !== resEpochSec) {
       return BigInt(resEpochSec) * bigNanoInSec;
     }
@@ -5354,46 +5378,56 @@ function clampIntlSampleEpochSec(epochSec) {
 
 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 isZoned = void 0 !== fields.timeZone;
+  const [year, monthCodeParts] = refineCalendarDateFields(fields, calendar);
+  const isoDate = createDateFromRefinedFields(fields, calendar, year, monthCodeParts, 0);
+  if (isZoned) {
     const timeFields = resolveTimeFields(fields);
     const timeZone = queryTimeZone(refineTimeZoneString(fields.timeZone));
     return {
-      epochNanoseconds: getMatchingInstantFor(timeZone, combineDateAndTime(isoDateFields, timeFields), fields.offset),
+      epochNanoseconds: getMatchingInstantFor(timeZone, combineDateAndTime(isoDate, timeFields), fields.offset),
       timeZone: timeZone,
       calendar: calendar
     };
   }
-  return createPlainDateFromFields(calendar, fields);
+  return isoDate;
 }
 
 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 [year, monthCodeParts] = refineCalendarDateFields(fields, calendar);
+  const [overflow, offsetDisambig, epochDisambig] = refineZonedFieldOptions(options);
+  const isoDate = createDateFromRefinedFields(fields, calendar, year, monthCodeParts, overflow);
   const timeFields = resolveTimeFields(fields, overflow);
   const timeZone = queryTimeZone(timeZoneId);
-  return createZonedEpochNanoSlots(getMatchingInstantFor(timeZone, combineDateAndTime(isoDateFields, timeFields), fields.offset, offsetDisambig, epochDisambig), timeZone, calendar);
+  return createZonedEpochNanoSlots(getMatchingInstantFor(timeZone, combineDateAndTime(isoDate, 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);
+  const [year, monthCodeParts] = refineCalendarDateFields(fields, calendar);
+  const overflow = refineOverflowOptions(options);
+  return createDateTimeFromRefinedFields(createDateFromRefinedFields(fields, calendar, year, monthCodeParts, overflow), resolveTimeFields(fields, overflow), calendar);
 }
 
 function refinePlainDateObjectLike(calendar, bag, options, requireFields = []) {
-  return createPlainDateFromFields(calendar, readAndRefineBagFields(bag, getCalendarFieldNames(calendar, dateFieldNamesAlpha, dateFieldNamesWithEraAlpha), dateFieldRefiners, requireFields), options);
+  const fields = readAndRefineBagFields(bag, getCalendarFieldNames(calendar, dateFieldNamesAlpha, dateFieldNamesWithEraAlpha), dateFieldRefiners, requireFields);
+  const [year, monthCodeParts] = refineCalendarDateFields(fields, calendar);
+  return createDateFromRefinedFields(fields, calendar, year, monthCodeParts, refineOverflowOptions(options));
 }
 
 function refinePlainYearMonthObjectLike(calendar, bag, options, requireFields) {
-  return createPlainYearMonthFromFields(calendar, readAndRefineBagFields(bag, getCalendarFieldNames(calendar, yearMonthFieldNamesAlpha, yearMonthFieldNamesWithEraAlpha), dateFieldRefiners, requireFields), options);
+  const fields = readAndRefineBagFields(bag, getCalendarFieldNames(calendar, yearMonthFieldNamesAlpha, yearMonthFieldNamesWithEraAlpha), dateFieldRefiners, requireFields);
+  const [year, monthCodeParts] = refineCalendarDateFields(fields, calendar, 1);
+  return createYearMonthFromRefinedFields(fields, calendar, year, monthCodeParts, refineOverflowOptions(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);
+  calendarAbsent && void 0 !== fields.month && void 0 === fields.monthCode && void 0 === fields.year && (fields.year = 1972);
+  const [year, monthCodeParts] = refineMonthDayFields(fields, calendar);
+  return createMonthDayFromRefinedFields(fields, calendar, year, monthCodeParts, refineOverflowOptions(options));
 }
 
 function refinePlainTimeObjectLike(bag, options) {
@@ -5413,16 +5447,16 @@ function throwFailedParse(s) {
 }
 
 function parseInstant(s) {
-  const organized = parseDateTimeLike(s = toStringViaPrimitive(s));
+  const organized = parseDateTimeLike(s = requireString(toPrimitiveWithStringHint(s)));
   let offsetNano;
-  return organized || throwFailedParse(s), organized.C ? offsetNano = 0 : organized.offset ? offsetNano = parseOffsetNano(organized.offset) : throwFailedParse(s), 
+  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.C && throwFailedParse(s), 
+  return organized || throwFailedParse(s), organized.timeZoneId ? finalizeZonedDateTime(organized, resolveCalendar, void 0) : (organized.F && throwFailedParse(s), 
   finalizeDate(organized, resolveCalendar));
 }
 
@@ -5433,7 +5467,7 @@ function parseZonedDateTime(s, resolveCalendar, options) {
 
 function parsePlainDateTime(s, resolveCalendar) {
   const organized = parseDateTimeLike(requireString(s));
-  return organized && !organized.C || throwFailedParse(s), finalizeDateTime(organized, resolveCalendar);
+  return organized && !organized.F || throwFailedParse(s), finalizeDateTime(organized, resolveCalendar);
 }
 
 function parsePlainDate(s, resolveCalendar) {
@@ -5478,7 +5512,7 @@ function parsePlainTime(s) {
   })(s = requireString(s));
   if (!organized) {
     const dateTime = parseDateTimeLike(s);
-    dateTime && dateTime.re || throwFailedParse(s), dateTime.C && throwRangeError(invalidSubstring("Z")), 
+    dateTime && dateTime.te || throwFailedParse(s), dateTime.F && throwRangeError(invalidSubstring("Z")), 
     requireIsoCalendar(dateTime), organized = dateTime;
   }
   let altParsed;
@@ -5530,17 +5564,17 @@ function parseCalendarId(s) {
 
 function parseTimeZoneId(s) {
   const parsed = parseDateTimeLike(s);
-  return parsed && (parsed.timeZoneId || parsed.C && "UTC" || parsed.offset) || s;
+  return parsed && (parsed.timeZoneId || parsed.F && "UTC" || parsed.offset) || s;
 }
 
 function parsePlainDateLike(s) {
   const organized = parseDateTimeLike(s);
-  return organized && !organized.C || throwFailedParse(s), organized;
+  return organized && !organized.F || throwFailedParse(s), organized;
 }
 
 function finalizeDateLike(organized, isoDateProjector, resolveCalendar) {
   return isoDateProjector && "iso8601" === organized.calendarId ? (validateIsoDateFields(organized), 
-  organized.re && validateTimeFields(organized), finalizeDate(isoDateProjector(organized), resolveCalendar)) : organized.re ? finalizeDateTime(organized, resolveCalendar) : finalizeDate(organized, resolveCalendar);
+  organized.te && validateTimeFields(organized), finalizeDate(isoDateProjector(organized), resolveCalendar)) : organized.te ? finalizeDateTime(organized, resolveCalendar) : finalizeDate(organized, resolveCalendar);
 }
 
 function projectIsoYearMonthDate(organized) {
@@ -5561,11 +5595,11 @@ function projectIsoMonthDayDate(organized) {
 function finalizeZonedDateTime(organized, resolveCalendar, options) {
   const timeZone = queryTimeZone(resolveTimeZoneId(organized.timeZoneId));
   let epochNano;
-  if (validateIsoDateTimeFields(organized), organized.re) {
+  if (validateIsoDateTimeFields(organized), organized.te) {
     const offsetNano = organized.offset ? parseOffsetNano(organized.offset) : void 0;
     const [, offsetDisambig, epochDisambig] = refineZonedFieldOptions(options);
-    epochNano = getMatchingInstantFor(timeZone, organized, offsetNano, offsetDisambig, epochDisambig, !(timeZone.X || void 0 === organized.offset || (offset = organized.offset, 
-    offset.replace(/\D/g, "").length > 4)), organized.C);
+    epochNano = getMatchingInstantFor(timeZone, organized, offsetNano, offsetDisambig, epochDisambig, !(timeZone.Z || void 0 === organized.offset || (offset = organized.offset, 
+    offset.replace(/\D/g, "").length > 4)), organized.F);
   } else {
     refineZonedFieldOptions(options), epochNano = getStartOfDayInstantFor(timeZone, organized);
   }
@@ -5619,8 +5653,8 @@ function parseDateTimeLike(s) {
       day: parseInt(parts[6]),
       ...organizeTimeParts(parts, 7),
       ...organizeAnnotationParts(parts[19]),
-      re: Boolean(parts[7]),
-      C: hasZ,
+      te: Boolean(parts[7]),
+      F: hasZ,
       offset: hasZ ? void 0 : zOrOffset
     };
   })(parts) : void 0;
@@ -5690,7 +5724,7 @@ function organizeAnnotationParts(s) {
 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.ge && spliceFields(merged, additionalFields, monthDayFieldNames, eraYearFieldNames)), 
+  calendar && calendar.je && spliceFields(merged, additionalFields, monthDayFieldNames, eraYearFieldNames)), 
   merged;
 }
 
@@ -5707,8 +5741,7 @@ function spliceFields(dest, additional, allPropNames, deletablePropNames) {
   }
 }
 
-function mergeZonedDateTimeFields(zonedDateTimeSlots, modFields, options) {
-  const {calendar: calendar, timeZone: timeZone} = zonedDateTimeSlots;
+function mergeZonedDateTimeFields(calendar, zonedDateTimeSlots, modFields) {
   const validFieldNames = getCalendarFieldNames(calendar, dateTimeAndOffsetFieldNamesAlpha, dateTimeAndOffsetFieldNamesWithEraAlpha);
   const zonedSlots = zonedEpochSlotsToIso(zonedDateTimeSlots);
   const {year: year, month: month, day: day} = computeCalendarDateFields(calendar, zonedSlots);
@@ -5726,16 +5759,13 @@ function mergeZonedDateTimeFields(zonedDateTimeSlots, modFields, options) {
   };
   const partialFields = readAndRefineBagFields(modFields, validFieldNames, zonedDateTimeFieldRefiners);
   const mergedCalendarFields = mergeCalendarFields(calendar, origFields, partialFields);
-  const mergedAllFields = {
+  return [ {
     ...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);
+  }, mergedCalendarFields ];
 }
 
-function mergePlainDateTimeFields(plainDateTimeSlots, modFields, options) {
-  const {calendar: calendar} = plainDateTimeSlots;
+function mergeDateTimeFields(calendar, plainDateTimeSlots, modFields) {
   const validFieldNames = getCalendarFieldNames(calendar, dateTimeFieldNamesAlpha, dateTimeFieldNamesWithEraAlpha);
   const {year: year, month: month, day: day} = computeCalendarDateFields(calendar, plainDateTimeSlots);
   const origFields = {
@@ -5751,50 +5781,54 @@ function mergePlainDateTimeFields(plainDateTimeSlots, modFields, options) {
   };
   const partialFields = readAndRefineBagFields(modFields, validFieldNames, dateTimeFieldRefiners);
   const mergedCalendarFields = mergeCalendarFields(calendar, origFields, partialFields);
-  const mergedAllFields = {
+  return [ {
     ...origFields,
     ...partialFields
-  };
-  const [plainDateSlots, overflow] = createPlainDateFromFieldsWithOptionsRefiner(calendar, mergedCalendarFields, () => [ refineOverflowOptions(options) ]);
-  return createPlainDateTimeFromRefinedFields(plainDateSlots, constrainTimeFields(mergedAllFields, overflow), calendar);
+  }, mergedCalendarFields ];
 }
 
-function mergePlainDateFields(plainDateSlots, modFields, options) {
-  const {calendar: calendar} = plainDateSlots;
+function mergeDateFields(calendar, plainDateSlots, modFields) {
   const validFieldNames = getCalendarFieldNames(calendar, dateFieldNamesAlpha, dateFieldNamesWithEraAlpha);
   const {year: year, month: month, day: day} = computeCalendarDateFields(calendar, plainDateSlots);
-  return createPlainDateFromFields(calendar, mergeCalendarFields(calendar, {
+  return mergeCalendarFields(calendar, {
     year: year,
     monthCode: computeMonthCode(calendar, year, month),
     day: day
-  }, readAndRefineBagFields(modFields, validFieldNames, dateFieldRefiners)), options);
+  }, readAndRefineBagFields(modFields, validFieldNames, dateFieldRefiners));
 }
 
-function mergePlainYearMonthFields(plainYearMonthSlots, modFields, options) {
-  const {calendar: calendar} = plainYearMonthSlots;
+function mergeYearMonthFields(calendar, plainYearMonthSlots, modFields) {
   const validFieldNames = getCalendarFieldNames(calendar, yearMonthFieldNamesAlpha, yearMonthFieldNamesWithEraAlpha);
   const {year: year, month: month} = computeCalendarDateFields(calendar, plainYearMonthSlots);
-  return createPlainYearMonthFromFields(calendar, mergeCalendarFields(calendar, {
+  return mergeCalendarFields(calendar, {
     year: year,
     monthCode: computeMonthCode(calendar, year, month)
-  }, readAndRefineBagFields(modFields, validFieldNames, dateFieldRefiners)), options);
+  }, readAndRefineBagFields(modFields, validFieldNames, dateFieldRefiners));
 }
 
-function mergePlainMonthDayFields(plainMonthDaySlots, modFields, options) {
-  const {calendar: calendar} = plainMonthDaySlots;
+function mergeMonthDayFields(calendar, plainMonthDaySlots, modFields) {
   const validFieldNames = getCalendarFieldNames(calendar, dateFieldNamesAlpha, dateFieldNamesWithEraAlpha);
   const {year: year, month: month, day: day} = computeCalendarDateFields(calendar, plainMonthDaySlots);
-  return createPlainMonthDayFromFields(calendar, mergeCalendarFields(calendar, {
+  return mergeCalendarFields(calendar, {
     monthCode: computeMonthCode(calendar, year, month),
     day: day
-  }, readAndRefineBagFields(modFields, validFieldNames, dateFieldRefiners)), options);
+  }, readAndRefineBagFields(modFields, validFieldNames, dateFieldRefiners));
+}
+
+function createZonedDateTimeFromMergedFields(zonedDateTimeSlots, mergedAllFields, calendarFields, year, monthCodeParts, overflow, offsetDisambig, epochDisambig) {
+  const {calendar: calendar, timeZone: timeZone} = zonedDateTimeSlots;
+  return createZonedEpochNanoSlots(getMatchingInstantFor(timeZone, combineDateAndTime(createDateFromRefinedFields(calendarFields, calendar, year, monthCodeParts, overflow), constrainTimeFields(mergedAllFields, overflow)), mergedAllFields.offset, offsetDisambig, epochDisambig), timeZone, calendar);
 }
 
-function mergePlainTimeFields(initialFields, mod, options) {
-  return ((initialFields, modFields, options) => resolveTimeFields({
+function createDateTimeFromMergedFields(mergedAllFields, calendarFields, calendar, year, monthCodeParts, overflow) {
+  return createDateTimeFromRefinedFields(createDateFromRefinedFields(calendarFields, calendar, year, monthCodeParts, overflow), constrainTimeFields(mergedAllFields, overflow), calendar);
+}
+
+function mergeTimeFields(initialFields, modFields) {
+  return {
     ...pluckProps(timeFieldNamesAlpha, initialFields),
     ...readAndRefineBagFields(modFields, timeFieldNamesAlpha, timeFieldRefiners)
-  }, refineOverflowOptions(options)))(initialFields, mod, options);
+  };
 }
 
 function mergeDurationFields(slots, fields) {
@@ -5810,6 +5844,30 @@ function computeMonthCode(calendar, year, month) {
   return formatMonthCode(monthCodeNumber, isLeapMonth);
 }
 
+function totalDuration(refineRelativeTo, slots, options) {
+  const [totalUnit, relativeToSlots] = refineTotalOptions(options, refineRelativeTo);
+  const maxDurationUnit = getMaxDurationUnit(slots);
+  const maxUnit = Math.max(totalUnit, maxDurationUnit);
+  const isZoned = relativeToSlots && isZonedEpochSlots(relativeToSlots);
+  if (!relativeToSlots && isUniformUnit(maxUnit, isZoned)) {
+    return totalDayTimeDuration(slots, totalUnit);
+  }
+  if (relativeToSlots || throwRangeError("Missing relativeTo"), !slots.sign && (!isZoned || totalUnit < 6)) {
+    return 0;
+  }
+  const [balancedDuration, endEpochNano, relativeOps] = spanRelativeDuration(relativeToSlots, slots, totalUnit);
+  return isUniformUnit(totalUnit, isZoned) ? totalDayTimeDuration(balancedDuration, totalUnit) : ((durationFields, endEpochNano, totalUnit, relativeOps) => {
+    const fieldName = durationFieldNamesAsc[totalUnit];
+    const baseDurationFields = clearDurationFields(totalUnit, durationFields);
+    return totalRelativeUnit(durationFields[fieldName], computeDurationSign(durationFields) || 1, endEpochNano, value => (baseDurationFields[fieldName] = value, 
+    moveRelativeMarkerToEpochNano(relativeOps, baseDurationFields)));
+  })(balancedDuration, endEpochNano, totalUnit, relativeOps);
+}
+
+function totalDayTimeDuration(durationFields, totalUnit) {
+  return divideBigNanoToExactNumber(durationDayTimeToBigNano(durationFields), unitNanoMap[totalUnit]);
+}
+
 function instantToZonedDateTime(instantSlots, timeZone, calendar) {
   return createZonedEpochNanoSlots(instantSlots.epochNanoseconds, timeZone, calendar);
 }
@@ -5818,55 +5876,55 @@ function zonedDateTimeToInstant(zonedDateTimeSlots0) {
   return createEpochNanoSlots(zonedDateTimeSlots0.epochNanoseconds);
 }
 
-function zonedDateTimeToPlainDateTime(zonedDateTimeSlots0) {
+function zonedDateTimeToDateTime(zonedDateTimeSlots0) {
   return createDateTimeSlots(zonedEpochSlotsToIso(zonedDateTimeSlots0), zonedDateTimeSlots0.calendar);
 }
 
-function zonedDateTimeToPlainDate(zonedDateTimeSlots0) {
+function zonedDateTimeToDate(zonedDateTimeSlots0) {
   return createDateSlots(zonedEpochSlotsToIso(zonedDateTimeSlots0), zonedDateTimeSlots0.calendar);
 }
 
-function zonedDateTimeToPlainTime(zonedDateTimeSlots0) {
+function zonedDateTimeToTime(zonedDateTimeSlots0) {
   return createTimeSlots(zonedEpochSlotsToIso(zonedDateTimeSlots0));
 }
 
-function plainDateTimeToZonedDateTime(plainDateTimeSlots, timeZone, options) {
-  const epochNano = getSingleInstantFor(timeZone, plainDateTimeSlots, (options => coerceEpochDisambig(normalizeOptions(options)))(options));
-  return createZonedEpochNanoSlots(checkEpochNanoInBounds(epochNano), timeZone, plainDateTimeSlots.calendar);
+function dateTimeToZonedDateTime(plainDateTimeSlots, timeZone, epochDisambig) {
+  return createZonedEpochNanoSlots(checkEpochNanoInBounds(getSingleInstantFor(timeZone, plainDateTimeSlots, epochDisambig)), 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);
+function dateToZonedDateTime(plainDateSlots, timeZone, timeFields) {
   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(requireObjectLike(bag), dayFieldNamesAsc, dateFieldRefiners, []));
+function yearMonthToDate(calendar, input, bag) {
+  return mergeFieldsIntoDate(calendar, pluckProps(getCalendarFieldNames(calendar, yearMonthCodeFieldNamesAlpha, yearMonthCodeFieldNamesWithEraAlpha), input), readAndRefineBagFields(requireObjectLike(bag), dayFieldNamesAsc, dateFieldRefiners, []));
 }
 
-function convertPlainMonthDayToDate(calendar, input, bag) {
+function monthDayToDate(calendar, input, bag) {
   const extraFieldNames = getCalendarFieldNames(calendar, yearFieldNamesAsc, yearFieldNamesWithEraAlpha);
-  return createPlainDateFromMergedFields(calendar, pluckProps(monthCodeDayFieldNamesAlpha, input), readAndRefineBagFields(requireObjectLike(bag), extraFieldNames, dateFieldRefiners, []));
+  return mergeFieldsIntoDate(calendar, pluckProps(monthCodeDayFieldNamesAlpha, input), readAndRefineBagFields(requireObjectLike(bag), extraFieldNames, dateFieldRefiners, []));
 }
 
-function convertToPlainMonthDay(calendar, input) {
-  return createPlainMonthDayFromFields(calendar, readAndRefineBagFields(input, monthCodeDayFieldNamesAlpha, dateFieldRefiners));
+function fieldsToMonthDay(calendar, input) {
+  const refinedFields = readAndRefineBagFields(input, monthCodeDayFieldNamesAlpha, dateFieldRefiners);
+  const [year, monthCodeParts] = refineMonthDayFields(refinedFields, calendar);
+  return createMonthDayFromRefinedFields(refinedFields, calendar, year, monthCodeParts, 0);
 }
 
-function convertToPlainYearMonth(calendar, input, options) {
-  return createPlainYearMonthFromFields(calendar, readAndRefineBagFields(input, getCalendarFieldNames(calendar, yearMonthCodeFieldNamesAlpha, yearMonthCodeFieldNamesWithEraAlpha), dateFieldRefiners), options);
+function fieldsToYearMonth(calendar, input) {
+  const refinedFields = readAndRefineBagFields(input, getCalendarFieldNames(calendar, yearMonthCodeFieldNamesAlpha, yearMonthCodeFieldNamesWithEraAlpha), dateFieldRefiners);
+  const [year, monthCodeParts] = refineCalendarDateFields(refinedFields, calendar, 1);
+  return createYearMonthFromRefinedFields(refinedFields, calendar, year, monthCodeParts, 0);
 }
 
-function createPlainDateFromMergedFields(calendar, inputFields, extraFields) {
+function mergeFieldsIntoDate(calendar, inputFields, extraFields) {
   const mergedFieldNames = getCalendarFieldNames(calendar, yearMonthCodeDayFieldNamesAlpha, yearMonthCodeDayFieldNamesWithEraAlpha);
   let mergedFields = mergeCalendarFields(calendar, inputFields, extraFields);
-  return mergedFields = readAndRefineBagFields(mergedFields, mergedFieldNames, dateFieldRefiners, []), 
-  createPlainDateFromFields(calendar, mergedFields);
+  mergedFields = readAndRefineBagFields(mergedFields, mergedFieldNames, dateFieldRefiners, []);
+  const [year, monthCodeParts] = refineCalendarDateFields(mergedFields, calendar);
+  return createDateFromRefinedFields(mergedFields, calendar, year, monthCodeParts, 0);
 }
 
 function epochMilliToInstant(epochMilli) {
@@ -6049,24 +6107,24 @@ function createDateTimeFormatShell(createArgsProvider, transformOptions = identi
       const resolvedOptions = baseFormat.resolvedOptions();
       const copiedOptions = pluckProps(observedOptionNames, resolvedOptions);
       internalsMap.set(this, {
-        Z: createArgsProvider({
+        $: createArgsProvider({
           t: baseFormat,
-          ze: resolvedOptions.locale,
-          F: copiedOptions,
-          Ce: transformedOptions
+          Ce: resolvedOptions.locale,
+          G: copiedOptions,
+          Ee: transformedOptions
         }),
         t: baseFormat
       });
     }
     get format() {
       const internals = getInternals(this);
-      return internals.qe || (internals.qe = record => {
-        const [format, ...rest] = internals.Z.A(record);
+      return internals.we || (internals.we = record => {
+        const [format, ...rest] = internals.$.A(record);
         return format.format(...rest);
       });
     }
     formatToParts(record) {
-      const {Z: argsProvider} = getInternals(this);
+      const {$: argsProvider} = getInternals(this);
       const [format, ...rest] = argsProvider.A(record);
       return format.formatToParts(...rest);
     }
@@ -6080,12 +6138,12 @@ function createDateTimeFormatShell(createArgsProvider, transformOptions = identi
   }
   RawDateTimeFormat.prototype.formatRange && Object.defineProperties(prototype, createPropDescriptors({
     formatRange(record0, record1) {
-      const {Z: argsProvider} = getInternals(this);
+      const {$: argsProvider} = getInternals(this);
       const [format, epochMilli0, epochMilli1] = argsProvider.v(record0, record1);
       return format.formatRange(epochMilli0, epochMilli1);
     },
     formatRangeToParts(record0, record1) {
-      const {Z: argsProvider} = getInternals(this);
+      const {$: argsProvider} = getInternals(this);
       const [format, epochMilli0, epochMilli1] = argsProvider.v(record0, record1);
       return format.formatRangeToParts(epochMilli0, epochMilli1);
     }
@@ -6231,11 +6289,89 @@ const dateDerivedGetters = {
   }
 };
 
-function createNativeGetters(shimGetters) {
-  return createPropGetters(Object.keys(shimGetters));
+function diffInstants(invert, instantSlots0, instantSlots1, options) {
+  const [largestUnit, smallestUnit, roundingInc, roundingMode] = refineDiffOptions(invert, options, 3, 5);
+  return createDiffDurationSlots(invert, diffEpochNanosRounded(instantSlots0.epochNanoseconds, instantSlots1.epochNanoseconds, largestUnit, smallestUnit, roundingInc, roundingMode));
+}
+
+function diffZonedDateTimes(invert, slots0, slots1, options) {
+  const calendar = getCommonCalendar(slots0.calendar, slots1.calendar);
+  const [largestUnit, smallestUnit, roundingInc, roundingMode] = refineDiffOptions(invert, options, 5);
+  return createDiffDurationSlots(invert, diffZonedDateTimesRounded(calendar, slots0, slots1, largestUnit, smallestUnit, roundingInc, roundingMode));
+}
+
+function diffDateTimes(invert, plainDateTimeSlots0, plainDateTimeSlots1, options) {
+  const calendar = getCommonCalendar(plainDateTimeSlots0.calendar, plainDateTimeSlots1.calendar);
+  const [largestUnit, smallestUnit, roundingInc, roundingMode] = refineDiffOptions(invert, options, 6);
+  return createDiffDurationSlots(invert, diffDateTimesRounded(calendar, plainDateTimeSlots0, plainDateTimeSlots1, largestUnit, smallestUnit, roundingInc, roundingMode));
+}
+
+function diffDates(invert, plainDateSlots0, plainDateSlots1, options) {
+  const calendar = getCommonCalendar(plainDateSlots0.calendar, plainDateSlots1.calendar);
+  const [largestUnit, smallestUnit, roundingInc, roundingMode] = refineDiffOptions(invert, options, 6, 9, 6);
+  return createDiffDurationSlots(invert, diffDatesRounded(calendar, plainDateSlots0, plainDateSlots1, largestUnit, smallestUnit, roundingInc, roundingMode));
+}
+
+function diffYearMonths(invert, plainYearMonthSlots0, plainYearMonthSlots1, options) {
+  const calendar = getCommonCalendar(plainYearMonthSlots0.calendar, plainYearMonthSlots1.calendar);
+  const [largestUnit, smallestUnit, roundingInc, roundingMode] = refineDiffOptions(invert, options, 9, 9, 8);
+  return createDiffDurationSlots(invert, diffYearMonthsRounded(calendar, plainYearMonthSlots0, plainYearMonthSlots1, largestUnit, smallestUnit, roundingInc, roundingMode));
+}
+
+function diffTimes(invert, plainTimeSlots0, plainTimeSlots1, options) {
+  const [largestUnit, smallestUnit, roundingInc, roundingMode] = refineDiffOptions(invert, options, 5, 5);
+  return createDiffDurationSlots(invert, diffTimesRounded(plainTimeSlots0, plainTimeSlots1, largestUnit, smallestUnit, roundingInc, roundingMode));
+}
+
+function createDiffDurationSlots(invert, durationFields) {
+  return createDurationSlots(invert ? negateDurationFields(durationFields) : durationFields);
+}
+
+function withDateFields(slots, modFields, options) {
+  const {calendar: calendar} = slots;
+  const fields = mergeDateFields(calendar, slots, modFields);
+  const [year, monthCodeParts] = refineCalendarDateFields(fields, calendar);
+  const overflow = refineOverflowOptions(options);
+  return createDateFromRefinedFields(fields, calendar, year, monthCodeParts, overflow);
+}
+
+function withDateTimeFields(slots, modFields, options) {
+  const {calendar: calendar} = slots;
+  const [mergedFields, calendarFields] = mergeDateTimeFields(calendar, slots, modFields);
+  const [year, monthCodeParts] = refineCalendarDateFields(calendarFields, calendar);
+  const overflow = refineOverflowOptions(options);
+  return createDateTimeFromMergedFields(mergedFields, calendarFields, calendar, year, monthCodeParts, overflow);
+}
+
+function withYearMonthFields(slots, modFields, options) {
+  const {calendar: calendar} = slots;
+  const fields = mergeYearMonthFields(calendar, slots, modFields);
+  const [year, monthCodeParts] = refineCalendarDateFields(fields, calendar, 1);
+  const overflow = refineOverflowOptions(options);
+  return createYearMonthFromRefinedFields(fields, calendar, year, monthCodeParts, overflow);
+}
+
+function withMonthDayFields(slots, modFields, options) {
+  const {calendar: calendar} = slots;
+  const fields = mergeMonthDayFields(calendar, slots, modFields);
+  const [year, monthCodeParts] = refineMonthDayFields(fields, calendar);
+  const overflow = refineOverflowOptions(options);
+  return createMonthDayFromRefinedFields(fields, calendar, year, monthCodeParts, overflow);
+}
+
+function withTimeFields(slots, modFields, options) {
+  const refinedFields = mergeTimeFields(slots, modFields);
+  const overflow = refineOverflowOptions(options);
+  return resolveTimeFields(refinedFields, overflow);
 }
 
-createNativeGetters(yearMonthDerivedGetters), createNativeGetters(dateDerivedGetters);
+function withZonedDateTimeFields(slots, modFields, options) {
+  const {calendar: calendar} = slots;
+  const [mergedFields, calendarFields] = mergeZonedDateTimeFields(calendar, slots, modFields);
+  const [year, monthCodeParts] = refineCalendarDateFields(calendarFields, calendar);
+  const [overflow, offsetDisambig, epochDisambig] = refineZonedFieldOptions(options, 2);
+  return createZonedDateTimeFromMergedFields(slots, mergedFields, calendarFields, year, monthCodeParts, overflow, offsetDisambig, epochDisambig);
+}
 
 function createDateTimeFormatClass(getTemporalBrandingAndSlots) {
   return createDateTimeFormatShell(internals => {
@@ -6243,33 +6379,33 @@ function createDateTimeFormatClass(getTemporalBrandingAndSlots) {
       let options;
       switch (branding) {
        case InstantBranding:
-        options = transformInstantOptions(internals.F, 1);
+        options = transformInstantOptions(internals.G, 1);
         break;
 
        case PlainDateTimeBranding:
-        options = applyPlainFormatTimeZone(transformDateTimeOptions(internals.F, 1));
+        options = applyPlainFormatTimeZone(transformDateTimeOptions(internals.G, 1));
         break;
 
        case PlainDateBranding:
-        options = applyPlainFormatTimeZone(transformDateOptions(internals.F, 1));
+        options = applyPlainFormatTimeZone(transformDateOptions(internals.G, 1));
         break;
 
        case PlainTimeBranding:
-        options = applyPlainFormatTimeZone(transformTimeOptions(internals.F, 1));
+        options = applyPlainFormatTimeZone(transformTimeOptions(internals.G, 1));
         break;
 
        case PlainYearMonthBranding:
-        options = applyPlainFormatTimeZone(transformYearMonthOptions(internals.F, 1));
+        options = applyPlainFormatTimeZone(transformYearMonthOptions(internals.G, 1));
         break;
 
        case PlainMonthDayBranding:
-        options = applyPlainFormatTimeZone(transformMonthDayOptions(internals.F, 1));
+        options = applyPlainFormatTimeZone(transformMonthDayOptions(internals.G, 1));
         break;
 
        default:
         throwTypeError(invalidFormatType(branding));
       }
-      return new RawDateTimeFormat(internals.ze, options);
+      return new RawDateTimeFormat(internals.Ce, options);
     });
     return {
       A(formattable) {
@@ -6327,7 +6463,7 @@ function checkTemporalDateTimeFormatCompatible(format, branding, slots) {
 function temporalDateTimeToEpochMilli(branding, slots) {
   switch (branding) {
    case InstantBranding:
-    return getEpochMilli(slots);
+    return epochNanoToMilli(slots.epochNanoseconds);
 
    case PlainDateTimeBranding:
     return isoDateTimeToEpochMilli(slots);
@@ -6376,10 +6512,10 @@ const ZonedDateTime = /*@__PURE__*/ defineTemporalClass(ZonedDateTimeBranding, c
     return getZonedDateTimeSlots(this).timeZone.id;
   }
   get epochMilliseconds() {
-    return getEpochMilli(getZonedDateTimeSlots(this));
+    return epochNanoToMilli(getZonedDateTimeSlots(this).epochNanoseconds);
   }
   get epochNanoseconds() {
-    return getEpochNano(getZonedDateTimeSlots(this));
+    return getZonedDateTimeSlots(this).epochNanoseconds;
   }
   get offset() {
     return formatOffsetNano(zonedEpochSlotsToIso(getZonedDateTimeSlots(this)).offsetNanoseconds);
@@ -6391,7 +6527,7 @@ const ZonedDateTime = /*@__PURE__*/ defineTemporalClass(ZonedDateTimeBranding, c
     return computeZonedHoursInDay(getZonedDateTimeSlots(this));
   }
   with(mod, options = void 0) {
-    return createZonedDateTime(mergeZonedDateTimeFields(getZonedDateTimeSlots(this), validateBag(mod), options));
+    return createZonedDateTime(withZonedDateTimeFields(getZonedDateTimeSlots(this), validateBag(mod), options));
   }
   withCalendar(calendarArg) {
     return createZonedDateTime({
@@ -6410,23 +6546,21 @@ const ZonedDateTime = /*@__PURE__*/ defineTemporalClass(ZonedDateTimeBranding, c
   }
   add(durationArg, options = void 0) {
     const slots = getZonedDateTimeSlots(this);
-    return createZonedDateTime(moveZonedEpochSlots(slots, toDurationSlots(durationArg), options));
+    return createZonedDateTime(moveZonedEpochSlots(slots, toDurationSlots(durationArg), refineOverflowOptions(options)));
   }
   subtract(durationArg, options = void 0) {
     const slots = getZonedDateTimeSlots(this);
-    return createZonedDateTime(moveZonedEpochSlots(slots, negateDurationFields(toDurationSlots(durationArg)), options));
+    return createZonedDateTime(moveZonedEpochSlots(slots, negateDurationFields(toDurationSlots(durationArg)), refineOverflowOptions(options)));
   }
   until(otherArg, options = void 0) {
     const slots = getZonedDateTimeSlots(this);
     const other = toZonedDateTimeSlots(otherArg);
-    const calendar = getCommonCalendar(slots.calendar, other.calendar);
-    return createDuration(createDurationSlots(diffZonedDateTimes(0, calendar, slots, other, options)));
+    return createDuration(diffZonedDateTimes(0, slots, other, options));
   }
   since(otherArg, options = void 0) {
     const slots = getZonedDateTimeSlots(this);
     const other = toZonedDateTimeSlots(otherArg);
-    const calendar = getCommonCalendar(slots.calendar, other.calendar);
-    return createDuration(createDurationSlots(diffZonedDateTimes(1, calendar, slots, other, options)));
+    return createDuration(diffZonedDateTimes(1, slots, other, options));
   }
   round(options) {
     const slots = getZonedDateTimeSlots(this);
@@ -6443,18 +6577,18 @@ const ZonedDateTime = /*@__PURE__*/ defineTemporalClass(ZonedDateTimeBranding, c
     return createInstant(zonedDateTimeToInstant(getZonedDateTimeSlots(this)));
   }
   toPlainDateTime() {
-    return createPlainDateTime(zonedDateTimeToPlainDateTime(getZonedDateTimeSlots(this)));
+    return createPlainDateTime(zonedDateTimeToDateTime(getZonedDateTimeSlots(this)));
   }
   toPlainDate() {
-    return createPlainDate(zonedDateTimeToPlainDate(getZonedDateTimeSlots(this)));
+    return createPlainDate(zonedDateTimeToDate(getZonedDateTimeSlots(this)));
   }
   toPlainTime() {
-    return createPlainTime(zonedDateTimeToPlainTime(getZonedDateTimeSlots(this)));
+    return createPlainTime(zonedDateTimeToTime(getZonedDateTimeSlots(this)));
   }
   toLocaleString(locales = void 0, options = {}) {
     const slots = getZonedDateTimeSlots(this);
     const format = new RawDateTimeFormat(locales, applyZonedFormatTimeZone(transformZonedOptions(options), getZonedTimeZoneId(slots)));
-    return checkResolvedCalendarCompatible(format, slots), format.format(getEpochMilli(slots));
+    return checkResolvedCalendarCompatible(format, slots), format.format(epochNanoToMilli(slots.epochNanoseconds));
   }
   toString(options = void 0) {
     return formatZonedDateTimeIso(getZonedDateTimeSlots(this), options);
@@ -6464,8 +6598,8 @@ const ZonedDateTime = /*@__PURE__*/ defineTemporalClass(ZonedDateTimeBranding, c
   }
   getTimeZoneTransition(options) {
     const slots = getZonedDateTimeSlots(this);
-    const newEpochNano = getTimeZoneTransitionEpochNanoseconds(slots, options);
-    return newEpochNano ? createZonedDateTime({
+    const newEpochNano = slots.timeZone.C(slots.epochNanoseconds, refineDirectionOptions(options));
+    return void 0 !== newEpochNano ? createZonedDateTime({
       ...slots,
       epochNanoseconds: newEpochNano
     }) : null;
@@ -6540,10 +6674,10 @@ const Instant = /*@__PURE__*/ defineTemporalClass(InstantBranding, class {
     return compareZonedEpochSlots(toInstantSlots(a), toInstantSlots(b));
   }
   get epochMilliseconds() {
-    return getEpochMilli(getInstantSlots(this));
+    return epochNanoToMilli(getInstantSlots(this).epochNanoseconds);
   }
   get epochNanoseconds() {
-    return getEpochNano(getInstantSlots(this));
+    return getInstantSlots(this).epochNanoseconds;
   }
   add(durationArg) {
     const slots = getInstantSlots(this);
@@ -6572,7 +6706,7 @@ const Instant = /*@__PURE__*/ defineTemporalClass(InstantBranding, class {
   }
   toLocaleString(locales = void 0, options = {}) {
     const slots = getInstantSlots(this);
-    return new RawDateTimeFormat(locales, transformInstantOptions(options)).format(getEpochMilli(slots));
+    return new RawDateTimeFormat(locales, transformInstantOptions(options)).format(epochNanoToMilli(slots.epochNanoseconds));
   }
   toString(options = void 0) {
     return formatInstantIso(refineTimeZoneArg, getInstantSlots(this), options);
@@ -6644,14 +6778,14 @@ const PlainMonthDay = /*@__PURE__*/ defineTemporalClass(PlainMonthDayBranding, c
     return getCalendarSlotId(getPlainMonthDaySlots(this).calendar);
   }
   with(mod, options = void 0) {
-    return createPlainMonthDay(mergePlainMonthDayFields(getPlainMonthDaySlots(this), validateBag(mod), options));
+    return createPlainMonthDay(withMonthDayFields(getPlainMonthDaySlots(this), validateBag(mod), options));
   }
   equals(otherArg) {
     return plainMonthDaysEqual(getPlainMonthDaySlots(this), toPlainMonthDaySlots(otherArg));
   }
   toPlainDate(bag) {
     const slots = getPlainMonthDaySlots(this);
-    return createPlainDate(convertPlainMonthDayToDate(slots.calendar, this, bag));
+    return createPlainDate(monthDayToDate(slots.calendar, this, bag));
   }
   toLocaleString(locales = void 0, options = {}) {
     const slots = getPlainMonthDaySlots(this);
@@ -6724,34 +6858,32 @@ const PlainYearMonth = /*@__PURE__*/ defineTemporalClass(PlainYearMonthBranding,
     return getCalendarSlotId(getPlainYearMonthSlots(this).calendar);
   }
   with(mod, options = void 0) {
-    return createPlainYearMonth(mergePlainYearMonthFields(getPlainYearMonthSlots(this), validateBag(mod), options));
+    return createPlainYearMonth(withYearMonthFields(getPlainYearMonthSlots(this), validateBag(mod), options));
   }
   add(durationArg, options = void 0) {
     const slots = getPlainYearMonthSlots(this);
-    return createPlainYearMonth(createDateSlots(moveYearMonth(0, slots.calendar, slots, toDurationSlots(durationArg), options), slots.calendar));
+    return createPlainYearMonth(createDateSlots(moveYearMonth(slots.calendar, slots, toDurationSlots(durationArg), refineOverflowOptions(options)), slots.calendar));
   }
   subtract(durationArg, options = void 0) {
     const slots = getPlainYearMonthSlots(this);
-    return createPlainYearMonth(createDateSlots(moveYearMonth(1, slots.calendar, slots, toDurationSlots(durationArg), options), slots.calendar));
+    return createPlainYearMonth(createDateSlots(moveYearMonth(slots.calendar, slots, negateDurationFields(toDurationSlots(durationArg)), refineOverflowOptions(options)), slots.calendar));
   }
   until(otherArg, options = void 0) {
     const slots = getPlainYearMonthSlots(this);
     const other = toPlainYearMonthSlots(otherArg);
-    const calendar = getCommonCalendar(slots.calendar, other.calendar);
-    return createDuration(diffPlainYearMonth(0, calendar, slots, other, options));
+    return createDuration(diffYearMonths(0, slots, other, options));
   }
   since(otherArg, options = void 0) {
     const slots = getPlainYearMonthSlots(this);
     const other = toPlainYearMonthSlots(otherArg);
-    const calendar = getCommonCalendar(slots.calendar, other.calendar);
-    return createDuration(diffPlainYearMonth(1, calendar, slots, other, options));
+    return createDuration(diffYearMonths(1, slots, other, options));
   }
   equals(otherArg) {
     return plainYearMonthsEqual(getPlainYearMonthSlots(this), toPlainYearMonthSlots(otherArg));
   }
   toPlainDate(bag) {
     const slots = getPlainYearMonthSlots(this);
-    return createPlainDate(convertPlainYearMonthToDate(slots.calendar, this, bag));
+    return createPlainDate(yearMonthToDate(slots.calendar, this, bag));
   }
   toLocaleString(locales = void 0, options = {}) {
     const slots = getPlainYearMonthSlots(this);
@@ -6840,7 +6972,7 @@ const PlainTime = /*@__PURE__*/ defineTemporalClass(PlainTimeBranding, class {
     return compareTimeFields(toPlainTimeSlots(arg0), toPlainTimeSlots(arg1));
   }
   with(mod, options = void 0) {
-    return createPlainTime(mergePlainTimeFields(getPlainTimeSlots(this), validateBag(mod), options));
+    return createPlainTime(withTimeFields(getPlainTimeSlots(this), validateBag(mod), options));
   }
   add(durationArg) {
     const slots = getPlainTimeSlots(this);
@@ -6851,15 +6983,15 @@ const PlainTime = /*@__PURE__*/ defineTemporalClass(PlainTimeBranding, class {
     return createPlainTime(moveTime(slots, negateDurationFields(toDurationSlots(durationArg)))[0]);
   }
   until(otherArg, options = void 0) {
-    return createDuration(diffPlainTimes(0, getPlainTimeSlots(this), toPlainTimeSlots(otherArg), options));
+    return createDuration(diffTimes(0, getPlainTimeSlots(this), toPlainTimeSlots(otherArg), options));
   }
   since(otherArg, options = void 0) {
-    return createDuration(diffPlainTimes(1, getPlainTimeSlots(this), toPlainTimeSlots(otherArg), options));
+    return createDuration(diffTimes(1, getPlainTimeSlots(this), toPlainTimeSlots(otherArg), options));
   }
   round(options) {
     const slots = getPlainTimeSlots(this);
     const [smallestUnit, roundingInc, roundingMode] = refineRoundingOptions(options, 5);
-    return createPlainTime(roundTimeToNano(slots, computeNanoInc(smallestUnit, roundingInc), roundingMode)[0]);
+    return createPlainTime(roundTimeToInc(slots, computeNanoInc(smallestUnit, roundingInc), roundingMode)[0]);
   }
   equals(other) {
     return plainTimesEqual(getPlainTimeSlots(this), toPlainTimeSlots(other));
@@ -6902,7 +7034,7 @@ function toPlainTimeSlots(arg, options) {
       return refineOverflowOptions(options), createTimeSlots(dateTimeSlots);
     }
     const zonedDateTimeSlots = getZonedDateTimeSlotsIfPresent(arg);
-    return zonedDateTimeSlots ? (refineOverflowOptions(options), zonedDateTimeToPlainTime(zonedDateTimeSlots)) : refinePlainTimeObjectLike(arg, options);
+    return zonedDateTimeSlots ? (refineOverflowOptions(options), zonedDateTimeToTime(zonedDateTimeSlots)) : refinePlainTimeObjectLike(arg, options);
   }
   const timeSlots = parsePlainTime(arg);
   return refineOverflowOptions(options), timeSlots;
@@ -6946,7 +7078,7 @@ const PlainDateTime = /*@__PURE__*/ defineTemporalClass(PlainDateTimeBranding, c
     return getCalendarSlotId(getPlainDateTimeSlots(this).calendar);
   }
   with(mod, options = void 0) {
-    return createPlainDateTime(mergePlainDateTimeFields(getPlainDateTimeSlots(this), validateBag(mod), options));
+    return createPlainDateTime(withDateTimeFields(getPlainDateTimeSlots(this), validateBag(mod), options));
   }
   withCalendar(calendarArg) {
     const slots = getPlainDateTimeSlots(this);
@@ -6954,38 +7086,36 @@ const PlainDateTime = /*@__PURE__*/ defineTemporalClass(PlainDateTimeBranding, c
   }
   withPlainTime(plainTimeArg = void 0) {
     const slots = getPlainDateTimeSlots(this);
-    return createPlainDateTime(createPlainDateTimeFromRefinedFields(slots, optionalToPlainTimeFields(plainTimeArg), slots.calendar));
+    return createPlainDateTime(createDateTimeFromRefinedFields(slots, optionalToPlainTimeFields(plainTimeArg), slots.calendar));
   }
   add(durationArg, options = void 0) {
     const slots = getPlainDateTimeSlots(this);
-    return createPlainDateTime(createDateTimeSlots(moveDateTime(slots.calendar, slots, toDurationSlots(durationArg), options), slots.calendar));
+    return createPlainDateTime(createDateTimeSlots(moveDateTime(slots.calendar, slots, toDurationSlots(durationArg), refineOverflowOptions(options)), slots.calendar));
   }
   subtract(durationArg, options = void 0) {
     const slots = getPlainDateTimeSlots(this);
-    return createPlainDateTime(createDateTimeSlots(moveDateTime(slots.calendar, slots, negateDurationFields(toDurationSlots(durationArg)), options), slots.calendar));
+    return createPlainDateTime(createDateTimeSlots(moveDateTime(slots.calendar, slots, negateDurationFields(toDurationSlots(durationArg)), refineOverflowOptions(options)), slots.calendar));
   }
   until(otherArg, options = void 0) {
     const slots = getPlainDateTimeSlots(this);
     const other = toPlainDateTimeSlots(otherArg);
-    const calendar = getCommonCalendar(slots.calendar, other.calendar);
-    return createDuration(diffPlainDateTimes(0, calendar, slots, other, options));
+    return createDuration(diffDateTimes(0, slots, other, options));
   }
   since(otherArg, options = void 0) {
     const slots = getPlainDateTimeSlots(this);
     const other = toPlainDateTimeSlots(otherArg);
-    const calendar = getCommonCalendar(slots.calendar, other.calendar);
-    return createDuration(diffPlainDateTimes(1, calendar, slots, other, options));
+    return createDuration(diffDateTimes(1, slots, other, options));
   }
   round(options) {
     const slots = getPlainDateTimeSlots(this);
     const [smallestUnit, roundingInc, roundingMode] = refineRoundingOptions(options);
-    return createPlainDateTime(createDateTimeSlots(roundDateTimeToNano(slots, computeNanoInc(smallestUnit, roundingInc), roundingMode), slots.calendar));
+    return createPlainDateTime(createDateTimeSlots(roundDateTimeToInc(slots, computeNanoInc(smallestUnit, roundingInc), roundingMode), slots.calendar));
   }
   equals(otherArg) {
     return plainDateTimesEqual(getPlainDateTimeSlots(this), toPlainDateTimeSlots(otherArg));
   }
   toZonedDateTime(timeZoneArg, options = void 0) {
-    return createZonedDateTime(plainDateTimeToZonedDateTime(getPlainDateTimeSlots(this), queryTimeZone(refineTimeZoneArg(timeZoneArg)), options));
+    return createZonedDateTime(dateTimeToZonedDateTime(getPlainDateTimeSlots(this), queryTimeZone(refineTimeZoneArg(timeZoneArg)), refineEpochDisambigOptions(options)));
   }
   toPlainDate() {
     const slots = getPlainDateTimeSlots(this);
@@ -7034,7 +7164,7 @@ function toPlainDateTimeSlots(arg, options) {
     }
     const zonedDateTimeSlots = getZonedDateTimeSlotsIfPresent(arg);
     if (zonedDateTimeSlots) {
-      return refineOverflowOptions(options), zonedDateTimeToPlainDateTime(zonedDateTimeSlots);
+      return refineOverflowOptions(options), zonedDateTimeToDateTime(zonedDateTimeSlots);
     }
     const calendar = getCalendarFromBag(arg);
     return refinePlainDateTimeObjectLike(calendar, arg, options);
@@ -7070,8 +7200,7 @@ const PlainDate = /*@__PURE__*/ defineTemporalClass(PlainDateBranding, class {
     return getCalendarSlotId(getPlainDateSlots(this).calendar);
   }
   with(mod, options = void 0) {
-    const slots = getPlainDateSlots(this);
-    return createPlainDate(mergePlainDateFields(slots, validateBag(mod), options));
+    return createPlainDate(withDateFields(getPlainDateSlots(this), validateBag(mod), options));
   }
   withCalendar(calendarArg) {
     const slots = getPlainDateSlots(this);
@@ -7079,23 +7208,21 @@ const PlainDate = /*@__PURE__*/ defineTemporalClass(PlainDateBranding, class {
   }
   add(durationArg, options = void 0) {
     const slots = getPlainDateSlots(this);
-    return createPlainDate(createDateSlots(moveDate(slots.calendar, slots, toDurationSlots(durationArg), options), slots.calendar));
+    return createPlainDate(createDateSlots(moveDate(slots.calendar, slots, toDurationSlots(durationArg), refineOverflowOptions(options)), slots.calendar));
   }
   subtract(durationArg, options = void 0) {
     const slots = getPlainDateSlots(this);
-    return createPlainDate(createDateSlots(moveDate(slots.calendar, slots, negateDurationFields(toDurationSlots(durationArg)), options), slots.calendar));
+    return createPlainDate(createDateSlots(moveDate(slots.calendar, slots, negateDurationFields(toDurationSlots(durationArg)), refineOverflowOptions(options)), slots.calendar));
   }
   until(otherArg, options = void 0) {
     const slots = getPlainDateSlots(this);
     const other = toPlainDateSlots(otherArg);
-    const calendar = getCommonCalendar(slots.calendar, other.calendar);
-    return createDuration(diffPlainDates(0, calendar, slots, other, options));
+    return createDuration(diffDates(0, slots, other, options));
   }
   since(otherArg, options = void 0) {
     const slots = getPlainDateSlots(this);
     const other = toPlainDateSlots(otherArg);
-    const calendar = getCommonCalendar(slots.calendar, other.calendar);
-    return createDuration(diffPlainDates(1, calendar, slots, other, options));
+    return createDuration(diffDates(1, slots, other, options));
   }
   equals(otherArg) {
     return plainDatesEqual(getPlainDateSlots(this), toPlainDateSlots(otherArg));
@@ -7107,19 +7234,23 @@ const PlainDate = /*@__PURE__*/ defineTemporalClass(PlainDateBranding, class {
     } : {
       timeZone: options
     };
-    return createZonedDateTime(plainDateToZonedDateTime(refineTimeZoneArg, toPlainTimeSlots, getPlainDateSlots(this), optionsObj));
+    const slots = getPlainDateSlots(this);
+    const timeZoneId = refineTimeZoneArg(optionsObj.timeZone);
+    const plainTimeArg = optionsObj.plainTime;
+    const timeFields = void 0 !== plainTimeArg ? toPlainTimeSlots(plainTimeArg) : void 0;
+    return createZonedDateTime(dateToZonedDateTime(slots, queryTimeZone(timeZoneId), timeFields));
   }
   toPlainDateTime(plainTimeArg = void 0) {
     const slots = getPlainDateSlots(this);
-    return createPlainDateTime(createPlainDateTimeFromRefinedFields(slots, optionalToPlainTimeFields(plainTimeArg), slots.calendar));
+    return createPlainDateTime(createDateTimeFromRefinedFields(slots, optionalToPlainTimeFields(plainTimeArg), slots.calendar));
   }
   toPlainYearMonth() {
     const slots = getPlainDateSlots(this);
-    return createPlainYearMonth(convertToPlainYearMonth(slots.calendar, this));
+    return createPlainYearMonth(fieldsToYearMonth(slots.calendar, this));
   }
   toPlainMonthDay() {
     const slots = getPlainDateSlots(this);
-    return createPlainMonthDay(convertToPlainMonthDay(slots.calendar, this));
+    return createPlainMonthDay(fieldsToMonthDay(slots.calendar, this));
   }
   toLocaleString(locales = void 0, options = {}) {
     const slots = getPlainDateSlots(this);
@@ -7161,7 +7292,7 @@ function toPlainDateSlots(arg, options) {
     }
     const zonedDateTimeSlots = getZonedDateTimeSlotsIfPresent(arg);
     if (zonedDateTimeSlots) {
-      return refineOverflowOptions(options), zonedDateTimeToPlainDate(zonedDateTimeSlots);
+      return refineOverflowOptions(options), zonedDateTimeToDate(zonedDateTimeSlots);
     }
     const calendar = getCalendarFromBag(arg);
     return refinePlainDateObjectLike(calendar, arg, options);
@@ -7233,11 +7364,11 @@ const Duration = /*@__PURE__*/ defineTemporalClass(DurationBranding, class {
   abs() {
     return createDuration(absDuration(getDurationSlots(this)));
   }
-  add(otherArg, options = void 0) {
-    return createDuration(addDurations(refinePublicRelativeTo, 0, getDurationSlots(this), toDurationSlots(otherArg), options));
+  add(otherArg) {
+    return createDuration(addDurationsWithoutRelativeTo(0, getDurationSlots(this), toDurationSlots(otherArg)));
   }
-  subtract(otherArg, options = void 0) {
-    return createDuration(addDurations(refinePublicRelativeTo, 1, getDurationSlots(this), toDurationSlots(otherArg), options));
+  subtract(otherArg) {
+    return createDuration(addDurationsWithoutRelativeTo(1, getDurationSlots(this), toDurationSlots(otherArg)));
   }
   round(roundTo) {
     return createDuration(roundDuration(refinePublicRelativeTo, getDurationSlots(this), roundTo));
@@ -11520,14 +11651,14 @@ const Kislev = months.KISLEV;
 const Shvat = months.SHVAT;
 const Adar2 = months.ADAR_II;
 const CHAG$1 = flags.CHAG;
-const LIGHT_CANDLES$3 = flags.LIGHT_CANDLES;
+const LIGHT_CANDLES$2 = flags.LIGHT_CANDLES;
 const YOM_TOV_ENDS$1 = flags.YOM_TOV_ENDS;
 const CHUL_ONLY$1 = flags.CHUL_ONLY;
 const IL_ONLY$2 = flags.IL_ONLY;
 const LIGHT_CANDLES_TZEIS$3 = flags.LIGHT_CANDLES_TZEIS;
 const MAJOR_FAST$2 = flags.MAJOR_FAST;
 const MINOR_HOLIDAY$2 = flags.MINOR_HOLIDAY;
-const EREV$3 = flags.EREV;
+const EREV$2 = flags.EREV;
 const CHOL_HAMOED$1 = flags.CHOL_HAMOED;
 const emojiPesach = '🫓';
 const emojiSukkot = '🌿🍋';
@@ -11763,7 +11894,7 @@ const staticHolidays = [
         flags: CHAG$1 | YOM_TOV_ENDS$1,
         emoji: '🍏🍯',
     },
-    { mm: Tishrei, dd: 9, desc: EREV_YOM_KIPPUR, flags: EREV$3 | LIGHT_CANDLES$3 },
+    { mm: Tishrei, dd: 9, desc: EREV_YOM_KIPPUR, flags: EREV$2 | LIGHT_CANDLES$2 },
     {
         mm: Tishrei,
         dd: 10,
@@ -11774,7 +11905,7 @@ const staticHolidays = [
         mm: Tishrei,
         dd: 14,
         desc: EREV_SUKKOT,
-        flags: CHUL_ONLY$1 | EREV$3 | LIGHT_CANDLES$3,
+        flags: CHUL_ONLY$1 | EREV$2 | LIGHT_CANDLES$2,
         emoji: emojiSukkot,
     },
     {
@@ -11839,7 +11970,7 @@ const staticHolidays = [
         mm: Tishrei,
         dd: 14,
         desc: EREV_SUKKOT,
-        flags: IL_ONLY$2 | EREV$3 | LIGHT_CANDLES$3,
+        flags: IL_ONLY$2 | EREV$2 | LIGHT_CANDLES$2,
         emoji: emojiSukkot,
     },
     {
@@ -11899,7 +12030,7 @@ const staticHolidays = [
         mm: Tishrei,
         dd: 21,
         desc: SUKKOT_VII_HOSHANA_RABA,
-        flags: LIGHT_CANDLES$3 | CHOL_HAMOED$1,
+        flags: LIGHT_CANDLES$2 | CHOL_HAMOED$1,
         chmDay: -1,
         emoji: emojiSukkot,
     },
@@ -11908,7 +12039,7 @@ const staticHolidays = [
         mm: Adar2,
         dd: 13,
         desc: EREV_PURIM,
-        flags: EREV$3 | MINOR_HOLIDAY$2,
+        flags: EREV$2 | MINOR_HOLIDAY$2,
         emoji: '🎭️📜',
     },
     { mm: Adar2, dd: 14, desc: PURIM, flags: MINOR_HOLIDAY$2, emoji: '🎭️📜' },
@@ -11924,7 +12055,7 @@ const staticHolidays = [
         mm: Nisan,
         dd: 14,
         desc: EREV_PESACH,
-        flags: IL_ONLY$2 | EREV$3 | LIGHT_CANDLES$3,
+        flags: IL_ONLY$2 | EREV$2 | LIGHT_CANDLES$2,
         emoji: '🫓🍷',
     },
     {
@@ -11970,7 +12101,7 @@ const staticHolidays = [
         mm: Nisan,
         dd: 20,
         desc: PESACH_VI_CHM,
-        flags: IL_ONLY$2 | CHOL_HAMOED$1 | LIGHT_CANDLES$3,
+        flags: IL_ONLY$2 | CHOL_HAMOED$1 | LIGHT_CANDLES$2,
         chmDay: 5,
         emoji: emojiPesach,
     },
@@ -11986,7 +12117,7 @@ const staticHolidays = [
         mm: Nisan,
         dd: 14,
         desc: EREV_PESACH,
-        flags: CHUL_ONLY$1 | EREV$3 | LIGHT_CANDLES$3,
+        flags: CHUL_ONLY$1 | EREV$2 | LIGHT_CANDLES$2,
         emoji: '🫓🍷',
     },
     {
@@ -12031,7 +12162,7 @@ const staticHolidays = [
         mm: Nisan,
         dd: 20,
         desc: PESACH_VI_CHM,
-        flags: CHUL_ONLY$1 | CHOL_HAMOED$1 | LIGHT_CANDLES$3,
+        flags: CHUL_ONLY$1 | CHOL_HAMOED$1 | LIGHT_CANDLES$2,
         chmDay: 4,
         emoji: emojiPesach,
     },
@@ -12055,7 +12186,7 @@ const staticHolidays = [
         mm: Sivan,
         dd: 5,
         desc: EREV_SHAVUOT,
-        flags: EREV$3 | LIGHT_CANDLES$3,
+        flags: EREV$2 | LIGHT_CANDLES$2,
         emoji: '⛰️🌸',
     },
     {
@@ -12091,7 +12222,7 @@ const staticHolidays = [
         mm: Elul,
         dd: 29,
         desc: EREV_ROSH_HASHANA,
-        flags: EREV$3 | LIGHT_CANDLES$3,
+        flags: EREV$2 | LIGHT_CANDLES$2,
         emoji: '🍏🍯',
     },
 ];
@@ -12203,7 +12334,7 @@ class HolidayEvent extends Event {
             urlFriendly(this.basename()) +
             '-' +
             this.urlDateSuffix();
-        return this.getFlags() & flags.IL_ONLY ? url + '?i=on' : url;
+        return this.hasFlag('IL_ONLY') ? url + '?i=on' : url;
     }
     /**
      * The date portion of {@link url}. For most holidays this is just the
@@ -12217,7 +12348,7 @@ class HolidayEvent extends Event {
         if (this.emoji) {
             return this.emoji;
         }
-        if (this.getFlags() & flags.SPECIAL_SHABBAT) {
+        if (this.hasFlag('SPECIAL_SHABBAT')) {
             return '🕍';
         }
         return '✡️';
@@ -12460,7 +12591,7 @@ const SPECIAL_SHABBAT$1 = flags.SPECIAL_SHABBAT;
 const MODERN_HOLIDAY$1 = flags.MODERN_HOLIDAY;
 const MAJOR_FAST$1 = flags.MAJOR_FAST;
 const MINOR_HOLIDAY$1 = flags.MINOR_HOLIDAY;
-const EREV$2 = flags.EREV;
+const EREV$1 = flags.EREV;
 const SUN = 0;
 const TUE = 2;
 const THU = 4;
@@ -12503,7 +12634,7 @@ function getHolidaysForYear_(year) {
             const key = ev.date.toString();
             const arr = map.get(key);
             if (typeof arr === 'object') {
-                if (arr[0].getFlags() & EREV$2) {
+                if (arr[0].hasFlag('EREV')) {
                     arr.unshift(ev);
                 }
                 else {
@@ -12536,7 +12667,7 @@ function getHolidaysForYear_(year) {
         ? new HDate(1, TEVET, year)
         : new HDate(30, KISLEV, year);
     add(new HolidayEvent(rchTevet, holidayDesc.CHAG_HABANOT, MINOR_HOLIDAY$1));
-    add(new ChanukahEvent(new HDate(24, KISLEV, year), holidayDesc.CHANUKAH_1_CANDLE, EREV$2 | MINOR_HOLIDAY$1 | CHANUKAH_CANDLES$1, undefined));
+    add(new ChanukahEvent(new HDate(24, KISLEV, year), holidayDesc.CHANUKAH_1_CANDLE, EREV$1 | MINOR_HOLIDAY$1 | CHANUKAH_CANDLES$1, undefined));
     // yes, we know Kislev 30-32 are wrong
     // HDate() corrects the month automatically
     for (let candles = 2; candles <= 8; candles++) {
@@ -12606,7 +12737,7 @@ function getHolidaysForYear_(year) {
         av9title += ' (observed)';
     }
     const av9abs = av9dt.abs();
-    add(new HolidayEvent(new HDate(HDate.dayOnOrBefore(SAT$2, av9abs)), holidayDesc.SHABBAT_CHAZON, SPECIAL_SHABBAT$1), new HolidayEvent(av9dt.prev(), holidayDesc.EREV_TISHA_BAV, EREV$2 | MAJOR_FAST$1, av9attrs), new HolidayEvent(av9dt, av9title, MAJOR_FAST$1, av9attrs), new HolidayEvent(new HDate(HDate.dayOnOrBefore(SAT$2, av9abs + 7)), holidayDesc.SHABBAT_NACHAMU, SPECIAL_SHABBAT$1));
+    add(new HolidayEvent(new HDate(HDate.dayOnOrBefore(SAT$2, av9abs)), holidayDesc.SHABBAT_CHAZON, SPECIAL_SHABBAT$1), new HolidayEvent(av9dt.prev(), holidayDesc.EREV_TISHA_BAV, EREV$1 | MAJOR_FAST$1, av9attrs), new HolidayEvent(av9dt, av9title, MAJOR_FAST$1, av9attrs), new HolidayEvent(new HDate(HDate.dayOnOrBefore(SAT$2, av9abs + 7)), holidayDesc.SHABBAT_NACHAMU, SPECIAL_SHABBAT$1));
     const monthsInYear = HDate.monthsInYear(year);
     for (let month = 1; month <= monthsInYear; month++) {
         const monthName = HDate.getMonthName(month, year);
@@ -12721,12 +12852,11 @@ function getHolidaysForYearArray(year, il) {
     return events;
 }
 
-const LIGHT_CANDLES$2 = flags.LIGHT_CANDLES | flags.LIGHT_CANDLES_TZEIS;
 function isTomorrowShabbosOrYomTov(dow, events) {
     if (dow === 5) {
         return true;
     }
-    const erev = events.find(ev => ev.getFlags() & LIGHT_CANDLES$2);
+    const erev = events.find(ev => ev.hasAnyFlag('LIGHT_CANDLES', 'LIGHT_CANDLES_TZEIS'));
     if (erev) {
         return true;
     }
@@ -12744,7 +12874,7 @@ function isTodayAssurBemelacha(dow, events) {
     if (dow === 6) {
         return true;
     }
-    const chag = events.find(ev => ev.getFlags() & flags.CHAG);
+    const chag = events.find(ev => ev.hasFlag('CHAG'));
     if (chag) {
         return true;
     }
@@ -12859,8 +12989,6 @@ function isAveilut(date) {
     return isSefiratHaOmer(hd) || isBeinHaMetzarim(hd);
 }
 
-const FAST_DAY = flags.MAJOR_FAST | flags.MINOR_FAST;
-const EREV$1 = flags.EREV;
 /**
  * Returns `true` if the given date is observed as a major or minor fast day.
  *
@@ -12882,10 +13010,7 @@ const EREV$1 = flags.EREV;
  */
 function isFastDay(date, il) {
     const events = getHolidaysOnDate(date, il) || [];
-    const fastDay = events.find(ev => {
-        const mask = ev.getFlags();
-        return mask & FAST_DAY && !(mask & EREV$1);
-    });
+    const fastDay = events.find(ev => ev.hasAnyFlag('MAJOR_FAST', 'MINOR_FAST') && !ev.hasFlag('EREV'));
     return Boolean(fastDay);
 }
 
@@ -13023,14 +13148,14 @@ const LIGHT_CANDLES_TZEIS$1 = flags.LIGHT_CANDLES_TZEIS;
 function makeCandleEvent(ev, hd, options, isFriday, isSaturday) {
     let havdalahTitle = false;
     let useHavdalahOffset = isSaturday;
-    let mask = ev ? ev.getFlags() : LIGHT_CANDLES$1;
+    let mask = ev ? ev.mask : LIGHT_CANDLES$1;
     if (ev !== undefined) {
         // if linked event && dow == FRI, use Candle lighting time & title
         if (!isFriday) {
-            if (mask & (LIGHT_CANDLES_TZEIS$1 | flags.CHANUKAH_CANDLES)) {
+            if (ev.hasAnyFlag('LIGHT_CANDLES_TZEIS', 'CHANUKAH_CANDLES')) {
                 useHavdalahOffset = true;
             }
-            else if (mask & flags.YOM_TOV_ENDS) {
+            else if (ev.hasFlag('YOM_TOV_ENDS')) {
                 havdalahTitle = true;
                 useHavdalahOffset = true;
             }
@@ -13134,7 +13259,7 @@ function makeFastEndTime(zmanim, isTishaBav, options) {
  */
 class FastDayEvent extends HolidayEvent {
     constructor(linkedEvent, startEvent, endEvent) {
-        super(linkedEvent.getDate(), linkedEvent.getDesc(), linkedEvent.getFlags());
+        super(linkedEvent.getDate(), linkedEvent.getDesc(), linkedEvent.mask);
         this.linkedEvent = linkedEvent;
         this.startEvent = startEvent;
         this.endEvent = endEvent;
@@ -13210,7 +13335,7 @@ function makeFastStartEnd(ev, options) {
 function makeTimedEvent(ev, time, desc, options) {
     const location = options.location;
     const hd = ev.getDate();
-    return new TimedEvent(hd, desc, ev.getFlags(), time, location, ev, options);
+    return new TimedEvent(hd, desc, ev.mask, time, location, ev, options);
 }
 /**
  * A Chanukah candle-lighting event that carries a specific time of day.
@@ -13229,7 +13354,7 @@ class TimedChanukahEvent extends ChanukahEvent {
      * @param location location used to format the time
      */
     constructor(ev, eventTime, location) {
-        super(ev.getDate(), ev.getDesc(), ev.getFlags(), ev.chanukahDay);
+        super(ev.getDate(), ev.getDesc(), ev.mask, ev.chanukahDay);
         this.eventTime = Zmanim.roundTime(eventTime);
         const timeFormat = location.getTimeFormatter();
         this.eventTimeStr = Zmanim.formatTime(this.eventTime, timeFormat);
@@ -14711,7 +14836,6 @@ function getMaskFromOptions(options) {
     }
     return mask;
 }
-const MASK_LIGHT_CANDLES = LIGHT_CANDLES | LIGHT_CANDLES_TZEIS | CHANUKAH_CANDLES | YOM_TOV_ENDS;
 const defaultLocation = new Location(0, 0, false, 'UTC');
 /**
  * @private
@@ -14765,10 +14889,12 @@ function appendHolidayAndRelated(candlesEv, events, ev, options, isFriday, isSat
     if (!ev.observedIn(il)) {
         return candlesEv; // holiday isn't observed here; bail out early
     }
-    const eFlags = ev.getFlags();
-    if ((!options.yomKippurKatan && eFlags & YOM_KIPPUR_KATAN) ||
-        (!options.behab && eFlags & BEHAB) ||
-        (options.noModern && eFlags & MODERN_HOLIDAY)) {
+    const eFlags = ev.mask;
+    const isYomKippurKatan = ev.hasFlag('YOM_KIPPUR_KATAN');
+    const isBehab = ev.hasFlag('BEHAB');
+    if ((!options.yomKippurKatan && isYomKippurKatan) ||
+        (!options.behab && isBehab) ||
+        (options.noModern && ev.hasFlag('MODERN_HOLIDAY'))) {
         return candlesEv; // bail out early
     }
     if (options.candlelighting && ev.getDesc() === holidayDesc.EREV_PESACH) {
@@ -14777,8 +14903,10 @@ function appendHolidayAndRelated(candlesEv, events, ev, options, isFriday, isSat
             events.push(...evts);
         }
     }
-    const isMajorFast = Boolean(eFlags & MAJOR_FAST);
-    const isMinorFast = Boolean(eFlags & MINOR_FAST);
+    const isMajorFast = ev.hasFlag('MAJOR_FAST');
+    const isMinorFast = ev.hasFlag('MINOR_FAST');
+    const isChanukah = ev.hasFlag('CHANUKAH_CANDLES');
+    const hasCandles = ev.hasAnyFlag('LIGHT_CANDLES', 'LIGHT_CANDLES_TZEIS', 'CHANUKAH_CANDLES', 'YOM_TOV_ENDS');
     let fastEv;
     if (options.candlelighting &&
         (isMajorFast || isMinorFast) &&
@@ -14790,10 +14918,10 @@ function appendHolidayAndRelated(candlesEv, events, ev, options, isFriday, isSat
         }
     }
     if (eFlags & Number(options.mask) || (!eFlags && !hasUserMask)) {
-        if (options.candlelighting && eFlags & MASK_LIGHT_CANDLES) {
+        if (options.candlelighting && hasCandles) {
             const hd = ev.getDate();
             candlesEv = makeCandleEvent(ev, hd, options, isFriday, isSaturday);
-            if (eFlags & CHANUKAH_CANDLES && candlesEv && !options.noHolidays) {
+            if (isChanukah && candlesEv && !options.noHolidays) {
                 // Replace Chanukah event with a clone that includes candle lighting time.
                 // For clarity, allow a "duplicate" candle lighting event to remain for Shabbat
                 const chanukahEv = makeWeekdayChanukahCandleLighting(ev, options);
@@ -14808,8 +14936,8 @@ function appendHolidayAndRelated(candlesEv, events, ev, options, isFriday, isSat
             }
         }
         if (!options.noHolidays ||
-            (options.yomKippurKatan && eFlags & YOM_KIPPUR_KATAN) ||
-            (options.behab && eFlags & BEHAB)) {
+            (options.yomKippurKatan && isYomKippurKatan) ||
+            (options.behab && isBehab)) {
             events.push(ev); // the original event itself
         }
     }
@@ -14921,18 +15049,17 @@ function hallel_(events, hdate) {
         const desc = ev.getDesc();
         const month = hd.getMonth();
         const mday = hd.getDate();
-        const mask = ev.getFlags();
         if (desc.startsWith('Chanukah') ||
             desc.startsWith('Shavuot') ||
             desc.startsWith('Sukkot') ||
             (month === months.NISAN &&
                 (mday === 15 || mday === 16) &&
-                mask & flags.CHAG) || // Pesach
+                ev.hasFlag('CHAG')) || // Pesach
             desc === holidayDesc.YOM_HAATZMA_UT ||
             desc === holidayDesc.YOM_YERUSHALAYIM) {
             return WHOLE;
         }
-        if (mask & flags.ROSH_CHODESH ||
+        if (ev.hasFlag('ROSH_CHODESH') ||
             (desc.startsWith('Pesach') &&
                 desc !== holidayDesc.PESACH_I &&
                 desc !== holidayDesc.PESACH_II)) {
@@ -15073,8 +15200,8 @@ class HebrewCalendar {
     }
     /**
      * Lower-level holidays interface, which returns a `Map` of `Event`s indexed by
-     * `HDate.toString()`. These events must be filtered for `flags.IL_ONLY`
-     * or `flags.CHUL_ONLY` depending on Israel vs. Diaspora holiday scheme.
+     * `HDate.toString()`. These events are not filtered by Israel vs. Diaspora
+     * holiday scheme; use {@link Event.observedIn} to do that.
      *
      * Includes Rosh Chodesh, fasts, Yom Kippur Katan, Special Shabbatot, etc.,
      * but does not generate candle-lighting times, Torah readings, or Omer days.
@@ -15269,7 +15396,7 @@ class HebrewCalendar {
  */
 function isChag(date, il) {
     const events = getHolidaysOnDate(date, il) || [];
-    const chag = events.filter(ev => ev.getFlags() & flags.CHAG);
+    const chag = events.filter(ev => ev.hasFlag('CHAG'));
     return chag.length !== 0;
 }