@hebcal/core 5.2.2 → 5.3.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-/*! @hebcal/core v5.2.2 */
+/*! @hebcal/core v5.3.0 */
 /** @private */
 const lengths = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
 /** @private */
@@ -2026,18 +2026,18 @@ class HebrewDateEvent extends Event {
   }
 }
 
-function clampEntity(e, n, t, o, r) {
-  const i = clampNumber(n, t, o);
-  if (r && n !== i) {
-    throw new RangeError(numberOutOfRange(e, n, t, o));
-  }
-  return i;
-}
-
 function clampProp(e, n, t, o, r) {
   return clampEntity(n, getDefinedProp(e, n), t, o, r);
 }
 
+function clampEntity(e, n, t, o, r, i) {
+  const a = clampNumber(n, t, o);
+  if (r && n !== a) {
+    throw new RangeError(numberOutOfRange(e, n, t, o, i));
+  }
+  return a;
+}
+
 function getDefinedProp(e, n) {
   const t = e[n];
   if (void 0 === t) {
@@ -2050,7 +2050,7 @@ function isObjectLike(e) {
   return null !== e && /object|function/.test(typeof e);
 }
 
-function createLazyGenerator(e, n = Map) {
+function memoize(e, n = Map) {
   const t = new n;
   return (n, ...o) => {
     if (t.has(n)) {
@@ -2174,10 +2174,6 @@ function bindArgs(e, ...n) {
   return (...t) => e(...n, ...t);
 }
 
-function identity(e) {
-  return e;
-}
-
 function capitalize(e) {
   return e[0].toUpperCase() + e.substring(1);
 }
@@ -2222,82 +2218,82 @@ function hasHalf(e) {
   return .5 === Math.abs(e % 1);
 }
 
-function givenFieldsToDayTimeNano(e, n, t) {
+function givenFieldsToBigNano(e, n, t) {
   let o = 0, r = 0;
   for (let i = 0; i <= n; i++) {
-    const n = e[t[i]], a = U[i], s = A / a, [c, u] = divModTrunc(n, s);
+    const n = e[t[i]], a = j[i], s = W / a, [c, u] = divModTrunc(n, s);
     o += u * a, r += c;
   }
-  const [i, a] = divModTrunc(o, A);
+  const [i, a] = divModTrunc(o, W);
   return [ r + i, a ];
 }
 
 function nanoToGivenFields(e, n, t) {
   const o = {};
   for (let r = n; r >= 0; r--) {
-    const n = U[r];
+    const n = j[r];
     o[t[r]] = divTrunc(e, n), e = modTrunc(e, n);
   }
   return o;
 }
 
 function getRequiredYearMonthFields(e) {
-  return e === ae ? J : [];
+  return e === ce ? Q : [];
 }
 
 function getRequiredMonthDayFields(e) {
-  return e === ae ? X : [];
+  return e === ce ? ne : [];
 }
 
 function getRequiredDateFields(e) {
-  return e === ae ? [ "year", "day" ] : [];
+  return e === ce ? [ "year", "day" ] : [];
 }
 
-function createDayTimeNano(e, n) {
-  let [t, o] = divModTrunc(n, A), r = e + t;
+function createBigNano(e, n) {
+  let [t, o] = divModTrunc(n, W), r = e + t;
   const i = Math.sign(r);
-  return i && i === -Math.sign(o) && (r -= i, o += i * A), [ r, o ];
+  return i && i === -Math.sign(o) && (r -= i, o += i * W), [ r, o ];
 }
 
-function addDayTimeNanoAndNumber(e, n) {
-  return createDayTimeNano(e[0], e[1] + n);
+function addBigNanoAndNumber(e, n) {
+  return createBigNano(e[0], e[1] + n);
 }
 
-function addDayTimeNanos(e, n, t = 1) {
-  return createDayTimeNano(e[0] + n[0] * t, e[1] + n[1] * t);
+function addBigNanos(e, n, t = 1) {
+  return createBigNano(e[0] + n[0] * t, e[1] + n[1] * t);
 }
 
-function diffDayTimeNanos(e, n) {
-  return createDayTimeNano(n[0] - e[0], n[1] - e[1]);
+function diffBigNanos(e, n) {
+  return addBigNanos(n, e, -1);
 }
 
-function compareDayTimeNanos(e, n) {
+function compareBigNanos(e, n) {
   return compareNumbers(e[0], n[0]) || compareNumbers(e[1], n[1]);
 }
 
-function bigIntToDayTimeNano(e, n = 1) {
-  const t = BigInt(A / n);
+function bigIntToBigNano(e, n = 1) {
+  const t = BigInt(W / n);
   return [ Number(e / t), Number(e % t) * n ];
 }
 
-function numberToDayTimeNano(e, n = 1) {
-  const t = A / n, [o, r] = divModTrunc(e, t);
+function numberToBigNano(e, n = 1) {
+  const t = W / n, [o, r] = divModTrunc(e, t);
   return [ o, r * n ];
 }
 
-function dayTimeNanoToBigInt(e, n = 1) {
-  const [t, o] = e, r = Math.floor(o / n), i = A / n;
+function bigNanoToBigInt(e, n = 1) {
+  const [t, o] = e, r = Math.floor(o / n), i = W / n;
   return BigInt(t) * BigInt(i) + BigInt(r);
 }
 
-function dayTimeNanoToNumber(e, n = 1, t) {
-  const [o, r] = dayTimeNanoToNumberRemainder(e, n);
-  return o + (t ? r / n : 0);
+function bigNanoToNumber(e, n = 1, t) {
+  const [o, r] = e, [i, a] = divModTrunc(r, n);
+  return o * (W / n) + (i + (t ? a / n : 0));
 }
 
-function dayTimeNanoToNumberRemainder(e, n) {
-  const [t, o] = e, [r, i] = divModFloor(o, n);
-  return [ t * (A / n) + r, i ];
+function divModBigNano(e, n, t = divModFloor) {
+  const [o, r] = e, [i, a] = t(r, n);
+  return [ o * (W / n) + i, a ];
 }
 
 function hashIntlFormatParts(e, n) {
@@ -2309,20 +2305,20 @@ function hashIntlFormatParts(e, n) {
 }
 
 function checkIsoYearMonthInBounds(e) {
-  return clampProp(e, "isoYear", ke, Ye, 1), e.isoYear === ke ? clampProp(e, "isoMonth", 4, 12, 1) : e.isoYear === Ye && clampProp(e, "isoMonth", 1, 9, 1), 
+  return clampProp(e, "isoYear", Ze, Re, 1), e.isoYear === Ze ? clampProp(e, "isoMonth", 4, 12, 1) : e.isoYear === Re && clampProp(e, "isoMonth", 1, 9, 1), 
   e;
 }
 
 function checkIsoDateInBounds(e) {
   return checkIsoDateTimeInBounds({
     ...e,
-    ...ve,
+    ...be,
     isoHour: 12
   }), e;
 }
 
 function checkIsoDateTimeInBounds(e) {
-  const n = clampProp(e, "isoYear", ke, Ye, 1), t = n === ke ? 1 : n === Ye ? -1 : 0;
+  const n = clampProp(e, "isoYear", Ze, Re, 1), t = n === Ze ? 1 : n === Re ? -1 : 0;
   return t && checkEpochNanoInBounds(isoToEpochNano({
     ...e,
     isoDay: e.isoDay + t,
@@ -2331,27 +2327,31 @@ function checkIsoDateTimeInBounds(e) {
 }
 
 function checkEpochNanoInBounds(e) {
-  if (!e || -1 === compareDayTimeNanos(e, Oe) || 1 === compareDayTimeNanos(e, we)) {
-    throw new RangeError(y);
+  if (!e || -1 === compareBigNanos(e, Ce) || 1 === compareBigNanos(e, Ye)) {
+    throw new RangeError(N);
   }
   return e;
 }
 
 function isoTimeFieldsToNano(e) {
-  return givenFieldsToDayTimeNano(e, 5, ge)[1];
+  return givenFieldsToBigNano(e, 5, ye)[1];
 }
 
 function nanoToIsoTimeAndDay(e) {
-  const [n, t] = divModFloor(e, A);
-  return [ nanoToGivenFields(t, 5, ge), n ];
+  const [n, t] = divModFloor(e, W);
+  return [ nanoToGivenFields(t, 5, ye), n ];
 }
 
 function epochNanoToSec(e) {
-  return dayTimeNanoToNumber(e, z);
+  return epochNanoToSecMod(e)[0];
+}
+
+function epochNanoToSecMod(e) {
+  return divModBigNano(e, A);
 }
 
 function epochNanoToMilli(e) {
-  return dayTimeNanoToNumber(e, Z);
+  return divModBigNano(e, q)[0];
 }
 
 function isoToEpochMilli(e) {
@@ -2361,8 +2361,8 @@ function isoToEpochMilli(e) {
 function isoToEpochNano(e) {
   const n = isoToEpochMilli(e);
   if (void 0 !== n) {
-    const [t, o] = divModTrunc(n, C);
-    return [ t, o * Z + (e.isoMicrosecond || 0) * R + (e.isoNanosecond || 0) ];
+    const [t, o] = divModTrunc(n, R);
+    return [ t, o * q + (e.isoMicrosecond || 0) * z + (e.isoNanosecond || 0) ];
   }
 }
 
@@ -2376,39 +2376,39 @@ function isoToEpochNanoWithOffset(e, n) {
 }
 
 function isoArgsToEpochSec(...e) {
-  return isoArgsToEpochMilli(...e) / B;
+  return isoArgsToEpochMilli(...e) / Z;
 }
 
 function isoArgsToEpochMilli(...e) {
   const [n, t] = isoToLegacyDate(...e), o = n.getTime();
   if (!isNaN(o)) {
-    return o - t * C;
+    return o - t * R;
   }
 }
 
 function isoToLegacyDate(e, n = 1, t = 1, o = 0, r = 0, i = 0, a = 0) {
-  const s = e === ke ? 1 : e === Ye ? -1 : 0, c = new Date;
+  const s = e === Ze ? 1 : e === Re ? -1 : 0, c = new Date;
   return c.setUTCHours(o, r, i, a), c.setUTCFullYear(e, n - 1, t + s), [ c, s ];
 }
 
 function epochNanoToIso(e, n) {
-  let [t, o] = addDayTimeNanoAndNumber(e, n);
-  o < 0 && (o += A, t -= 1);
-  const [r, i] = divModFloor(o, Z), [a, s] = divModFloor(i, R);
+  let [t, o] = addBigNanoAndNumber(e, n);
+  o < 0 && (o += W, t -= 1);
+  const [r, i] = divModFloor(o, q), [a, s] = divModFloor(i, z);
   return {
-    ...epochMilliToIso(t * C + r),
+    ...epochMilliToIso(t * R + r),
     isoMicrosecond: a,
     isoNanosecond: s
   };
 }
 
 function epochMilliToIso(e) {
-  const n = e < -C * Se ? 1 : e > C * Se ? -1 : 0, t = new Date(e + n * C);
-  return zipProps(Ne, [ t.getUTCFullYear(), t.getUTCMonth() + 1, t.getUTCDate() - n, t.getUTCHours(), t.getUTCMinutes(), t.getUTCSeconds(), t.getUTCMilliseconds() ]);
+  const n = Math.ceil(Math.max(0, Math.abs(e) - ke) / R) * Math.sign(e), t = new Date(e - n * R);
+  return zipProps(Pe, [ t.getUTCFullYear(), t.getUTCMonth() + 1, t.getUTCDate() + n, t.getUTCHours(), t.getUTCMinutes(), t.getUTCSeconds(), t.getUTCMilliseconds() ]);
 }
 
 function computeIsoMonthsInYear() {
-  return Re;
+  return Ae;
 }
 
 function computeIsoDaysInMonth(e, n) {
@@ -2434,9 +2434,14 @@ function computeIsoInLeapYear(e) {
 }
 
 function computeIsoDayOfYear(e) {
-  return diffEpochMilliByDay(isoToEpochMilli(isoDateYearStart(e)), isoToEpochMilli({
+  return diffEpochMilliByDay(isoToEpochMilli((e => ({
+    ...e,
+    isoMonth: 1,
+    isoDay: 1,
+    ...be
+  }))(e)), isoToEpochMilli({
     ...e,
-    ...ve
+    ...be
   })) + 1;
 }
 
@@ -2445,30 +2450,16 @@ function computeIsoDayOfWeek(e) {
   return modFloor(n.getUTCDay() - t, 7) || 7;
 }
 
-function computeIsoWeekParts(e) {
-  const n = computeIsoDayOfYear(e), t = computeIsoDayOfWeek(e), o = computeIsoDayOfWeek(isoDateYearStart(e)), r = Math.floor((n - t + 10) / Ze), {isoYear: i} = e;
-  return r < 1 ? [ i - 1, 5 === o || 6 === o && computeIsoInLeapYear(i - 1) ? 53 : 52 ] : 53 === r && computeIsoDaysInYear(i) - n < 4 - t ? [ i + 1, 1 ] : [ i, r ];
-}
-
-function isoDateYearStart(e) {
-  return {
-    ...e,
-    isoMonth: 1,
-    isoDay: 1,
-    ...ve
-  };
-}
-
 function computeGregoryEraParts({isoYear: e}) {
   return e < 1 ? [ "bce", 1 - e ] : [ "ce", e ];
 }
 
 function computeJapaneseEraParts(e) {
   const n = isoToEpochMilli(e);
-  if (n < ze) {
+  if (n < Le) {
     return computeGregoryEraParts(e);
   }
-  const t = hashIntlFormatParts(Hn(ce), n), {era: o, eraYear: r} = parseIntlYear(t, ce);
+  const t = hashIntlFormatParts(Kn(le), n), {era: o, eraYear: r} = parseIntlYear(t, le);
   return [ o, r ];
 }
 
@@ -2481,7 +2472,7 @@ function checkIsoDateFields(e) {
 }
 
 function isIsoDateFieldsValid(e) {
-  return allPropsEqual(ye, e, constrainIsoDateFields(e));
+  return allPropsEqual(ve, e, constrainIsoDateFields(e));
 }
 
 function constrainIsoDateFields(e, n) {
@@ -2494,45 +2485,61 @@ function constrainIsoDateFields(e, n) {
 }
 
 function constrainIsoTimeFields(e, n) {
-  return zipProps(ge, [ clampProp(e, "isoHour", 0, 23, n), clampProp(e, "isoMinute", 0, 59, n), clampProp(e, "isoSecond", 0, 59, n), clampProp(e, "isoMillisecond", 0, 999, n), clampProp(e, "isoMicrosecond", 0, 999, n), clampProp(e, "isoNanosecond", 0, 999, n) ]);
+  return zipProps(ye, [ clampProp(e, "isoHour", 0, 23, n), clampProp(e, "isoMinute", 0, 59, n), clampProp(e, "isoSecond", 0, 59, n), clampProp(e, "isoMillisecond", 0, 999, n), clampProp(e, "isoMicrosecond", 0, 999, n), clampProp(e, "isoNanosecond", 0, 999, n) ]);
 }
 
-function requireObjectLike(e) {
-  if (!isObjectLike(e)) {
-    throw new TypeError(n);
+function requireStringOrUndefined(e) {
+  if (void 0 !== e) {
+    return We(e);
   }
-  return e;
 }
 
-function requireType(e, n, t = e) {
-  if (typeof n !== e) {
-    throw new TypeError(invalidEntity(t, n));
+function requirePositiveIntegerOrUndefined(e) {
+  if (void 0 !== e) {
+    return requirePositiveInteger(e);
   }
-  return n;
 }
 
-function requireStringOrUndefined(e) {
-  if (void 0 !== e && "string" != typeof e) {
-    throw new TypeError("Expected string or undefined");
+function requireIntegerOrUndefined(e) {
+  if (void 0 !== e) {
+    return requireInteger(e);
   }
-  return e;
 }
 
-function requireIntegerOrUndefined(e) {
-  if ("number" == typeof e) {
-    requireNumberIsInteger(e);
-  } else if (void 0 !== e) {
-    throw new TypeError("Expected integer or undefined");
+function requirePositiveInteger(e) {
+  return requireNumberIsPositive(requireInteger(e));
+}
+
+function requireInteger(e) {
+  return requireNumberIsInteger($e(e));
+}
+
+function requireNonNullish(e) {
+  if (null == e) {
+    throw new TypeError("Cannot be null or undefined");
   }
   return e;
 }
 
-function requireInteger(e) {
-  return requireNumberIsInteger(Ue(e));
+function requirePropDefined(e, n) {
+  if (null == n) {
+    throw new RangeError(missingField(e));
+  }
+  return n;
 }
 
-function requirePositiveInteger(e) {
-  return requireNumberIsPositive(requireInteger(e));
+function requireObjectLike(e) {
+  if (!isObjectLike(e)) {
+    throw new TypeError(n);
+  }
+  return e;
+}
+
+function requireType(e, n, t = e) {
+  if (typeof n !== e) {
+    throw new TypeError(invalidEntity(t, n));
+  }
+  return n;
 }
 
 function requireNumberIsInteger(e, n = "number") {
@@ -2549,20 +2556,6 @@ function requireNumberIsPositive(e, n = "number") {
   return e;
 }
 
-function requireNonNullish(e) {
-  if (null == e) {
-    throw new TypeError("Cannot be null or undefined");
-  }
-  return e;
-}
-
-function requirePropDefined(e, n) {
-  if (null == n) {
-    throw new RangeError(missingField(e));
-  }
-  return n;
-}
-
 function toString(n) {
   if ("symbol" == typeof n) {
     throw new TypeError(e);
@@ -2571,7 +2564,7 @@ function toString(n) {
 }
 
 function toStringViaPrimitive(e, n) {
-  return isObjectLike(e) ? String(e) : Le(e, n);
+  return isObjectLike(e) ? String(e) : We(e, n);
 }
 
 function toBigInt(e) {
@@ -2607,40 +2600,40 @@ function toPositiveInteger(e, n) {
 }
 
 function refineOverflowOptions(e) {
-  return void 0 === e ? 0 : an(requireObjectLike(e));
+  return void 0 === e ? 0 : un(requireObjectLike(e));
 }
 
 function refineZonedFieldOptions(e, n = 0) {
   e = normalizeOptions(e);
-  const t = sn(e), o = cn(e, n);
-  return [ an(e), o, t ];
+  const t = ln(e), o = fn(e, n);
+  return [ un(e), o, t ];
 }
 
 function refineEpochDisambigOptions(e) {
-  return sn(normalizeOptions(e));
+  return ln(normalizeOptions(e));
 }
 
 function refineCalendarDiffOptions(e) {
-  return e = normalizeOptions(e), on(e, 9, 6, 1);
+  return e = normalizeOptions(e), sn(e, 9, 6, 1);
 }
 
 function refineDiffOptions(e, n, t, o = 9, r = 0, i = 4) {
   n = normalizeOptions(n);
-  let a = on(n, o, r), s = parseRoundingIncInteger(n), c = dn(n, i);
-  const u = tn(n, o, r, 1);
+  let a = sn(n, o, r), s = parseRoundingIncInteger(n), c = hn(n, i);
+  const u = an(n, o, r, 1);
   return null == a ? a = Math.max(t, u) : checkLargestSmallestUnit(a, u), s = refineRoundingInc(s, u, 1), 
   e && (c = (e => e < 4 ? (e + 2) % 4 : e)(c)), [ a, u, s, c ];
 }
 
 function refineRoundOptions(e, n = 6, t) {
-  let o = parseRoundingIncInteger(e = normalizeUnitNameOptions(e, We));
-  const r = dn(e, 7);
-  let i = tn(e, n);
-  return i = requirePropDefined(We, i), o = refineRoundingInc(o, i, void 0, t), [ i, o, r ];
+  let o = parseRoundingIncInteger(e = normalizeUnitNameOptions(e, He));
+  const r = hn(e, 7);
+  let i = an(e, n);
+  return i = requirePropDefined(He, i), o = refineRoundingInc(o, i, void 0, t), [ i, o, r ];
 }
 
 function refineDateDisplayOptions(e) {
-  return un(normalizeOptions(e));
+  return dn(normalizeOptions(e));
 }
 
 function refineTimeDisplayOptions(e, n) {
@@ -2649,41 +2642,41 @@ function refineTimeDisplayOptions(e, n) {
 
 function refineTimeDisplayTuple(e, n = 4) {
   const t = refineSubsecDigits(e);
-  return [ dn(e, 4), ...refineSmallestUnitAndSubsecDigits(tn(e, n), t) ];
+  return [ hn(e, 4), ...refineSmallestUnitAndSubsecDigits(an(e, n), t) ];
 }
 
 function refineSmallestUnitAndSubsecDigits(e, n) {
-  return null != e ? [ U[e], e < 4 ? 9 - 3 * e : -1 ] : [ void 0 === n ? 1 : 10 ** (9 - n), n ];
+  return null != e ? [ j[e], e < 4 ? 9 - 3 * e : -1 ] : [ void 0 === n ? 1 : 10 ** (9 - n), n ];
 }
 
 function parseRoundingIncInteger(e) {
-  const n = e[$e];
-  return void 0 === n ? 1 : toInteger(n, $e);
+  const n = e[Ve];
+  return void 0 === n ? 1 : toInteger(n, Ve);
 }
 
 function refineRoundingInc(e, n, t, o) {
-  const r = o ? A : U[n + 1];
+  const r = o ? W : j[n + 1];
   if (r) {
-    const t = U[n];
-    if (r % ((e = clampEntity($e, e, 1, r / t - (o ? 0 : 1), 1)) * t)) {
-      throw new RangeError(invalidEntity($e, e));
+    const t = j[n];
+    if (r % ((e = clampEntity(Ve, e, 1, r / t - (o ? 0 : 1), 1)) * t)) {
+      throw new RangeError(invalidEntity(Ve, e));
     }
   } else {
-    e = clampEntity($e, e, 1, t ? 10 ** 9 : 1, 1);
+    e = clampEntity(Ve, e, 1, t ? 10 ** 9 : 1, 1);
   }
   return e;
 }
 
 function refineSubsecDigits(e) {
-  let n = e[Ge];
+  let n = e[_e];
   if (void 0 !== n) {
     if ("number" != typeof n) {
       if ("auto" === toString(n)) {
         return;
       }
-      throw new RangeError(invalidEntity(Ge, n));
+      throw new RangeError(invalidEntity(_e, n));
     }
-    n = clampEntity(Ge, Math.floor(n), 0, 9, 1);
+    n = clampEntity(_e, Math.floor(n), 0, 9, 1);
   }
   return n;
 }
@@ -2709,7 +2702,7 @@ function copyOptions(e) {
 
 function overrideOverflowOptions(e, n) {
   return e && Object.assign(Object.create(null), e, {
-    overflow: _e[n]
+    overflow: Qe[n]
   });
 }
 
@@ -2722,10 +2715,10 @@ function refineUnitOption(e, n, t = 9, o = 0, r) {
     return r ? o : null;
   }
   let a = Y[i];
-  if (void 0 === a && (a = Te[i]), void 0 === a) {
-    throw new RangeError(invalidEntity(e, i));
+  if (void 0 === a && (a = Ie[i]), void 0 === a) {
+    throw new RangeError(invalidChoice(e, i, Y));
   }
-  return clampEntity(e, a, o, t, 1), a;
+  return clampEntity(e, a, o, t, 1, C), a;
 }
 
 function refineChoiceOption(e, n, t, o = 0) {
@@ -2735,27 +2728,27 @@ function refineChoiceOption(e, n, t, o = 0) {
   }
   const i = toString(r), a = n[i];
   if (void 0 === a) {
-    throw new RangeError(invalidEntity(e, i));
+    throw new RangeError(invalidChoice(e, i, n));
   }
   return a;
 }
 
 function checkLargestSmallestUnit(e, n) {
   if (n > e) {
-    throw new RangeError(v);
+    throw new RangeError(F);
   }
 }
 
 function createInstantSlots(e) {
   return {
-    branding: gn,
+    branding: yn,
     epochNanoseconds: e
   };
 }
 
 function createZonedDateTimeSlots(e, n, t) {
   return {
-    branding: In,
+    branding: Nn,
     calendar: t,
     timeZone: n,
     epochNanoseconds: e
@@ -2764,47 +2757,48 @@ function createZonedDateTimeSlots(e, n, t) {
 
 function createPlainDateTimeSlots(e, n = e.calendar) {
   return {
-    branding: Tn,
+    branding: In,
     calendar: n,
-    ...pluckProps(Ee, e)
+    ...pluckProps(Fe, e)
   };
 }
 
 function createPlainDateSlots(e, n = e.calendar) {
   return {
-    branding: hn,
+    branding: Dn,
     calendar: n,
-    ...pluckProps(Me, e)
+    ...pluckProps(Ee, e)
   };
 }
 
 function createPlainYearMonthSlots(e, n = e.calendar) {
   return {
-    branding: mn,
+    branding: Tn,
     calendar: n,
-    ...pluckProps(Me, e)
+    ...pluckProps(Ee, e)
   };
 }
 
 function createPlainMonthDaySlots(e, n = e.calendar) {
   return {
-    branding: pn,
+    branding: gn,
     calendar: n,
-    ...pluckProps(Me, e)
+    ...pluckProps(Ee, e)
   };
 }
 
 function createPlainTimeSlots(e) {
   return {
-    branding: Dn,
-    ...pluckProps(Pe, e)
+    branding: Mn,
+    ...pluckProps(Se, e)
   };
 }
 
 function createDurationSlots(e) {
   return {
-    branding: yn,
-    ...pluckProps(me, e)
+    branding: vn,
+    sign: computeDurationSign(e),
+    ...pluckProps(he, e)
   };
 }
 
@@ -2817,63 +2811,75 @@ function getEpochMilliseconds(e) {
 }
 
 function getEpochMicroseconds(e) {
-  return dayTimeNanoToBigInt(e.epochNanoseconds, R);
+  return bigNanoToBigInt(e.epochNanoseconds, z);
 }
 
 function getEpochNanoseconds(e) {
-  return dayTimeNanoToBigInt(e.epochNanoseconds);
+  return bigNanoToBigInt(e.epochNanoseconds);
 }
 
 function getId(e) {
-  return "string" == typeof e ? e : Le(e.id);
+  return "string" == typeof e ? e : We(e.id);
 }
 
 function isIdLikeEqual(e, n) {
   return e === n || getId(e) === getId(n);
 }
 
+function createRelativeSystem(e, n, t) {
+  const o = e(t.calendar);
+  return t.epochNanoseconds ? [ t, o, n(t.timeZone) ] : [ {
+    ...t,
+    ...be
+  }, o ];
+}
+
+function relativeMarkerToEpochNano(e, n) {
+  return n ? e.epochNanoseconds : isoToEpochNano(e);
+}
+
 function totalDuration(e, n, t, o, r) {
   const i = getLargestDurationUnit(o), [a, s] = ((e, n) => {
-    const t = n((e = normalizeUnitNameOptions(e, xe))[He]);
-    let o = rn(e);
-    return o = requirePropDefined(xe, o), [ o, t ];
+    const t = n((e = normalizeUnitNameOptions(e, Ge))[Je]);
+    let o = cn(e);
+    return o = requirePropDefined(Ge, o), [ o, t ];
   })(r, e), c = Math.max(a, i);
   if (c < 6 || 6 === c && (!s || !s.epochNanoseconds)) {
-    return ((e, n) => totalDayTimeNano(durationFieldsToDayTimeNano(e, 6), n))(o, a);
+    return ((e, n) => totalBigNano(durationFieldsToBigNano(e), n))(o, a);
   }
   if (!s) {
-    throw new RangeError(M);
+    throw new RangeError(P);
   }
-  const u = createMarkerSystem(n, t, s);
+  const u = createRelativeSystem(n, t, s);
   return ((e, n, t, o, r, i) => {
-    const a = Sn(e), [s, c] = clampRelativeDuration(clearDurationFields(e, t - 1), t, a, o, r, i), u = computeEpochNanoFrac(s, c, n);
-    return e[de[t]] + u * a;
+    const a = computeDurationSign(e), [s, c] = clampRelativeDuration(clearDurationFields(e, t - 1), t, a, o, r, i), u = computeEpochNanoFrac(s, c, n);
+    return e[pe[t]] + u * a;
   })(...spanDuration(o, void 0, a, ...u), a, ...u);
 }
 
-function totalDayTimeNano(e, n) {
-  return dayTimeNanoToNumber(e, U[n], 1);
+function totalBigNano(e, n) {
+  return bigNanoToNumber(e, j[n], 1);
 }
 
 function clampRelativeDuration(e, n, t, o, r, i) {
   const a = {
-    ...De,
-    [de[n]]: t
-  }, s = i(o, e), c = i(s, a);
-  return [ r(s), r(c) ];
+    ...Me,
+    [pe[n]]: t
+  }, s = moveRelativeMarker(e, o, r, i), c = moveRelativeMarker(a, s, r, i);
+  return [ relativeMarkerToEpochNano(s, i), relativeMarkerToEpochNano(c, i) ];
 }
 
 function computeEpochNanoFrac(e, n, t) {
-  const o = dayTimeNanoToNumber(diffDayTimeNanos(e, n));
+  const o = bigNanoToNumber(diffBigNanos(e, n));
   if (!o) {
-    throw new RangeError(p);
+    throw new RangeError(m);
   }
-  return dayTimeNanoToNumber(diffDayTimeNanos(e, t)) / o;
+  return bigNanoToNumber(diffBigNanos(e, t)) / o;
 }
 
 function roundInstant(e, n) {
   const [t, o, r] = refineRoundOptions(n, 5, 1);
-  return createInstantSlots(roundDayTimeNano(e.epochNanoseconds, t, o, r, 1));
+  return createInstantSlots(roundBigNano(e.epochNanoseconds, t, o, r, 1));
 }
 
 function roundZonedDateTime(e, n, t) {
@@ -2904,13 +2910,13 @@ function roundPlainTime(e, n) {
 function roundDateTime(e, n, t, o, r) {
   return 6 === n ? ((e, n, t) => {
     if (n) {
-      const o = computeNanosecondsInDay(n, e);
+      const o = computeTimeInDay(n, e);
       return checkIsoDateTimeInBounds({
         ...moveByIsoDays(e, roundByInc(isoTimeFieldsToNano(e), o, t) / o),
-        ...ve
+        ...be
       });
     }
-    return roundDateTimeToNano(e, A, t);
+    return roundDateTimeToNano(e, W, t);
   })(e, r, o) : roundDateTimeToNano(e, computeNanoInc(n, t), o);
 }
 
@@ -2927,25 +2933,25 @@ function roundTimeToNano(e, n, t) {
 }
 
 function balanceDayTimeDuration(e, n, t, o, r) {
-  return nanoToDurationDayTimeFields(roundDayTimeNano(durationFieldsToDayTimeNano(e, 6), t, o, r), n);
+  return nanoToDurationDayTimeFields(roundBigNano(durationFieldsToBigNano(e), t, o, r), n);
 }
 
 function balanceDayTimeDurationByInc(e, n, t, o) {
-  return nanoToDurationDayTimeFields(roundDayTimeNanoByInc(durationFieldsToDayTimeNano(e, n), t, o), n);
+  return nanoToDurationDayTimeFields(roundBigNanoByInc(durationFieldsToBigNano(e, n), t, o), n);
 }
 
 function roundRelativeDuration(e, n, t, o, r, i, a, s, c) {
-  const u = s === identity ? o > 6 ? nudgeRelativeDuration : 6 === o ? nudgeDurationDayTime : nudgeRelativeDurationTime : o > 6 ? nudgeRelativeDuration : nudgeDurationDayTime;
+  const u = o > 6 ? nudgeRelativeDuration : c && o < 6 ? nudgeRelativeDurationTime : nudgeDurationDayTime;
   let [l, f, d] = u(e, n, t, o, r, i, a, s, c);
   return d && (l = ((e, n, t, o, r, i, a) => {
-    const s = Sn(e);
+    const s = computeDurationSign(e);
     for (let c = o + 1; c <= t; c++) {
       if (7 === c && 7 !== t) {
         continue;
       }
       const o = clearDurationFields(e, c - 1);
-      o[de[c]] += s;
-      const u = dayTimeNanoToNumber(diffDayTimeNanos(i(a(r, o)), n));
+      o[pe[c]] += s;
+      const u = bigNanoToNumber(diffBigNanos(relativeMarkerToEpochNano(moveRelativeMarker(o, r, i, a), a), n));
       if (u && Math.sign(u) !== s) {
         break;
       }
@@ -2956,60 +2962,60 @@ function roundRelativeDuration(e, n, t, o, r, i, a, s, c) {
 }
 
 function computeNanoInc(e, n) {
-  return U[e] * n;
+  return j[e] * n;
 }
 
 function roundByInc(e, n, t) {
-  return ((e, n) => Nn[n](e))(e / n, t) * n;
+  return ((e, n) => Pn[n](e))(e / n, t) * n;
 }
 
 function roundToMinute(e) {
-  return roundByInc(e, q, 7);
+  return roundByInc(e, L, 7);
 }
 
-function roundDayTimeNano(e, n, t, o, r) {
-  return 6 === n ? [ roundByInc(totalDayTimeNano(e, 6), t, o), 0 ] : roundDayTimeNanoByInc(e, computeNanoInc(n, t), o, r);
+function roundBigNano(e, n, t, o, r) {
+  return 6 === n ? [ roundByInc(totalBigNano(e, 6), t, o), 0 ] : roundBigNanoByInc(e, computeNanoInc(n, t), o, r);
 }
 
-function roundDayTimeNanoByInc(e, n, t, o) {
+function roundBigNanoByInc(e, n, t, o) {
   let [r, i] = e;
-  o && i < 0 && (i += A, r -= 1);
-  const [a, s] = divModFloor(roundByInc(i, n, t), A);
-  return createDayTimeNano(r + a, s);
+  o && i < 0 && (i += W, r -= 1);
+  const [a, s] = divModFloor(roundByInc(i, n, t), W);
+  return createBigNano(r + a, s);
 }
 
 function nudgeDurationDayTime(e, n, t, o, r, i) {
-  const a = Sn(e), s = durationFieldsToDayTimeNano(e, 6), c = roundDayTimeNano(s, o, r, i), u = diffDayTimeNanos(s, c), l = Math.sign(c[0] - s[0]) === a, f = nanoToDurationDayTimeFields(c, Math.min(t, 6));
+  const a = computeDurationSign(e), s = durationFieldsToBigNano(e), c = roundBigNano(s, o, r, i), u = diffBigNanos(s, c), l = Math.sign(c[0] - s[0]) === a, f = nanoToDurationDayTimeFields(c, Math.min(t, 6));
   return [ {
     ...e,
     ...f
-  }, addDayTimeNanos(n, u), l ];
+  }, addBigNanos(n, u), l ];
 }
 
 function nudgeRelativeDurationTime(e, n, t, o, r, i, a, s, c) {
-  const u = Sn(e);
-  let [l, f] = givenFieldsToDayTimeNano(e, 5, de);
+  const u = computeDurationSign(e);
+  let [l, f] = givenFieldsToBigNano(e, 5, pe);
   const d = computeNanoInc(o, r);
   let m = roundByInc(f, d, i);
   const [p, h] = clampRelativeDuration({
     ...e,
-    ...Ie
-  }, 6, u, a, s, c), T = m - dayTimeNanoToNumber(diffDayTimeNanos(p, h));
-  T && Math.sign(T) !== u ? n = addDayTimeNanoAndNumber(p, m) : (l += u, m = roundByInc(T, d, i), 
-  n = addDayTimeNanoAndNumber(h, m));
-  const D = nanoToDurationTimeFields(m);
+    ...Ne
+  }, 6, u, a, s, c), T = m - bigNanoToNumber(diffBigNanos(p, h));
+  T && Math.sign(T) !== u ? n = addBigNanoAndNumber(p, m) : (l += u, m = roundByInc(T, d, i), 
+  n = addBigNanoAndNumber(h, m));
+  const g = nanoToDurationTimeFields(m);
   return [ {
     ...e,
-    ...D,
+    ...g,
     days: e.days + l
   }, n, Boolean(l) ];
 }
 
 function nudgeRelativeDuration(e, n, t, o, r, i, a, s, c) {
-  const u = Sn(e), l = de[o], f = clearDurationFields(e, o - 1), d = divTrunc(e[l], r) * r;
+  const u = computeDurationSign(e), l = pe[o], f = clearDurationFields(e, o - 1), d = divTrunc(e[l], r) * r;
   f[l] = d;
-  const [m, p] = clampRelativeDuration(f, o, r * u, a, s, c), h = d + computeEpochNanoFrac(m, p, n) * u * r, T = roundByInc(h, r, i), D = Math.sign(T - h) === u;
-  return f[l] = T, [ f, D ? p : m, D ];
+  const [m, p] = clampRelativeDuration(f, o, r * u, a, s, c), h = d + computeEpochNanoFrac(m, p, n) * u * r, T = roundByInc(h, r, i), g = Math.sign(T - h) === u;
+  return f[l] = T, [ f, g ? p : m, g ];
 }
 
 function formatInstantIso(e, n, t, o) {
@@ -3018,27 +3024,27 @@ function formatInstantIso(e, n, t, o) {
     return [ e.timeZone, ...n ];
   })(o), c = void 0 !== r;
   return ((e, n, t, o, r, i) => {
-    t = roundDayTimeNanoByInc(t, r, o, 1);
+    t = roundBigNanoByInc(t, r, o, 1);
     const a = n.getOffsetNanosecondsFor(t);
     return formatIsoDateTimeFields(epochNanoToIso(t, a), i) + (e ? formatOffsetNano(roundToMinute(a)) : "Z");
-  })(c, n(c ? e(r) : Mn), t.epochNanoseconds, i, a, s);
+  })(c, n(c ? e(r) : En), t.epochNanoseconds, i, a, s);
 }
 
 function formatZonedDateTimeIso(e, n, t) {
   return ((e, n, t, o, r, i, a, s, c, u) => {
-    o = roundDayTimeNanoByInc(o, c, s, 1);
+    o = roundBigNanoByInc(o, c, s, 1);
     const l = e(t).getOffsetNanosecondsFor(o);
     return formatIsoDateTimeFields(epochNanoToIso(o, l), u) + formatOffsetNano(roundToMinute(l), a) + ((e, n) => 1 !== n ? "[" + (2 === n ? "!" : "") + getId(e) + "]" : "")(t, i) + formatCalendar(n, r);
   })(e, n.calendar, n.timeZone, n.epochNanoseconds, ...(e => {
     e = normalizeOptions(e);
-    const n = un(e), t = refineSubsecDigits(e), o = fn(e), r = dn(e, 4), i = tn(e, 4);
-    return [ n, ln(e), o, r, ...refineSmallestUnitAndSubsecDigits(i, t) ];
+    const n = dn(e), t = refineSubsecDigits(e), o = pn(e), r = hn(e, 4), i = an(e, 4);
+    return [ n, mn(e), o, r, ...refineSmallestUnitAndSubsecDigits(i, t) ];
   })(t));
 }
 
 function formatPlainDateTimeIso(e, n) {
   return ((e, n, t, o, r, i) => formatIsoDateTimeFields(roundDateTimeToNano(n, r, o), i) + formatCalendar(e, t))(e.calendar, e, ...(e => (e = normalizeOptions(e), 
-  [ un(e), ...refineTimeDisplayTuple(e) ]))(n));
+  [ dn(e), ...refineTimeDisplayTuple(e) ]))(n));
 }
 
 function formatPlainDateIso(e, n) {
@@ -3064,23 +3070,25 @@ function formatDurationIso(e, n) {
     ...e,
     ...balanceDayTimeDurationByInc(e, Math.min(getLargestDurationUnit(e), 6), o, t)
   }), ((e, n) => {
-    const t = Sn(e), o = -1 === t ? negateDurationFields(e) : e, {hours: r, minutes: i} = o, [a, s] = dayTimeNanoToNumberRemainder(givenFieldsToDayTimeNano(o, 3, de), z), c = formatSubsecNano(s, n), u = n >= 0 || !t || c;
+    const {sign: t} = e, o = -1 === t ? negateDurationFields(e) : e, {hours: r, minutes: i} = o, [a, s] = divModBigNano(givenFieldsToBigNano(o, 3, pe), A, divModTrunc);
+    checkDurationTimeUnit(a);
+    const c = formatSubsecNano(s, n), u = n >= 0 || !t || c;
     return (t < 0 ? "-" : "") + "P" + formatDurationFragments({
-      Y: formatNumberUnscientific(o.years),
-      M: formatNumberUnscientific(o.months),
-      W: formatNumberUnscientific(o.weeks),
-      D: formatNumberUnscientific(o.days)
+      Y: formatDurationNumber(o.years),
+      M: formatDurationNumber(o.months),
+      W: formatDurationNumber(o.weeks),
+      D: formatDurationNumber(o.days)
     }) + (r || i || a || u ? "T" + formatDurationFragments({
-      H: formatNumberUnscientific(r),
-      M: formatNumberUnscientific(i),
-      S: formatNumberUnscientific(a, u) + c
+      H: formatDurationNumber(r),
+      M: formatDurationNumber(i),
+      S: formatDurationNumber(a, u) + c
     }) : "");
   })(e, r);
 }
 
 function formatDateLikeIso(e, n, t, o) {
-  const r = getId(e), i = o > 1 || 0 === o && r !== ae;
-  return 1 === o ? r === ae ? n(t) : formatIsoDateFields(t) : i ? formatIsoDateFields(t) + formatCalendarId(r, 2 === o) : n(t);
+  const r = getId(e), i = o > 1 || 0 === o && r !== ce;
+  return 1 === o ? r === ce ? n(t) : formatIsoDateFields(t) : i ? formatIsoDateFields(t) + formatCalendarId(r, 2 === o) : n(t);
 }
 
 function formatDurationFragments(e) {
@@ -3097,21 +3105,21 @@ function formatIsoDateTimeFields(e, n) {
 }
 
 function formatIsoDateFields(e) {
-  return formatIsoYearMonthFields(e) + "-" + O(e.isoDay);
+  return formatIsoYearMonthFields(e) + "-" + k(e.isoDay);
 }
 
 function formatIsoYearMonthFields(e) {
   const {isoYear: n} = e;
-  return (n < 0 || n > 9999 ? getSignStr(n) + padNumber(6, Math.abs(n)) : padNumber(4, n)) + "-" + O(e.isoMonth);
+  return (n < 0 || n > 9999 ? getSignStr(n) + padNumber(6, Math.abs(n)) : padNumber(4, n)) + "-" + k(e.isoMonth);
 }
 
 function formatIsoMonthDayFields(e) {
-  return O(e.isoMonth) + "-" + O(e.isoDay);
+  return k(e.isoMonth) + "-" + k(e.isoDay);
 }
 
 function formatIsoTimeFields(e, n) {
-  const t = [ O(e.isoHour), O(e.isoMinute) ];
-  return -1 !== n && t.push(O(e.isoSecond) + ((e, n, t, o) => formatSubsecNano(e * Z + n * R + t, o))(e.isoMillisecond, e.isoMicrosecond, e.isoNanosecond, n)), 
+  const t = [ k(e.isoHour), k(e.isoMinute) ];
+  return -1 !== n && t.push(k(e.isoSecond) + ((e, n, t, o) => formatSubsecNano(e * q + n * z + t, o))(e.isoMillisecond, e.isoMicrosecond, e.isoNanosecond, n)), 
   t.join(":");
 }
 
@@ -3119,14 +3127,14 @@ function formatOffsetNano(e, n = 0) {
   if (1 === n) {
     return "";
   }
-  const [t, o] = divModFloor(Math.abs(e), L), [r, i] = divModFloor(o, q), [a, s] = divModFloor(i, z);
-  return getSignStr(e) + O(t) + ":" + O(r) + (a || s ? ":" + O(a) + formatSubsecNano(s) : "");
+  const [t, o] = divModFloor(Math.abs(e), U), [r, i] = divModFloor(o, L), [a, s] = divModFloor(i, A);
+  return getSignStr(e) + k(t) + ":" + k(r) + (a || s ? ":" + k(a) + formatSubsecNano(s) : "");
 }
 
 function formatCalendar(e, n) {
   if (1 !== n) {
     const t = getId(e);
-    if (n > 1 || 0 === n && t !== ae) {
+    if (n > 1 || 0 === n && t !== ce) {
       return formatCalendarId(t, 2 === n);
     }
   }
@@ -3139,23 +3147,19 @@ function formatCalendarId(e, n) {
 
 function formatSubsecNano(e, n) {
   let t = padNumber(9, e);
-  return t = void 0 === n ? t.replace(Fn, "") : t.slice(0, n), t ? "." + t : "";
+  return t = void 0 === n ? t.replace(On, "") : t.slice(0, n), t ? "." + t : "";
 }
 
 function getSignStr(e) {
   return e < 0 ? "-" : "+";
 }
 
-function formatNumberUnscientific(e, n) {
+function formatDurationNumber(e, n) {
   return e || n ? e.toLocaleString("fullwide", {
     useGrouping: 0
   }) : "";
 }
 
-function zonedEpochNanoToIso(e, n) {
-  return epochNanoToIso(n, e.getOffsetNanosecondsFor(n));
-}
-
 function _zonedEpochSlotsToIso(e, n) {
   const {epochNanoseconds: t} = e, o = (n.getOffsetNanosecondsFor ? n : n(e.timeZone)).getOffsetNanosecondsFor(t), r = epochNanoToIso(t, o);
   return {
@@ -3166,10 +3170,10 @@ function _zonedEpochSlotsToIso(e, n) {
 }
 
 function buildZonedIsoFields(e, n) {
-  const t = bn(n, e);
+  const t = wn(n, e);
   return {
     calendar: n.calendar,
-    ...pluckProps(Ee, t),
+    ...pluckProps(Fe, t),
     offset: formatOffsetNano(t.offsetNanoseconds),
     timeZone: n.timeZone
   };
@@ -3185,7 +3189,7 @@ function getMatchingInstantFor(e, n, t, o = 0, r = 0, i, a) {
       const r = isoToEpochNano(n);
       o && (t = roundToMinute(t));
       for (const n of e) {
-        let e = dayTimeNanoToNumber(diffDayTimeNanos(n, r));
+        let e = bigNanoToNumber(diffBigNanos(n, r));
         if (o && (e = roundToMinute(e)), e === t) {
           return n;
         }
@@ -3206,14 +3210,14 @@ function getSingleInstantFor(e, n, t = 0, o = e.getPossibleInstantsFor(n)) {
     return o[0];
   }
   if (1 === t) {
-    throw new RangeError(g);
+    throw new RangeError(M);
   }
   if (o.length) {
     return o[3 === t ? 1 : 0];
   }
   const r = isoToEpochNano(n), i = ((e, n) => {
-    const t = e.getOffsetNanosecondsFor(addDayTimeNanoAndNumber(n, -A));
-    return e.getOffsetNanosecondsFor(addDayTimeNanoAndNumber(n, A)) - t;
+    const t = e.getOffsetNanosecondsFor(addBigNanoAndNumber(n, -W));
+    return validateTimeZoneGap(e.getOffsetNanosecondsFor(addBigNanoAndNumber(n, W)) - t);
   })(e, r), a = i * (2 === t ? -1 : 1);
   return (o = e.getPossibleInstantsFor(epochNanoToIso(r, a)))[2 === t ? 0 : o.length - 1];
 }
@@ -3222,52 +3226,59 @@ function computeStartOfDay(e, n) {
   let {epochNanoseconds: t, timeZone: o, calendar: r} = n;
   const i = e(o);
   return t = getMatchingInstantFor(i, {
-    ...bn(n, i),
-    ...ve
+    ...wn(n, i),
+    ...be
   }, void 0, 0, 0, 1), createZonedDateTimeSlots(t, o, r);
 }
 
 function computeHoursInDay(e, n) {
   const t = e(n.timeZone);
-  return computeNanosecondsInDay(t, bn(n, t)) / L;
+  return computeTimeInDay(t, wn(n, t), U);
 }
 
-function computeNanosecondsInDay(e, n) {
+function computeTimeInDay(e, n, t) {
   n = {
     ...n,
-    ...ve
+    ...be
   };
-  const t = dayTimeNanoToNumber(diffDayTimeNanos(getSingleInstantFor(e, {
+  const o = bigNanoToNumber(diffBigNanos(getSingleInstantFor(e, {
     ...n,
-    ...ve
+    ...be
   }), getSingleInstantFor(e, {
     ...moveByIsoDays(n, 1),
-    ...ve
-  })));
-  if (t <= 0) {
-    throw new RangeError(p);
+    ...be
+  })), t, 1);
+  if (o <= 0) {
+    throw new RangeError(m);
   }
-  return t;
+  return o;
 }
 
 function validateTimeZoneOffset(e) {
-  if (Math.abs(e) >= A) {
+  if (Math.abs(e) >= W) {
+    throw new RangeError(g);
+  }
+  return e;
+}
+
+function validateTimeZoneGap(e) {
+  if (e > W) {
     throw new RangeError(D$1);
   }
   return e;
 }
 
 function moveInstant(e, n, t) {
-  return createInstantSlots(checkEpochNanoInBounds(addDayTimeNanos(n.epochNanoseconds, (e => {
+  return createInstantSlots(checkEpochNanoInBounds(addBigNanos(n.epochNanoseconds, (e => {
     if (durationHasDateParts(e)) {
-      throw new RangeError(P);
+      throw new RangeError(E);
     }
-    return durationFieldsToDayTimeNano(e, 5);
+    return durationFieldsToBigNano(e, 5);
   })(e ? negateDurationFields(t) : t))));
 }
 
 function moveZonedDateTime(e, n, t, o, r, i = Object.create(null)) {
-  const a = n(o.timeZone), s = moveZonedEpochNano(e(o.calendar), a, o.epochNanoseconds, t ? negateDurationFields(r) : r, i);
+  const a = n(o.timeZone), s = moveZonedEpochSlots(e(o.calendar), a, o, t ? negateDurationFields(r) : r, i);
   return {
     ...o,
     epochNanoseconds: s
@@ -3275,24 +3286,20 @@ function moveZonedDateTime(e, n, t, o, r, i = Object.create(null)) {
 }
 
 function movePlainDateTime(e, n, t, o, r = Object.create(null)) {
-  return createPlainDateTimeSlots({
-    ...t,
-    ...moveDateTime(e(t.calendar), t, n ? negateDurationFields(o) : o, r)
-  });
+  const {calendar: i} = t;
+  return createPlainDateTimeSlots(moveDateTime(e(i), t, n ? negateDurationFields(o) : o, r), i);
 }
 
 function movePlainDate(e, n, t, o, r) {
-  return {
-    ...t,
-    ...moveDateEfficient(e(t.calendar), t, n ? negateDurationFields(o) : o, r)
-  };
+  const {calendar: i} = t;
+  return createPlainDateSlots(moveDateEfficient(e(i), t, n ? negateDurationFields(o) : o, r), i);
 }
 
 function movePlainYearMonth(e, n, t, o, r = Object.create(null)) {
   const i = t.calendar, a = e(i);
   let s = moveToMonthStart(a, t);
-  n && (o = negateDuration(o)), Sn(o) < 0 && (s = a.dateAdd(s, {
-    ...De,
+  n && (o = negateDuration(o)), o.sign < 0 && (s = a.dateAdd(s, {
+    ...Me,
     months: 1
   }), s = moveByIsoDays(s, -1));
   const c = a.dateAdd(s, o, r);
@@ -3303,22 +3310,29 @@ function movePlainTime(e, n, t) {
   return createPlainTimeSlots(moveTime(n, e ? negateDurationFields(t) : t)[0]);
 }
 
-function moveZonedEpochNano(e, n, t, o, r) {
-  const i = durationFieldsToDayTimeNano(o, 5);
+function moveRelativeMarker(e, n, t, o) {
+  return o ? {
+    epochNanoseconds: moveZonedEpochSlots(t, o, n, e)
+  } : moveDateTime(t, n, e);
+}
+
+function moveZonedEpochSlots(e, n, t, o, r) {
+  const i = durationFieldsToBigNano(o, 5);
+  let a = t.epochNanoseconds;
   if (durationHasDateParts(o)) {
-    const a = zonedEpochNanoToIso(n, t);
-    t = addDayTimeNanos(getSingleInstantFor(n, {
-      ...moveDateEfficient(e, a, {
+    const s = wn(t, n);
+    a = addBigNanos(getSingleInstantFor(n, {
+      ...moveDateEfficient(e, s, {
         ...o,
-        ...Ie
+        ...Ne
       }, r),
-      ...pluckProps(ge, a),
-      calendar: ae
+      ...pluckProps(ye, s),
+      calendar: ce
     }), i);
   } else {
-    t = addDayTimeNanos(t, i), refineOverflowOptions(r);
+    a = addBigNanos(a, i), refineOverflowOptions(r);
   }
-  return checkEpochNanoInBounds(t);
+  return checkEpochNanoInBounds(a);
 }
 
 function moveDateTime(e, n, t, o) {
@@ -3326,7 +3340,7 @@ function moveDateTime(e, n, t, o) {
   return checkIsoDateTimeInBounds({
     ...moveDateEfficient(e, n, {
       ...t,
-      ...Ie,
+      ...Ne,
       days: t.days + i
     }, o),
     ...r
@@ -3338,7 +3352,7 @@ function moveDateEfficient(e, n, t, o) {
     return e.dateAdd(n, t, o);
   }
   refineOverflowOptions(o);
-  const r = t.days + givenFieldsToDayTimeNano(t, 5, de)[0];
+  const r = t.days + givenFieldsToBigNano(t, 5, pe)[0];
   return r ? checkIsoDateInBounds(moveByIsoDays(n, r)) : n;
 }
 
@@ -3347,87 +3361,87 @@ function moveToMonthStart(e, n) {
 }
 
 function moveTime(e, n) {
-  const [t, o] = givenFieldsToDayTimeNano(n, 5, de), [r, i] = nanoToIsoTimeAndDay(isoTimeFieldsToNano(e) + o);
+  const [t, o] = givenFieldsToBigNano(n, 5, pe), [r, i] = nanoToIsoTimeAndDay(isoTimeFieldsToNano(e) + o);
   return [ r, t + i ];
 }
 
 function moveByIsoDays(e, n) {
-  return n && (e = epochMilliToIso(isoToEpochMilli(e) + n * C)), e;
+  return n && (e = epochMilliToIso(isoToEpochMilli(e) + n * R)), e;
 }
 
-function createMarkerSystem(e, n, t) {
-  const {calendar: o, timeZone: r, epochNanoseconds: i} = t, a = e(o);
-  if (i) {
-    const e = n(r);
-    return [ i, identity, bindArgs(moveZonedEpochNano, a, e), bindArgs(diffZonedEpochNanoExact, a, e) ];
-  }
-  return [ {
-    ...t,
-    ...ve
-  }, isoToEpochNano, bindArgs(moveDateTime, a), bindArgs(diffDateTimesExact, a) ];
-}
-
-function spanDuration(e, n, t, o, r, i, a) {
-  let s = i(o, e);
-  return n && (s = i(s, n)), [ a(o, s, t), r(s) ];
+function spanDuration(e, n, t, o, r, i) {
+  let a = moveRelativeMarker(e, o, r, i);
+  n && (a = moveRelativeMarker(n, a, r, i));
+  const s = ((e, n, t, o, r) => r ? ((e, n, t, o, r) => {
+    const i = compareBigNanos(o.epochNanoseconds, t.epochNanoseconds);
+    return i ? r < 6 ? diffEpochNanoExact(t.epochNanoseconds, o.epochNanoseconds, r) : diffZonedEpochNanoViaCalendar(e, n, i, t, o, r, void 0) : Me;
+  })(o, r, n, t, e) : ((e, n, t, o) => {
+    const r = isoToEpochNano(n), i = isoToEpochNano(t), a = compareBigNanos(i, r);
+    return a ? o <= 6 ? diffEpochNanoExact(r, i, o) : diffDateTimesViaCalendar(e, a, n, t, o, void 0) : Me;
+  })(o, n, t, e))(t, o, a, r, i);
+  return [ s, relativeMarkerToEpochNano(a, i) ];
 }
 
 function addDurations(e, n, t, o, r, i, a) {
   const s = e(normalizeOptions(a).relativeTo), c = Math.max(getLargestDurationUnit(r), getLargestDurationUnit(i));
   if (c < 6 || 6 === c && (!s || !s.epochNanoseconds)) {
-    return createDurationSlots(((e, n, t, o) => {
-      const r = addDayTimeNanos(durationFieldsToDayTimeNano(e, 6), durationFieldsToDayTimeNano(n, 6), o ? -1 : 1);
+    return createDurationSlots(checkDurationUnits(((e, n, t, o) => {
+      const r = addBigNanos(durationFieldsToBigNano(e), durationFieldsToBigNano(n), o ? -1 : 1);
       if (!Number.isFinite(r[0])) {
-        throw new RangeError(y);
+        throw new RangeError(N);
       }
       return {
-        ...De,
+        ...Me,
         ...nanoToDurationDayTimeFields(r, t)
       };
-    })(r, i, c, o));
+    })(r, i, c, o)));
   }
   if (!s) {
-    throw new RangeError(M);
+    throw new RangeError(P);
   }
-  return o && (i = negateDurationFields(i)), createDurationSlots(spanDuration(r, i, c, ...createMarkerSystem(n, t, s))[0]);
+  return o && (i = negateDurationFields(i)), createDurationSlots(spanDuration(r, i, c, ...createRelativeSystem(n, t, s))[0]);
 }
 
 function roundDuration(e, n, t, o, r) {
   const i = getLargestDurationUnit(o), [a, s, c, u, l] = ((e, n, t) => {
-    e = normalizeUnitNameOptions(e, We);
-    let o = on(e);
-    const r = t(e[He]);
+    e = normalizeUnitNameOptions(e, He);
+    let o = sn(e);
+    const r = t(e[Je]);
     let i = parseRoundingIncInteger(e);
-    const a = dn(e, 7);
-    let s = tn(e);
+    const a = hn(e, 7);
+    let s = an(e);
     if (void 0 === o && void 0 === s) {
-      throw new RangeError(E);
+      throw new RangeError(S);
     }
     return null == s && (s = 0), null == o && (o = Math.max(s, n)), checkLargestSmallestUnit(o, s), 
     i = refineRoundingInc(i, s, 1), [ o, s, i, a, r ];
   })(r, i, e), f = Math.max(i, a);
   if (f < 6 || 6 === f && (!l || !l.epochNanoseconds)) {
-    return createDurationSlots(((e, n, t, o, r) => ({
-      ...De,
+    return createDurationSlots(checkDurationUnits(((e, n, t, o, r) => ({
+      ...Me,
       ...balanceDayTimeDuration(e, n, t, o, r)
-    }))(o, a, s, c, u));
+    }))(o, a, s, c, u)));
   }
   if (!l) {
-    throw new RangeError(M);
+    throw new RangeError(P);
   }
-  const d = createMarkerSystem(n, t, l);
-  let m = 0;
-  o.weeks && 7 === s && (m = o.weeks, o = {
+  const d = createRelativeSystem(n, t, l);
+  let p = 0;
+  o.weeks && 7 === s && (p = o.weeks, o = {
     ...o,
     weeks: 0
   });
   let [h, T] = spanDuration(o, void 0, a, ...d);
-  const D = Sn(o), I = Sn(h);
-  if (D && I && D !== I) {
-    throw new RangeError(p);
+  const g = o.sign, D = computeDurationSign(h);
+  if (g && D && g !== D) {
+    throw new RangeError(m);
   }
-  return !I || 0 === s && 1 === c || (h = roundRelativeDuration(h, T, a, s, c, u, ...d)), 
-  h.weeks += m, createDurationSlots(h);
+  return !D || 0 === s && 1 === c || (h = roundRelativeDuration(h, T, a, s, c, u, ...d)), 
+  h.weeks += p, createDurationSlots(h);
+}
+
+function absDuration(e) {
+  return -1 === e.sign ? negateDuration(e) : e;
 }
 
 function negateDuration(e) {
@@ -3436,28 +3450,23 @@ function negateDuration(e) {
 
 function negateDurationFields(e) {
   const n = {};
-  for (const t of de) {
+  for (const t of pe) {
     n[t] = -1 * e[t] || 0;
   }
   return n;
 }
 
-function absDuration(e) {
-  return createDurationSlots(-1 === Sn(n = e) ? negateDurationFields(n) : n);
-  var n;
-}
-
-function queryDurationBlank(e) {
-  return !Sn(e);
+function getDurationBlank(e) {
+  return !e.sign;
 }
 
-function computeDurationSign(e, n = de) {
+function computeDurationSign(e, n = pe) {
   let t = 0;
   for (const o of n) {
     const n = Math.sign(e[o]);
     if (n) {
       if (t && t !== n) {
-        throw new RangeError(N);
+        throw new RangeError(v);
       }
       t = n;
     }
@@ -3465,24 +3474,33 @@ function computeDurationSign(e, n = de) {
   return t;
 }
 
-function checkDurationFields(e) {
-  return Sn(e), e;
+function checkDurationUnits(e) {
+  for (const n of De) {
+    clampEntity(n, e[n], -Bn, Bn, 1);
+  }
+  return checkDurationTimeUnit(bigNanoToNumber(durationFieldsToBigNano(e), A)), e;
 }
 
-function durationFieldsToDayTimeNano(e, n) {
-  return givenFieldsToDayTimeNano(e, n, de);
+function checkDurationTimeUnit(e) {
+  if (!Number.isSafeInteger(e)) {
+    throw new RangeError(y);
+  }
+}
+
+function durationFieldsToBigNano(e, n = 6) {
+  return givenFieldsToBigNano(e, n, pe);
 }
 
 function nanoToDurationDayTimeFields(e, n = 6) {
-  const [t, o] = e, r = nanoToGivenFields(o, n, de);
-  if (r[de[n]] += t * (A / U[n]), !Number.isFinite(r[de[n]])) {
-    throw new RangeError(y);
+  const [t, o] = e, r = nanoToGivenFields(o, n, pe);
+  if (r[pe[n]] += t * (W / j[n]), !Number.isFinite(r[pe[n]])) {
+    throw new RangeError(N);
   }
   return r;
 }
 
 function nanoToDurationTimeFields(e, n = 5) {
-  return nanoToGivenFields(e, n, de);
+  return nanoToGivenFields(e, n, pe);
 }
 
 function clearDurationFields(e, n) {
@@ -3490,18 +3508,18 @@ function clearDurationFields(e, n) {
     ...e
   };
   for (let e = 0; e <= n; e++) {
-    t[de[e]] = 0;
+    t[pe[e]] = 0;
   }
   return t;
 }
 
 function durationHasDateParts(e) {
-  return Boolean(computeDurationSign(e, he));
+  return Boolean(computeDurationSign(e, ge));
 }
 
 function getLargestDurationUnit(e) {
   let n = 9;
-  for (;n > 0 && !e[de[n]]; n--) {}
+  for (;n > 0 && !e[pe[n]]; n--) {}
   return n;
 }
 
@@ -3510,8 +3528,8 @@ function createSplitTuple(e, n) {
 }
 
 function computePeriod(e) {
-  const n = Math.floor(e / Pn) * Pn;
-  return [ n, n + Pn ];
+  const n = Math.floor(e / Sn) * Sn;
+  return [ n, n + Sn ];
 }
 
 function parseInstant(e) {
@@ -3531,8 +3549,8 @@ function parseInstant(e) {
   return n.timeZone && parseOffsetNanoMaybe(n.timeZone, 1), createInstantSlots(isoToEpochNanoWithOffset(checkIsoDateTimeFields(n), t));
 }
 
-function parseZonedOrPlainDateTime(e) {
-  const n = parseDateTimeLike(Le(e));
+function parseRelativeToSlots(e) {
+  const n = parseDateTimeLike(We(e));
   if (!n) {
     throw new RangeError(failedParse(e));
   }
@@ -3546,7 +3564,7 @@ function parseZonedOrPlainDateTime(e) {
 }
 
 function parseZonedDateTime(e, n) {
-  const t = parseDateTimeLike(Le(e));
+  const t = parseDateTimeLike(We(e));
   if (!t || !t.timeZone) {
     throw new RangeError(failedParse(e));
   }
@@ -3563,7 +3581,7 @@ function parseOffsetNano(e) {
 }
 
 function parsePlainDateTime(e) {
-  const n = parseDateTimeLike(Le(e));
+  const n = parseDateTimeLike(We(e));
   if (!n || n.o) {
     throw new RangeError(failedParse(e));
   }
@@ -3571,7 +3589,7 @@ function parsePlainDateTime(e) {
 }
 
 function parsePlainDate(e) {
-  const n = parseDateTimeLike(Le(e));
+  const n = parseDateTimeLike(We(e));
   if (!n || n.o) {
     throw new RangeError(failedParse(e));
   }
@@ -3579,7 +3597,7 @@ function parsePlainDate(e) {
 }
 
 function parsePlainYearMonth(e, n) {
-  const t = parseYearMonthOnly(Le(n));
+  const t = parseYearMonthOnly(We(n));
   if (t) {
     return requireIsoCalendar(t), createPlainYearMonthSlots(checkIsoYearMonthInBounds(checkIsoDateFields(t)));
   }
@@ -3591,13 +3609,13 @@ function parsePlainYearMonth(e, n) {
 }
 
 function requireIsoCalendar(e) {
-  if (e.calendar !== ae) {
+  if (e.calendar !== ce) {
     throw new RangeError(invalidSubstring(e.calendar));
   }
 }
 
 function parsePlainMonthDay(e, n) {
-  const t = parseMonthDayOnly(Le(n));
+  const t = parseMonthDayOnly(We(n));
   if (t) {
     return requireIsoCalendar(t), createPlainMonthDaySlots(checkIsoDateFields(t));
   }
@@ -3607,9 +3625,9 @@ function parsePlainMonthDay(e, n) {
 
 function parsePlainTime(e) {
   let n, t = (e => {
-    const n = Un.exec(e);
+    const n = $n.exec(e);
     return n ? (organizeAnnotationParts(n[10]), organizeTimeParts(n)) : void 0;
-  })(Le(e));
+  })(We(e));
   if (!t) {
     if (t = parseDateTimeLike(e), !t) {
       throw new RangeError(failedParse(e));
@@ -3633,12 +3651,12 @@ function parsePlainTime(e) {
 
 function parseDuration(e) {
   const n = (e => {
-    const n = xn.exec(e);
+    const n = Gn.exec(e);
     return n ? (e => {
-      function parseUnit(e, t, i) {
+      function parseUnit(e, r, i) {
         let a = 0, s = 0;
-        if (i && ([a, r] = divModFloor(r, U[i])), void 0 !== e) {
-          if (o) {
+        if (i && ([a, o] = divModFloor(o, j[i])), void 0 !== e) {
+          if (t) {
             throw new RangeError(invalidSubstring(e));
           }
           s = (e => {
@@ -3647,24 +3665,24 @@ function parseDuration(e) {
               throw new RangeError(invalidSubstring(e));
             }
             return n;
-          })(e), n = 1, t && (r = parseSubsecNano(t) * (U[i] / z), o = 1);
+          })(e), n = 1, r && (o = parseSubsecNano(r) * (j[i] / A), t = 1);
         }
         return a + s;
       }
-      let n = 0, o = 0, r = 0, i = {
-        ...zipProps(de, [ parseUnit(e[2]), parseUnit(e[3]), parseUnit(e[4]), parseUnit(e[5]), parseUnit(e[6], e[7], 5), parseUnit(e[8], e[9], 4), parseUnit(e[10], e[11], 3) ]),
-        ...nanoToGivenFields(r, 2, de)
+      let n = 0, t = 0, o = 0, r = {
+        ...zipProps(pe, [ parseUnit(e[2]), parseUnit(e[3]), parseUnit(e[4]), parseUnit(e[5]), parseUnit(e[6], e[7], 5), parseUnit(e[8], e[9], 4), parseUnit(e[10], e[11], 3) ]),
+        ...nanoToGivenFields(o, 2, pe)
       };
       if (!n) {
-        throw new RangeError(t);
+        throw new RangeError(noValidFields(pe));
       }
-      return parseSign(e[1]) < 0 && (i = negateDurationFields(i)), i;
+      return parseSign(e[1]) < 0 && (r = negateDurationFields(r)), r;
     })(n) : void 0;
-  })(Le(e));
+  })(We(e));
   if (!n) {
     throw new RangeError(failedParse(e));
   }
-  return createDurationSlots(n);
+  return createDurationSlots(checkDurationUnits(n));
 }
 
 function parseCalendarId(e) {
@@ -3674,11 +3692,11 @@ function parseCalendarId(e) {
 
 function parseTimeZoneId(e) {
   const n = parseDateTimeLike(e);
-  return n && (n.timeZone || n.o && Mn || n.offset) || e;
+  return n && (n.timeZone || n.o && En || n.offset) || e;
 }
 
 function finalizeZonedDateTime(e, n, t = 0, o = 0) {
-  const r = resolveTimeZoneId(e.timeZone), i = wn(r);
+  const r = resolveTimeZoneId(e.timeZone), i = kn(r);
   return createZonedDateTimeSlots(getMatchingInstantFor(i, checkIsoDateTimeFields(e), n, t, o, !i.h, e.o), r, resolveCalendarId(e.calendar));
 }
 
@@ -3698,7 +3716,7 @@ function resolveSlotsCalendar(e) {
 }
 
 function parseDateTimeLike(e) {
-  const n = An.exec(e);
+  const n = jn.exec(e);
   return n ? (e => {
     const n = e[10], t = "Z" === (n || "").toUpperCase();
     return {
@@ -3715,7 +3733,7 @@ function parseDateTimeLike(e) {
 }
 
 function parseYearMonthOnly(e) {
-  const n = qn.exec(e);
+  const n = Un.exec(e);
   return n ? (e => ({
     isoYear: organizeIsoYearParts(e),
     isoMonth: parseInt(e[4]),
@@ -3725,9 +3743,9 @@ function parseYearMonthOnly(e) {
 }
 
 function parseMonthDayOnly(e) {
-  const n = Ln.exec(e);
+  const n = Wn.exec(e);
   return n ? (e => ({
-    isoYear: Be,
+    isoYear: qe,
     isoMonth: parseInt(e[1]),
     isoDay: parseInt(e[2]),
     ...organizeAnnotationParts(e[3])
@@ -3735,13 +3753,13 @@ function parseMonthDayOnly(e) {
 }
 
 function parseOffsetNanoMaybe(e, n) {
-  const t = jn.exec(e);
+  const t = xn.exec(e);
   return t ? ((e, n) => {
     const t = e[4] || e[5];
     if (n && t) {
       throw new RangeError(invalidSubstring(t));
     }
-    return validateTimeZoneOffset((parseInt0(e[2]) * L + parseInt0(e[3]) * q + parseInt0(e[4]) * z + parseSubsecNano(e[5] || "")) * parseSign(e[1]));
+    return validateTimeZoneOffset((parseInt0(e[2]) * U + parseInt0(e[3]) * L + parseInt0(e[4]) * A + parseSubsecNano(e[5] || "")) * parseSign(e[1]));
   })(t, n) : void 0;
 }
 
@@ -3766,7 +3784,7 @@ function organizeTimeParts(e) {
 function organizeAnnotationParts(e) {
   let n, t;
   const o = [];
-  if (e.replace(Wn, ((e, r, i) => {
+  if (e.replace(Hn, ((e, r, i) => {
     const a = Boolean(r), [s, c] = i.split("=").reverse();
     if (c) {
       if ("u-ca" === c) {
@@ -3786,7 +3804,7 @@ function organizeAnnotationParts(e) {
   }
   return {
     timeZone: t,
-    calendar: o[0] || ae
+    calendar: o[0] || ce
   };
 }
 
@@ -3808,40 +3826,45 @@ function parseInt0(e) {
 
 function resolveTimeZoneId(e) {
   const n = getTimeZoneEssence(e);
-  return "number" == typeof n ? formatOffsetNano(n) : n ? (e => e.toLowerCase().split("/").map(((e, n) => (e.length <= 3 || /\d/.test(e)) && !/etc|yap/.test(e) ? e.toUpperCase() : e.replace(/baja|dumont|[a-z]+/g, ((e, t) => e.length <= 2 && !n || "in" === e || "chat" === e ? e.toUpperCase() : e.length > 2 || !t ? capitalize(e).replace(/island|noronha|murdo|rivadavia|urville/, capitalize) : e)))).join("/"))(e) : Mn;
+  return "number" == typeof n ? formatOffsetNano(n) : n ? (e => {
+    if (_n.test(e)) {
+      throw new RangeError(T);
+    }
+    return e.toLowerCase().split("/").map(((e, n) => (e.length <= 3 || /\d/.test(e)) && !/etc|yap/.test(e) ? e.toUpperCase() : e.replace(/baja|dumont|[a-z]+/g, ((e, t) => e.length <= 2 && !n || "in" === e || "chat" === e ? e.toUpperCase() : e.length > 2 || !t ? capitalize(e).replace(/island|noronha|murdo|rivadavia|urville/, capitalize) : e)))).join("/");
+  })(e) : En;
 }
 
 function getTimeZoneAtomic(e) {
   const n = getTimeZoneEssence(e);
-  return "number" == typeof n ? n : n ? n.resolvedOptions().timeZone : Mn;
+  return "number" == typeof n ? n : n ? n.resolvedOptions().timeZone : En;
 }
 
 function getTimeZoneEssence(e) {
   const n = parseOffsetNanoMaybe(e = e.toUpperCase(), 1);
-  return void 0 !== n ? n : e !== Mn ? $n(e) : void 0;
+  return void 0 !== n ? n : e !== En ? Vn(e) : void 0;
 }
 
 function compareInstants(e, n) {
-  return compareDayTimeNanos(e.epochNanoseconds, n.epochNanoseconds);
+  return compareBigNanos(e.epochNanoseconds, n.epochNanoseconds);
 }
 
 function compareZonedDateTimes(e, n) {
-  return compareDayTimeNanos(e.epochNanoseconds, n.epochNanoseconds);
+  return compareBigNanos(e.epochNanoseconds, n.epochNanoseconds);
 }
 
 function compareDurations(e, n, t, o, r, i) {
   const a = e(normalizeOptions(i).relativeTo), s = Math.max(getLargestDurationUnit(o), getLargestDurationUnit(r));
-  if (allPropsEqual(de, o, r)) {
+  if (allPropsEqual(pe, o, r)) {
     return 0;
   }
   if (s < 6 || 6 === s && (!a || !a.epochNanoseconds)) {
-    return compareDayTimeNanos(givenFieldsToDayTimeNano(o, 6, de), givenFieldsToDayTimeNano(r, 6, de));
+    return compareBigNanos(givenFieldsToBigNano(o, 6, pe), givenFieldsToBigNano(r, 6, pe));
   }
   if (!a) {
-    throw new RangeError(M);
+    throw new RangeError(P);
   }
-  const [c, u, l] = createMarkerSystem(n, t, a);
-  return compareDayTimeNanos(u(l(c, o)), u(l(c, r)));
+  const [c, u, l] = createRelativeSystem(n, t, a);
+  return compareBigNanos(relativeMarkerToEpochNano(moveRelativeMarker(o, c, u, l), l), relativeMarkerToEpochNano(moveRelativeMarker(r, c, u, l), l));
 }
 
 function compareIsoDateTimeFields(e, n) {
@@ -3903,38 +3926,38 @@ function diffInstants(e, n, t, o) {
 }
 
 function diffZonedDateTimes(e, n, t, o, r, i) {
-  const a = getCommonCalendarSlot(o.calendar, r.calendar), s = copyOptions(i), [c, u, l, f] = refineDiffOptions(t, s, 5), d = o.epochNanoseconds, m = r.epochNanoseconds, p = compareDayTimeNanos(m, d);
-  let h;
+  const a = getCommonCalendarSlot(o.calendar, r.calendar), s = copyOptions(i), [c, u, l, f] = refineDiffOptions(t, s, 5), d = o.epochNanoseconds, m = r.epochNanoseconds, p = compareBigNanos(m, d);
+  let T;
   if (p) {
     if (c < 6) {
-      h = diffEpochNano(d, m, c, u, l, f);
+      T = diffEpochNano(d, m, c, u, l, f);
     } else {
       const t = n(((e, n) => {
         if (!isTimeZoneSlotsEqual(e, n)) {
-          throw new RangeError(T);
+          throw new RangeError(h);
         }
         return e;
       })(o.timeZone, r.timeZone)), i = e(a);
-      h = diffZonedEpochNanoViaCalendar(i, t, p, d, m, c, s), !p || 0 === u && 1 === l || (h = roundRelativeDuration(h, m, c, u, l, f, d, identity, bindArgs(moveZonedEpochNano, i, t)));
+      T = diffZonedEpochNanoViaCalendar(i, t, p, o, r, c, s), !p || 0 === u && 1 === l || (T = roundRelativeDuration(T, m, c, u, l, f, o, i, t));
     }
   } else {
-    h = De;
+    T = Me;
   }
-  return createDurationSlots(t ? negateDurationFields(h) : h);
+  return createDurationSlots(t ? negateDurationFields(T) : T);
 }
 
 function diffPlainDateTimes(e, n, t, o, r) {
-  const i = getCommonCalendarSlot(t.calendar, o.calendar), a = copyOptions(r), [s, c, u, l] = refineDiffOptions(n, a, 6), f = isoToEpochNano(t), d = isoToEpochNano(o), m = compareDayTimeNanos(d, f);
+  const i = getCommonCalendarSlot(t.calendar, o.calendar), a = copyOptions(r), [s, c, u, l] = refineDiffOptions(n, a, 6), f = isoToEpochNano(t), d = isoToEpochNano(o), m = compareBigNanos(d, f);
   let p;
   if (m) {
     if (s <= 6) {
       p = diffEpochNano(f, d, s, c, u, l);
     } else {
       const n = e(i);
-      p = diffDateTimesViaCalendar(n, m, t, o, s, a), !m || 0 === c && 1 === u || (p = roundRelativeDuration(p, d, s, c, u, l, t, isoToEpochNano, bindArgs(moveDateTime, n)));
+      p = diffDateTimesViaCalendar(n, m, t, o, s, a), !m || 0 === c && 1 === u || (p = roundRelativeDuration(p, d, s, c, u, l, t, n));
     }
   } else {
-    p = De;
+    p = Me;
   }
   return createDurationSlots(n ? negateDurationFields(p) : p);
 }
@@ -3952,62 +3975,55 @@ function diffPlainYearMonth(e, n, t, o, r) {
 function diffDateLike(e, n, t, o, r, i, a, s, c) {
   const u = isoToEpochNano(t), l = isoToEpochNano(o);
   let f;
-  if (compareDayTimeNanos(l, u)) {
+  if (compareBigNanos(l, u)) {
     let e;
     6 === r ? f = diffByDay(t, o) : (e = n(), f = e.dateUntil(t, o, r, c)), 6 === i && 1 === a || (e || (e = n()), 
-    f = roundRelativeDuration(f, l, r, i, a, s, t, isoToEpochNano, ((n, t) => e.dateAdd(n, t))));
+    f = roundRelativeDuration(f, l, r, i, a, s, {
+      ...t,
+      ...be
+    }, e));
   } else {
-    f = De;
+    f = Me;
   }
   return createDurationSlots(e ? negateDurationFields(f) : f);
 }
 
 function diffPlainTimes(e, n, t, o) {
   const r = copyOptions(o), [i, a, s, c] = refineDiffOptions(e, r, 5, 5), u = isoTimeFieldsToNano(n), l = roundByInc(isoTimeFieldsToNano(t) - u, computeNanoInc(a, s), c), f = {
-    ...De,
+    ...Me,
     ...nanoToDurationTimeFields(l, i)
   };
   return createDurationSlots(e ? negateDurationFields(f) : f);
 }
 
-function diffZonedEpochNanoExact(e, n, t, o, r, i) {
-  const a = compareDayTimeNanos(o, t);
-  return a ? r < 6 ? diffEpochNanoExact(t, o, r) : diffZonedEpochNanoViaCalendar(e, n, a, t, o, r, i) : De;
-}
-
-function diffDateTimesExact(e, n, t, o, r) {
-  const i = isoToEpochNano(n), a = isoToEpochNano(t), s = compareDayTimeNanos(a, i);
-  return s ? o <= 6 ? diffEpochNanoExact(i, a, o) : diffDateTimesViaCalendar(e, s, n, t, o, r) : De;
-}
-
 function diffZonedEpochNanoViaCalendar(e, n, t, o, r, i, a) {
-  const s = zonedEpochNanoToIso(n, o), c = pluckProps(ge, s), u = zonedEpochNanoToIso(n, r), l = bindArgs(getSingleInstantFor, n);
-  let f, d, m, h = 0;
+  const s = wn(o, n), c = pluckProps(ye, s), u = wn(r, n), l = r.epochNanoseconds, f = bindArgs(getSingleInstantFor, n);
+  let d, p, h, T = 0;
   do {
-    if (h > 2) {
-      throw new RangeError(p);
+    if (T > 2) {
+      throw new RangeError(m);
     }
-    f = {
-      ...moveByIsoDays(u, h++ * -t),
+    d = {
+      ...moveByIsoDays(u, T++ * -t),
       ...c
-    }, d = l(f), m = compareDayTimeNanos(r, d);
-  } while (m === -t);
+    }, p = f(d), h = compareBigNanos(l, p);
+  } while (h === -t);
   return {
-    ...6 === i ? diffByDay(s, f) : e.dateUntil(s, f, i, a),
-    ...nanoToDurationTimeFields(dayTimeNanoToNumber(diffDayTimeNanos(d, r)))
+    ...6 === i ? diffByDay(s, d) : e.dateUntil(s, d, i, a),
+    ...nanoToDurationTimeFields(bigNanoToNumber(diffBigNanos(p, l)))
   };
 }
 
 function diffDateTimesViaCalendar(e, n, t, o, r, i) {
   const a = isoTimeFieldsToNano(t);
   let s = isoTimeFieldsToNano(o) - a, c = t;
-  return Math.sign(s) === -n && (c = moveByIsoDays(t, n), s += A * n), {
+  return Math.sign(s) === -n && (c = moveByIsoDays(t, n), s += W * n), {
     ...e.dateUntil({
       ...c,
-      ...ve
+      ...be
     }, {
       ...o,
-      ...ve
+      ...be
     }, r, i),
     ...nanoToDurationTimeFields(s)
   };
@@ -4015,21 +4031,21 @@ function diffDateTimesViaCalendar(e, n, t, o, r, i) {
 
 function diffEpochNano(e, n, t, o, r, i) {
   return {
-    ...De,
-    ...nanoToDurationDayTimeFields(roundDayTimeNano(diffDayTimeNanos(e, n), o, r, i), t)
+    ...Me,
+    ...nanoToDurationDayTimeFields(roundBigNano(diffBigNanos(e, n), o, r, i), t)
   };
 }
 
 function diffEpochNanoExact(e, n, t) {
   return {
-    ...De,
-    ...nanoToDurationDayTimeFields(diffDayTimeNanos(e, n), t)
+    ...Me,
+    ...nanoToDurationDayTimeFields(diffBigNanos(e, n), t)
   };
 }
 
 function diffByDay(e, n) {
   return {
-    ...De,
+    ...Me,
     days: diffDays(e, n)
   };
 }
@@ -4039,12 +4055,12 @@ function diffDays(e, n) {
 }
 
 function diffEpochMilliByDay(e, n) {
-  return Math.round((n - e) / C);
+  return Math.round((n - e) / R);
 }
 
 function getCommonCalendarSlot(e, n) {
   if (!isIdLikeEqual(e, n)) {
-    throw new RangeError(h);
+    throw new RangeError(p);
   }
   return e;
 }
@@ -4057,7 +4073,7 @@ function createIntlCalendar(e) {
       day: parseInt(e.day)
     }))(hashIntlFormatParts(n, e), t);
   }
-  const n = Hn(e), t = computeCalendarIdBase(e);
+  const n = Kn(e), t = computeCalendarIdBase(e);
   return {
     id: e,
     I: createIntlFieldCache(epochMilliToIntlFields),
@@ -4066,26 +4082,26 @@ function createIntlCalendar(e) {
 }
 
 function createIntlFieldCache(e) {
-  return createLazyGenerator((n => {
+  return memoize((n => {
     const t = isoToEpochMilli(n);
     return e(t);
   }), WeakMap);
 }
 
 function createIntlYearMonthCache(e) {
-  const n = e(0).year - Ce;
-  return createLazyGenerator((t => {
+  const n = e(0).year - ze;
+  return memoize((t => {
     let o, r = isoArgsToEpochMilli(t - n);
     const i = [], a = [];
     do {
-      r += 400 * C;
+      r += 400 * R;
     } while ((o = e(r)).year <= t);
     do {
-      r += (1 - o.day) * C, o.year === t && (i.push(r), a.push(o.month)), r -= C;
+      r += (1 - o.day) * R, o.year === t && (i.push(r), a.push(o.month)), r -= R;
     } while ((o = e(r)).year >= t);
     return {
-      P: i.reverse(),
-      v: S(a.reverse())
+      v: i.reverse(),
+      P: w(a.reverse())
     };
   }));
 }
@@ -4093,9 +4109,9 @@ function createIntlYearMonthCache(e) {
 function parseIntlYear(e, n) {
   let t, o, r = parseIntlPartsYear(e);
   if (e.era) {
-    const a = ue[n];
+    const a = fe[n];
     void 0 !== a && (i = (i = e.era).normalize("NFD").toLowerCase().replace(/[^a-z0-9]/g, ""), 
-    t = le[i] || i, o = r, r = eraYearToYear(o, a[t] || 0));
+    t = de[i] || i, o = r, r = eraYearToYear(o, a[t] || 0));
   }
   var i;
   return {
@@ -4110,12 +4126,12 @@ function parseIntlPartsYear(e) {
 }
 
 function computeIntlDateParts(e) {
-  const {year: n, month: t, day: o} = this.I(e), {v: r} = this.N(n);
+  const {year: n, month: t, day: o} = this.I(e), {P: r} = this.N(n);
   return [ n, r[t] + 1, o ];
 }
 
 function computeIntlEpochMilli(e, n = 1, t = 1) {
-  return this.N(e).P[n - 1] + (t - 1) * C;
+  return this.N(e).v[n - 1] + (t - 1) * R;
 }
 
 function computeIntlLeapMonth(e) {
@@ -4138,32 +4154,40 @@ function computeIntlDaysInYear(e) {
 }
 
 function computeIntlDaysInMonth(e, n) {
-  const {P: t} = this.N(e);
+  const {v: t} = this.N(e);
   let o = n + 1, r = t;
-  return o > t.length && (o = 1, r = this.N(e + 1).P), diffEpochMilliByDay(t[n - 1], r[o - 1]);
+  return o > t.length && (o = 1, r = this.N(e + 1).v), diffEpochMilliByDay(t[n - 1], r[o - 1]);
 }
 
 function computeIntlMonthsInYear(e) {
-  return this.N(e).P.length;
+  return this.N(e).v.length;
 }
 
 function queryMonthStrs(e, n) {
-  return Object.keys(e.N(n).v);
+  return Object.keys(e.N(n).P);
 }
 
 function resolveCalendarId(e) {
-  if ((e = (e => ("islamicc" === (e = e.toLowerCase()) && (e = "islamic-civil"), e))(e)) !== ae && e !== se && computeCalendarIdBase(e) !== computeCalendarIdBase(Hn(e).resolvedOptions().calendar)) {
+  if ((e = e.toLowerCase()) !== ce && e !== ue && computeCalendarIdBase(e) !== computeCalendarIdBase(Kn(e).resolvedOptions().calendar)) {
     throw new RangeError(invalidCalendar(e));
   }
   return e;
 }
 
 function computeCalendarIdBase(e) {
-  return e.split("-")[0];
+  return "islamicc" === e && (e = "islamic"), e.split("-")[0];
+}
+
+function computeNativeWeekOfYear(e) {
+  return this.F(e)[0];
+}
+
+function computeNativeYearOfWeek(e) {
+  return this.F(e)[1];
 }
 
 function parseMonthCode(e) {
-  const n = _n.exec(e);
+  const n = Qn.exec(e);
   if (!n) {
     throw new RangeError(invalidMonthCode(e));
   }
@@ -4183,19 +4207,19 @@ function eraYearToYear(e, n) {
 }
 
 function getCalendarEraOrigins(e) {
-  return ue[getCalendarIdBase(e)];
+  return fe[getCalendarIdBase(e)];
 }
 
 function getCalendarLeapMonthMeta(e) {
-  return fe[getCalendarIdBase(e)];
+  return me[getCalendarIdBase(e)];
 }
 
 function getCalendarIdBase(e) {
-  return computeCalendarIdBase(e.id || ae);
+  return computeCalendarIdBase(e.id || ce);
 }
 
 function refineMaybeZonedDateTimeBag(e, n, t, o) {
-  const r = refineCalendarFields(t, o, te, [], H);
+  const r = refineCalendarFields(t, o, re, [], _);
   if (void 0 !== r.timeZone) {
     const o = t.dateFromFields(r), i = refineTimeBag(r), a = e(r.timeZone);
     return {
@@ -4208,12 +4232,12 @@ function refineMaybeZonedDateTimeBag(e, n, t, o) {
   }
   return {
     ...t.dateFromFields(r),
-    ...ve
+    ...be
   };
 }
 
 function refineZonedDateTimeBag(e, n, t, o, r, i) {
-  const a = refineCalendarFields(t, r, te, $, H), s = e(a.timeZone), [c, u, l] = refineZonedFieldOptions(i), f = t.dateFromFields(a, overrideOverflowOptions(i, c)), d = refineTimeBag(a, c);
+  const a = refineCalendarFields(t, r, re, G, _), s = e(a.timeZone), [c, u, l] = refineZonedFieldOptions(i), f = t.dateFromFields(a, overrideOverflowOptions(i, c)), d = refineTimeBag(a, c);
   return createZonedDateTimeSlots(getMatchingInstantFor(n(s), {
     ...f,
     ...d
@@ -4221,7 +4245,7 @@ function refineZonedDateTimeBag(e, n, t, o, r, i) {
 }
 
 function refinePlainDateTimeBag(e, n, t) {
-  const o = refineCalendarFields(e, n, te, [], j), r = refineOverflowOptions(t);
+  const o = refineCalendarFields(e, n, re, [], $), r = refineOverflowOptions(t);
   return createPlainDateTimeSlots(checkIsoDateTimeInBounds({
     ...e.dateFromFields(o, overrideOverflowOptions(t, r)),
     ...refineTimeBag(o, r)
@@ -4229,30 +4253,30 @@ function refinePlainDateTimeBag(e, n, t) {
 }
 
 function refinePlainDateBag(e, n, t, o = []) {
-  const r = refineCalendarFields(e, n, te, o);
+  const r = refineCalendarFields(e, n, re, o);
   return e.dateFromFields(r, t);
 }
 
 function refinePlainYearMonthBag(e, n, t, o) {
-  const r = refineCalendarFields(e, n, ee, o);
+  const r = refineCalendarFields(e, n, te, o);
   return e.yearMonthFromFields(r, t);
 }
 
 function refinePlainMonthDayBag(e, n, t, o, r = []) {
-  const i = refineCalendarFields(e, t, te, r);
-  return n && void 0 !== i.month && void 0 === i.monthCode && void 0 === i.year && (i.year = Be), 
+  const i = refineCalendarFields(e, t, re, r);
+  return n && void 0 !== i.month && void 0 === i.monthCode && void 0 === i.year && (i.year = qe), 
   e.monthDayFromFields(i, o);
 }
 
 function refinePlainTimeBag(e, n) {
   const t = refineOverflowOptions(n);
-  return createPlainTimeSlots(refineTimeBag(refineFields(e, W, [], 1), t));
+  return createPlainTimeSlots(refineTimeBag(refineFields(e, x, [], 1), t));
 }
 
 function refineDurationBag(e) {
-  const n = refineFields(e, me);
-  return createDurationSlots(checkDurationFields({
-    ...De,
+  const n = refineFields(e, he);
+  return createDurationSlots(checkDurationUnits({
+    ...Me,
     ...n
   }));
 }
@@ -4261,36 +4285,36 @@ function refineCalendarFields(e, n, t, o = [], r = []) {
   return refineFields(n, [ ...e.fields(t), ...r ].sort(), o);
 }
 
-function refineFields(e, n, o, r = !o) {
-  const i = {};
-  let a, s = 0;
-  for (const t of n) {
-    if (t === a) {
-      throw new RangeError(duplicateFields(t));
+function refineFields(e, n, t, o = !t) {
+  const r = {};
+  let i, a = 0;
+  for (const o of n) {
+    if (o === i) {
+      throw new RangeError(duplicateFields(o));
     }
-    if ("constructor" === t || "__proto__" === t) {
-      throw new RangeError(forbiddenField(t));
+    if ("constructor" === o || "__proto__" === o) {
+      throw new RangeError(forbiddenField(o));
     }
-    let n = e[t];
+    let n = e[o];
     if (void 0 !== n) {
-      s = 1, Xn[t] && (n = Xn[t](n, t)), i[t] = n;
-    } else if (o) {
-      if (o.includes(t)) {
-        throw new TypeError(missingField(t));
+      a = 1, tt[o] && (n = tt[o](n, o)), r[o] = n;
+    } else if (t) {
+      if (t.includes(o)) {
+        throw new TypeError(missingField(o));
       }
-      i[t] = ie[t];
+      r[o] = se[o];
     }
-    a = t;
+    i = o;
   }
-  if (r && !s) {
-    throw new TypeError(t);
+  if (o && !a) {
+    throw new TypeError(noValidFields(n));
   }
-  return i;
+  return r;
 }
 
 function refineTimeBag(e, n) {
-  return constrainIsoTimeFields(et({
-    ...ie,
+  return constrainIsoTimeFields(ot({
+    ...se,
     ...e
   }), n);
 }
@@ -4298,7 +4322,7 @@ function refineTimeBag(e, n) {
 function zonedDateTimeWithFields(e, n, t, o, r, i) {
   const a = copyOptions(i), {calendar: s, timeZone: c} = t;
   return createZonedDateTimeSlots(((e, n, t, o, r) => {
-    const i = mergeCalendarFields(e, t, o, te, G, x), [a, s, c] = refineZonedFieldOptions(r, 2);
+    const i = mergeCalendarFields(e, t, o, re, V, H), [a, s, c] = refineZonedFieldOptions(r, 2);
     return getMatchingInstantFor(n, {
       ...e.dateFromFields(i, overrideOverflowOptions(r, a)),
       ...refineTimeBag(i, a)
@@ -4309,7 +4333,7 @@ function zonedDateTimeWithFields(e, n, t, o, r, i) {
 function plainDateTimeWithFields(e, n, t, o, r) {
   const i = copyOptions(r);
   return createPlainDateTimeSlots(((e, n, t, o) => {
-    const r = mergeCalendarFields(e, n, t, te, j), i = refineOverflowOptions(o);
+    const r = mergeCalendarFields(e, n, t, re, $), i = refineOverflowOptions(o);
     return checkIsoDateTimeInBounds({
       ...e.dateFromFields(r, overrideOverflowOptions(o, i)),
       ...refineTimeBag(r, i)
@@ -4320,7 +4344,7 @@ function plainDateTimeWithFields(e, n, t, o, r) {
 function plainDateWithFields(e, n, t, o, r) {
   const i = copyOptions(r);
   return ((e, n, t, o) => {
-    const r = mergeCalendarFields(e, n, t, te);
+    const r = mergeCalendarFields(e, n, t, re);
     return e.dateFromFields(r, o);
   })(e(n.calendar), t, o, i);
 }
@@ -4328,7 +4352,7 @@ function plainDateWithFields(e, n, t, o, r) {
 function plainYearMonthWithFields(e, n, t, o, r) {
   const i = copyOptions(r);
   return createPlainYearMonthSlots(((e, n, t, o) => {
-    const r = mergeCalendarFields(e, n, t, ee);
+    const r = mergeCalendarFields(e, n, t, te);
     return e.yearMonthFromFields(r, o);
   })(e(n.calendar), t, o, i));
 }
@@ -4336,7 +4360,7 @@ function plainYearMonthWithFields(e, n, t, o, r) {
 function plainMonthDayWithFields(e, n, t, o, r) {
   const i = copyOptions(r);
   return ((e, n, t, o) => {
-    const r = mergeCalendarFields(e, n, t, te);
+    const r = mergeCalendarFields(e, n, t, re);
     return e.monthDayFromFields(r, o);
   })(e(n.calendar), t, o, i);
 }
@@ -4345,16 +4369,16 @@ function plainTimeWithFields(e, n, t) {
   return createPlainTimeSlots(((e, n, t) => {
     const o = refineOverflowOptions(t);
     return refineTimeBag({
-      ...pluckProps(W, e),
-      ...refineFields(n, W)
+      ...pluckProps(x, e),
+      ...refineFields(n, x)
     }, o);
   })(e, n, t));
 }
 
 function durationWithFields(e, n) {
-  return createDurationSlots((t = e, o = n, checkDurationFields({
+  return createDurationSlots((t = e, o = n, checkDurationUnits({
     ...t,
-    ...refineFields(o, me)
+    ...refineFields(o, he)
   })));
   var t, o;
 }
@@ -4367,12 +4391,12 @@ function mergeCalendarFields(e, n, t, o, r = [], i = []) {
 }
 
 function convertToPlainMonthDay(e, n) {
-  const t = refineCalendarFields(e, n, re);
+  const t = refineCalendarFields(e, n, ae);
   return e.monthDayFromFields(t);
 }
 
 function convertToPlainYearMonth(e, n, t) {
-  const o = refineCalendarFields(e, n, ne);
+  const o = refineCalendarFields(e, n, oe);
   return e.yearMonthFromFields(o, t);
 }
 
@@ -4384,25 +4408,25 @@ function convertToIso(e, n, t, o, r) {
 
 function refineYear(e, n) {
   let {era: t, eraYear: o, year: r} = n;
-  const i = getCalendarEraOrigins(e);
+  const c = getCalendarEraOrigins(e);
   if (void 0 !== t || void 0 !== o) {
     if (void 0 === t || void 0 === o) {
-      throw new TypeError(s);
+      throw new TypeError(a);
     }
-    if (!i) {
-      throw new RangeError(a);
+    if (!c) {
+      throw new RangeError(i);
     }
-    const e = i[t];
+    const e = c[t];
     if (void 0 === e) {
       throw new RangeError(invalidEra(t));
     }
     const n = eraYearToYear(o, e);
     if (void 0 !== r && r !== n) {
-      throw new RangeError(c);
+      throw new RangeError(s);
     }
     r = n;
   } else if (void 0 === r) {
-    throw new TypeError(missingYear(i));
+    throw new TypeError(missingYear(c));
   }
   return r;
 }
@@ -4411,42 +4435,42 @@ function refineMonth(e, n, t, o) {
   let {month: r, monthCode: i} = n;
   if (void 0 !== i) {
     const n = ((e, n, t, o) => {
-      const r = e.F(t), [i, a] = parseMonthCode(n);
+      const r = e.O(t), [i, a] = parseMonthCode(n);
       let s = monthCodeNumberToMonth(i, a, r);
       if (a) {
         const n = getCalendarLeapMonthMeta(e);
         if (void 0 === n) {
-          throw new RangeError(d);
+          throw new RangeError(f);
         }
         if (n > 0) {
           if (s > n) {
-            throw new RangeError(d);
+            throw new RangeError(f);
           }
           if (void 0 === r) {
             if (1 === o) {
-              throw new RangeError(d);
+              throw new RangeError(f);
             }
             s--;
           }
         } else {
           if (s !== -n) {
-            throw new RangeError(d);
+            throw new RangeError(f);
           }
           if (void 0 === r && 1 === o) {
-            throw new RangeError(d);
+            throw new RangeError(f);
           }
         }
       }
       return s;
     })(e, i, t, o);
     if (void 0 !== r && r !== n) {
-      throw new RangeError(u);
+      throw new RangeError(c);
     }
     r = n, o = 1;
   } else if (void 0 === r) {
-    throw new TypeError(l);
+    throw new TypeError(u);
   }
-  return clampEntity("month", r, 1, e.O(t), o);
+  return clampEntity("month", r, 1, e.B(t), o);
 }
 
 function refineDay(e, n, t, o, r) {
@@ -4466,25 +4490,19 @@ function spliceFields(e, n, t, o) {
   }
 }
 
-function createNativeOpsCreator(e, n) {
-  return t => t === ae ? e : t === se || t === ce ? Object.assign(Object.create(e), {
-    id: t
-  }) : Object.assign(Object.create(n), Gn(t));
-}
-
 function constructInstantSlots(e) {
-  return createInstantSlots(checkEpochNanoInBounds(bigIntToDayTimeNano(toBigInt(e))));
+  return createInstantSlots(checkEpochNanoInBounds(bigIntToBigNano(toBigInt(e))));
 }
 
-function constructZonedDateTimeSlots(e, n, t, o, r = ae) {
-  return createZonedDateTimeSlots(checkEpochNanoInBounds(bigIntToDayTimeNano(toBigInt(t))), n(o), e(r));
+function constructZonedDateTimeSlots(e, n, t, o, r = ce) {
+  return createZonedDateTimeSlots(checkEpochNanoInBounds(bigIntToBigNano(toBigInt(t))), n(o), e(r));
 }
 
-function constructPlainDateTimeSlots(e, n, t, o, r = 0, i = 0, a = 0, s = 0, c = 0, u = 0, l = ae) {
-  return createPlainDateTimeSlots(checkIsoDateTimeInBounds(checkIsoDateTimeFields(mapProps(toInteger, zipProps(Ne, [ n, t, o, r, i, a, s, c, u ])))), e(l));
+function constructPlainDateTimeSlots(e, n, t, o, r = 0, i = 0, a = 0, s = 0, c = 0, u = 0, l = ce) {
+  return createPlainDateTimeSlots(checkIsoDateTimeInBounds(checkIsoDateTimeFields(mapProps(toInteger, zipProps(Pe, [ n, t, o, r, i, a, s, c, u ])))), e(l));
 }
 
-function constructPlainDateSlots(e, n, t, o, r = ae) {
+function constructPlainDateSlots(e, n, t, o, r = ce) {
   return createPlainDateSlots(checkIsoDateInBounds(checkIsoDateFields(mapProps(toInteger, {
     isoYear: n,
     isoMonth: t,
@@ -4492,7 +4510,7 @@ function constructPlainDateSlots(e, n, t, o, r = ae) {
   }))), e(r));
 }
 
-function constructPlainYearMonthSlots(e, n, t, o = ae, r = 1) {
+function constructPlainYearMonthSlots(e, n, t, o = ce, r = 1) {
   const i = toInteger(n), a = toInteger(t), s = e(o);
   return createPlainYearMonthSlots(checkIsoYearMonthInBounds(checkIsoDateFields({
     isoYear: i,
@@ -4501,7 +4519,7 @@ function constructPlainYearMonthSlots(e, n, t, o = ae, r = 1) {
   })), s);
 }
 
-function constructPlainMonthDaySlots(e, n, t, o = ae, r = Be) {
+function constructPlainMonthDaySlots(e, n, t, o = ce, r = qe) {
   const i = toInteger(n), a = toInteger(t), s = e(o);
   return createPlainMonthDaySlots(checkIsoDateInBounds(checkIsoDateFields({
     isoYear: toInteger(r),
@@ -4511,14 +4529,14 @@ function constructPlainMonthDaySlots(e, n, t, o = ae, r = Be) {
 }
 
 function constructPlainTimeSlots(e = 0, n = 0, t = 0, o = 0, r = 0, i = 0) {
-  return createPlainTimeSlots(constrainIsoTimeFields(mapProps(toInteger, zipProps(ge, [ e, n, t, o, r, i ])), 1));
+  return createPlainTimeSlots(constrainIsoTimeFields(mapProps(toInteger, zipProps(ye, [ e, n, t, o, r, i ])), 1));
 }
 
 function constructDurationSlots(e = 0, n = 0, t = 0, o = 0, r = 0, i = 0, a = 0, s = 0, c = 0, u = 0) {
-  return createDurationSlots(checkDurationFields(mapProps(toStrictInteger, zipProps(de, [ e, n, t, o, r, i, a, s, c, u ]))));
+  return createDurationSlots(checkDurationUnits(mapProps(toStrictInteger, zipProps(pe, [ e, n, t, o, r, i, a, s, c, u ]))));
 }
 
-function instantToZonedDateTime(e, n, t = ae) {
+function instantToZonedDateTime(e, n, t = ce) {
   return createZonedDateTimeSlots(e.epochNanoseconds, n, t);
 }
 
@@ -4527,11 +4545,11 @@ function zonedDateTimeToInstant(e) {
 }
 
 function zonedDateTimeToPlainDateTime(e, n) {
-  return createPlainDateTimeSlots(bn(n, e));
+  return createPlainDateTimeSlots(wn(n, e));
 }
 
 function zonedDateTimeToPlainDate(e, n) {
-  return createPlainDateSlots(bn(n, e));
+  return createPlainDateSlots(wn(n, e));
 }
 
 function zonedDateTimeToPlainYearMonth(e, n, t) {
@@ -4543,7 +4561,7 @@ function zonedDateTimeToPlainMonthDay(e, n, t) {
 }
 
 function zonedDateTimeToPlainTime(e, n) {
-  return createPlainTimeSlots(bn(n, e));
+  return createPlainTimeSlots(wn(n, e));
 }
 
 function plainDateTimeToZonedDateTime(e, n, t, o) {
@@ -4566,14 +4584,14 @@ function plainDateTimeToPlainMonthDay(e, n, t) {
 }
 
 function plainDateToZonedDateTime(e, n, t, o, r) {
-  const i = e(r.timeZone), a = r.plainTime, s = void 0 !== a ? n(a) : ve;
+  const i = e(r.timeZone), a = r.plainTime, s = void 0 !== a ? n(a) : be;
   return createZonedDateTimeSlots(getSingleInstantFor(t(i), {
     ...o,
     ...s
   }), i, o.calendar);
 }
 
-function plainDateToPlainDateTime(e, n = ve) {
+function plainDateToPlainDateTime(e, n = be) {
   return createPlainDateTimeSlots(checkIsoDateTimeInBounds({
     ...e,
     ...n
@@ -4589,11 +4607,11 @@ function plainDateToPlainMonthDay(e, n, t) {
 }
 
 function plainYearMonthToPlainDate(e, n, t, o) {
-  return ((e, n, t) => convertToIso(e, n, ne, requireObjectLike(t), X))(e(n.calendar), t, o);
+  return ((e, n, t) => convertToIso(e, n, oe, requireObjectLike(t), ne))(e(n.calendar), t, o);
 }
 
 function plainMonthDayToPlainDate(e, n, t, o) {
-  return ((e, n, t) => convertToIso(e, n, re, requireObjectLike(t), J))(e(n.calendar), t, o);
+  return ((e, n, t) => convertToIso(e, n, ae, requireObjectLike(t), Q))(e(n.calendar), t, o);
 }
 
 function plainTimeToZonedDateTime(e, n, t, o, r) {
@@ -4612,24 +4630,24 @@ function plainTimeToPlainDateTime(e, n) {
 }
 
 function epochSecToInstant(e) {
-  return createInstantSlots(checkEpochNanoInBounds(numberToDayTimeNano(e, z)));
+  return createInstantSlots(checkEpochNanoInBounds(numberToBigNano(e, A)));
 }
 
 function epochMilliToInstant(e) {
-  return createInstantSlots(checkEpochNanoInBounds(numberToDayTimeNano(e, Z)));
+  return createInstantSlots(checkEpochNanoInBounds(numberToBigNano(e, q)));
 }
 
 function epochMicroToInstant(e) {
-  return createInstantSlots(checkEpochNanoInBounds(bigIntToDayTimeNano(toBigInt(e), R)));
+  return createInstantSlots(checkEpochNanoInBounds(bigIntToBigNano(toBigInt(e), z)));
 }
 
 function epochNanoToInstant(e) {
-  return createInstantSlots(checkEpochNanoInBounds(bigIntToDayTimeNano(toBigInt(e))));
+  return createInstantSlots(checkEpochNanoInBounds(bigIntToBigNano(toBigInt(e))));
 }
 
-function zonedDateTimeWithPlainTime(e, n, t = ve) {
+function zonedDateTimeWithPlainTime(e, n, t = be) {
   const o = n.timeZone, r = e(o), i = {
-    ...bn(n, r),
+    ...wn(n, r),
     ...t
   };
   return createZonedDateTimeSlots(getMatchingInstantFor(r, i, i.offsetNanoseconds, 2), o, n.calendar);
@@ -4637,13 +4655,13 @@ function zonedDateTimeWithPlainTime(e, n, t = ve) {
 
 function zonedDateTimeWithPlainDate(e, n, t) {
   const o = n.timeZone, r = e(o), i = {
-    ...bn(n, r),
+    ...wn(n, r),
     ...t
   }, a = getPreferredCalendarSlot(n.calendar, t.calendar);
   return createZonedDateTimeSlots(getMatchingInstantFor(r, i, i.offsetNanoseconds, 2), o, a);
 }
 
-function plainDateTimeWithPlainTime(e, n = ve) {
+function plainDateTimeWithPlainTime(e, n = be) {
   return createPlainDateTimeSlots({
     ...e,
     ...n
@@ -4676,13 +4694,19 @@ function getPreferredCalendarSlot(e, n) {
     return e;
   }
   const t = getId(e), o = getId(n);
-  if (t === o || t === ae) {
+  if (t === o || t === ce) {
     return n;
   }
-  if (o === ae) {
+  if (o === ce) {
     return e;
   }
-  throw new RangeError(h);
+  throw new RangeError(p);
+}
+
+function createNativeOpsCreator(e, n) {
+  return t => t === ce ? e : t === ue || t === le ? Object.assign(Object.create(e), {
+    id: t
+  }) : Object.assign(Object.create(n), Jn(t));
 }
 
 function createOptionsTransformer(e, n, t = []) {
@@ -4698,8 +4722,8 @@ function createOptionsTransformer(e, n, t = []) {
 }
 
 function isoDateFieldsToEpochNano(e, n) {
-  return getSingleInstantFor(wn(n.timeZone), {
-    ...ve,
+  return getSingleInstantFor(kn(n.timeZone), {
+    ...be,
     isoHour: 12,
     ...e
   });
@@ -4711,7 +4735,7 @@ function extractEpochNano(e) {
 
 function createFormatPrepper(e, n = createFormatForPrep) {
   const [t, , , o] = e;
-  return (r, i = wt, ...a) => {
+  return (r, i = Rt, ...a) => {
     const s = n(o ? o(...a) : void 0, r, i, t), c = s.resolvedOptions();
     return [ s, ...toEpochMillis(e, c, ...a) ];
   };
@@ -4720,36 +4744,36 @@ function createFormatPrepper(e, n = createFormatForPrep) {
 function createFormatForPrep(e, n, t, o) {
   if (t = o(t), e) {
     if (void 0 !== t.timeZone) {
-      throw new TypeError(b);
+      throw new TypeError(O);
     }
     t.timeZone = e;
   }
-  return new Fe(n, t);
+  return new Oe(n, t);
 }
 
 function toEpochMillis(e, n, ...t) {
   const [, o, r] = e;
   return t.map((e => (e.calendar && ((e, n, t) => {
-    if ((t || e !== ae) && e !== n) {
-      throw new RangeError(h);
+    if ((t || e !== ce) && e !== n) {
+      throw new RangeError(p);
     }
   })(getId(e.calendar), n.calendar, r), epochNanoToMilli(o(e, n)))));
 }
 
 function getCurrentIsoDateTime(e) {
-  const n = zonedEpochNanoToIso(e, getCurrentEpochNanoseconds());
-  return pluckProps(Ne, n);
+  const n = getCurrentEpochNano();
+  return epochNanoToIso(n, e.getOffsetNanosecondsFor(n));
 }
 
-function getCurrentEpochNanoseconds() {
-  return numberToDayTimeNano(Date.now(), Z);
+function getCurrentEpochNano() {
+  return numberToBigNano(Date.now(), q);
 }
 
 function getCurrentTimeZoneId() {
-  return Ot || (Ot = (new Fe).resolvedOptions().timeZone);
+  return Zt || (Zt = (new Oe).resolvedOptions().timeZone);
 }
 
-const expectedInteger = (e, n) => `Non-integer ${e}: ${n}`, expectedPositive = (e, n) => `Non-positive ${e}: ${n}`, expectedFinite = (e, n) => `Non-finite ${e}: ${n}`, forbiddenBigIntToNumber = e => `Cannot convert bigint to ${e}`, invalidBigInt = e => `Invalid bigint: ${e}`, e = "Cannot convert Symbol to string", n = "Invalid object", numberOutOfRange = (e, n, t, o) => `${e} ${n} must be between ${t}-${o}`, invalidEntity = (e, n) => `Invalid ${e}: ${n}`, missingField = e => `Missing ${e}`, forbiddenField = e => `Invalid field ${e}`, duplicateFields = e => `Duplicate field ${e}`, t = "No valid fields", o = "Invalid bag", r = "Cannot use valueOf", i = "Invalid calling context", a = "Forbidden era/eraYear", s = "Mismatching era/eraYear", c = "Mismatching year/eraYear", invalidEra = e => `Invalid era: ${e}`, missingYear = e => "Missing year" + (e ? "/era/eraYear" : ""), invalidMonthCode = e => `Invalid monthCode: ${e}`, u = "Mismatching month/monthCode", l = "Missing month/monthCode", f = "Cannot guess year", d = "Invalid leap month", m = "Invalid protocol", p = "Invalid protocol results", invalidCalendar = e => `Invalid Calendar: ${e}`, h = "Mismatching Calendars", T = "Mismatching TimeZones", D$1 = "Out-of-bounds offset", I = "Invalid offset for TimeZone", g = "Ambiguous offset", y = "Out-of-bounds date", N = "Cannot mix duration signs", M = "Missing relativeTo", P = "Cannot use large units", E = "Required smallestUnit or largestUnit", v = "smallestUnit > largestUnit", failedParse = e => `Cannot parse: ${e}`, invalidSubstring = e => `Invalid substring: ${e}`, invalidFormatType = e => `Cannot format ${e}`, F = "Mismatching types for formatting", b = "Forbidden timeZone", S = /*@__PURE__*/ bindArgs(mapPropNames, ((e, n) => n)), w = /*@__PURE__*/ bindArgs(mapPropNames, ((e, n, t) => t)), O = /*@__PURE__*/ bindArgs(padNumber, 2), Y = {
+const expectedInteger = (e, n) => `Non-integer ${e}: ${n}`, expectedPositive = (e, n) => `Non-positive ${e}: ${n}`, expectedFinite = (e, n) => `Non-finite ${e}: ${n}`, forbiddenBigIntToNumber = e => `Cannot convert bigint to ${e}`, invalidBigInt = e => `Invalid bigint: ${e}`, e = "Cannot convert Symbol to string", n = "Invalid object", numberOutOfRange = (e, n, t, o, r) => r ? numberOutOfRange(e, r[n], r[t], r[o]) : invalidEntity(e, n) + `; must be between ${t}-${o}`, invalidEntity = (e, n) => `Invalid ${e}: ${n}`, missingField = e => `Missing ${e}`, forbiddenField = e => `Invalid field ${e}`, duplicateFields = e => `Duplicate field ${e}`, noValidFields = e => "No valid fields: " + e.join(), t = "Invalid bag", invalidChoice = (e, n, t) => invalidEntity(e, n) + "; must be " + Object.keys(t).join(), o = "Cannot use valueOf", r = "Invalid calling context", i = "Forbidden era/eraYear", a = "Mismatching era/eraYear", s = "Mismatching year/eraYear", invalidEra = e => `Invalid era: ${e}`, missingYear = e => "Missing year" + (e ? "/era/eraYear" : ""), invalidMonthCode = e => `Invalid monthCode: ${e}`, c = "Mismatching month/monthCode", u = "Missing month/monthCode", l = "Cannot guess year", f = "Invalid leap month", d = "Invalid protocol", m = "Invalid protocol results", p = "Mismatching Calendars", invalidCalendar = e => `Invalid Calendar: ${e}`, h = "Mismatching TimeZones", T = "Forbidden ICU TimeZone", g = "Out-of-bounds offset", D$1 = "Out-of-bounds TimeZone gap", I = "Invalid TimeZone offset", M = "Ambiguous offset", N = "Out-of-bounds date", y = "Out-of-bounds duration", v = "Cannot mix duration signs", P = "Missing relativeTo", E = "Cannot use large units", S = "Required smallestUnit or largestUnit", F = "smallestUnit > largestUnit", failedParse = e => `Cannot parse: ${e}`, invalidSubstring = e => `Invalid substring: ${e}`, invalidFormatType = e => `Cannot format ${e}`, b = "Mismatching types for formatting", O = "Cannot specify TimeZone", w = /*@__PURE__*/ bindArgs(mapPropNames, ((e, n) => n)), B = /*@__PURE__*/ bindArgs(mapPropNames, ((e, n, t) => t)), k = /*@__PURE__*/ bindArgs(padNumber, 2), Y = {
   nanosecond: 0,
   microsecond: 1,
   millisecond: 2,
@@ -4760,12 +4784,12 @@ const expectedInteger = (e, n) => `Non-integer ${e}: ${n}`, expectedPositive = (
   week: 7,
   month: 8,
   year: 9
-}, k = /*@__PURE__*/ Object.keys(Y), C = 864e5, B = 1e3, R = 1e3, Z = 1e6, z = 1e9, q = 6e10, L = 36e11, A = 864e11, U = [ 1, R, Z, z, q, L, A ], j = /*@__PURE__*/ k.slice(0, 6), W = /*@__PURE__*/ sortStrings(j), x = [ "offset" ], $ = [ "timeZone" ], G = /*@__PURE__*/ j.concat(x), H = /*@__PURE__*/ G.concat($), V = [ "era", "eraYear" ], _ = /*@__PURE__*/ V.concat([ "year" ]), J = [ "year" ], K = [ "monthCode" ], Q = /*@__PURE__*/ [ "month" ].concat(K), X = [ "day" ], ee = /*@__PURE__*/ Q.concat(J), ne = /*@__PURE__*/ K.concat(J), te = /*@__PURE__*/ X.concat(ee), oe = /*@__PURE__*/ X.concat(Q), re = /*@__PURE__*/ X.concat(K), ie = /*@__PURE__*/ w(j, 0), ae = "iso8601", se = "gregory", ce = "japanese", ue = {
-  [se]: {
+}, C = /*@__PURE__*/ Object.keys(Y), R = 864e5, Z = 1e3, z = 1e3, q = 1e6, A = 1e9, L = 6e10, U = 36e11, W = 864e11, j = [ 1, z, q, A, L, U, W ], $ = /*@__PURE__*/ C.slice(0, 6), x = /*@__PURE__*/ sortStrings($), H = [ "offset" ], G = [ "timeZone" ], V = /*@__PURE__*/ $.concat(H), _ = /*@__PURE__*/ V.concat(G), J = [ "era", "eraYear" ], K = /*@__PURE__*/ J.concat([ "year" ]), Q = [ "year" ], X = [ "monthCode" ], ee = /*@__PURE__*/ [ "month" ].concat(X), ne = [ "day" ], te = /*@__PURE__*/ ee.concat(Q), oe = /*@__PURE__*/ X.concat(Q), re = /*@__PURE__*/ ne.concat(te), ie = /*@__PURE__*/ ne.concat(ee), ae = /*@__PURE__*/ ne.concat(X), se = /*@__PURE__*/ B($, 0), ce = "iso8601", ue = "gregory", le = "japanese", fe = {
+  [ue]: {
     bce: -1,
     ce: 0
   },
-  [ce]: {
+  [le]: {
     bce: -1,
     ce: 0,
     meiji: 1867,
@@ -4801,39 +4825,39 @@ const expectedInteger = (e, n) => `Non-integer ${e}: ${n}`, expectedPositive = (
   persian: {
     ap: 0
   }
-}, le = {
+}, de = {
   bc: "bce",
   ad: "ce"
-}, fe = {
+}, me = {
   chinese: 13,
   dangi: 13,
   hebrew: -6
-}, de = /*@__PURE__*/ k.map((e => e + "s")), me = /*@__PURE__*/ sortStrings(de), pe = /*@__PURE__*/ de.slice(0, 6), he = /*@__PURE__*/ de.slice(6), Te = /*@__PURE__*/ S(de), De = /*@__PURE__*/ w(de, 0), Ie = /*@__PURE__*/ w(pe, 0), ge = [ "isoNanosecond", "isoMicrosecond", "isoMillisecond", "isoSecond", "isoMinute", "isoHour" ], ye = [ "isoDay", "isoMonth", "isoYear" ], Ne = /*@__PURE__*/ ge.concat(ye), Me = /*@__PURE__*/ sortStrings(ye), Pe = /*@__PURE__*/ sortStrings(ge), Ee = /*@__PURE__*/ sortStrings(Ne), ve = /*@__PURE__*/ w(Pe, 0), Fe = Intl.DateTimeFormat, be = "en-GB", Se = 1e8, we = [ Se, 0 ], Oe = [ -Se, 0 ], Ye = 275760, ke = -271821, Ce = 1970, Be = 1972, Re = 12, Ze = 7, ze = /*@__PURE__*/ isoArgsToEpochMilli(1868, 9, 8), qe = /*@__PURE__*/ createLazyGenerator(computeJapaneseEraParts, WeakMap), Le = /*@__PURE__*/ bindArgs(requireType, "string"), Ae = /*@__PURE__*/ bindArgs(requireType, "boolean"), Ue = /*@__PURE__*/ bindArgs(requireType, "number"), je = /*@__PURE__*/ bindArgs(requireType, "function"), We = "smallestUnit", xe = "unit", $e = "roundingIncrement", Ge = "fractionalSecondDigits", He = "relativeTo", Ve = {
+}, pe = /*@__PURE__*/ C.map((e => e + "s")), he = /*@__PURE__*/ sortStrings(pe), Te = /*@__PURE__*/ pe.slice(0, 6), ge = /*@__PURE__*/ pe.slice(6), De = /*@__PURE__*/ ge.slice(1), Ie = /*@__PURE__*/ w(pe), Me = /*@__PURE__*/ B(pe, 0), Ne = /*@__PURE__*/ B(Te, 0), ye = [ "isoNanosecond", "isoMicrosecond", "isoMillisecond", "isoSecond", "isoMinute", "isoHour" ], ve = [ "isoDay", "isoMonth", "isoYear" ], Pe = /*@__PURE__*/ ye.concat(ve), Ee = /*@__PURE__*/ sortStrings(ve), Se = /*@__PURE__*/ sortStrings(ye), Fe = /*@__PURE__*/ sortStrings(Pe), be = /*@__PURE__*/ B(Se, 0), Oe = Intl.DateTimeFormat, we = "en-GB", Be = 1e8, ke = Be * R, Ye = [ Be, 0 ], Ce = [ -Be, 0 ], Re = 275760, Ze = -271821, ze = 1970, qe = 1972, Ae = 12, Le = /*@__PURE__*/ isoArgsToEpochMilli(1868, 9, 8), Ue = /*@__PURE__*/ memoize(computeJapaneseEraParts, WeakMap), We = /*@__PURE__*/ bindArgs(requireType, "string"), je = /*@__PURE__*/ bindArgs(requireType, "boolean"), $e = /*@__PURE__*/ bindArgs(requireType, "number"), xe = /*@__PURE__*/ bindArgs(requireType, "function"), He = "smallestUnit", Ge = "unit", Ve = "roundingIncrement", _e = "fractionalSecondDigits", Je = "relativeTo", Ke = {
   constrain: 0,
   reject: 1
-}, _e = /*@__PURE__*/ Object.keys(Ve), Je = {
+}, Qe = /*@__PURE__*/ Object.keys(Ke), Xe = {
   compatible: 0,
   reject: 1,
   earlier: 2,
   later: 3
-}, Ke = {
+}, en = {
   reject: 0,
   use: 1,
   prefer: 2,
   ignore: 3
-}, Qe = {
+}, nn = {
   auto: 0,
   never: 1,
   critical: 2,
   always: 3
-}, Xe = {
+}, tn = {
   auto: 0,
   never: 1,
   critical: 2
-}, en = {
+}, on = {
   auto: 0,
   never: 1
-}, nn = {
+}, rn = {
   floor: 0,
   halfFloor: 1,
   ceil: 2,
@@ -4843,7 +4867,7 @@ const expectedInteger = (e, n) => `Non-integer ${e}: ${n}`, expectedPositive = (
   expand: 6,
   halfExpand: 7,
   halfEven: 8
-}, tn = /*@__PURE__*/ bindArgs(refineUnitOption, We), on = /*@__PURE__*/ bindArgs(refineUnitOption, "largestUnit"), rn = /*@__PURE__*/ bindArgs(refineUnitOption, xe), an = /*@__PURE__*/ bindArgs(refineChoiceOption, "overflow", Ve), sn = /*@__PURE__*/ bindArgs(refineChoiceOption, "disambiguation", Je), cn = /*@__PURE__*/ bindArgs(refineChoiceOption, "offset", Ke), un = /*@__PURE__*/ bindArgs(refineChoiceOption, "calendarName", Qe), ln = /*@__PURE__*/ bindArgs(refineChoiceOption, "timeZoneName", Xe), fn = /*@__PURE__*/ bindArgs(refineChoiceOption, "offset", en), dn = /*@__PURE__*/ bindArgs(refineChoiceOption, "roundingMode", nn), mn = "PlainYearMonth", pn = "PlainMonthDay", hn = "PlainDate", Tn = "PlainDateTime", Dn = "PlainTime", In = "ZonedDateTime", gn = "Instant", yn = "Duration", Nn = [ Math.floor, e => hasHalf(e) ? Math.floor(e) : Math.round(e), Math.ceil, e => hasHalf(e) ? Math.ceil(e) : Math.round(e), Math.trunc, e => hasHalf(e) ? Math.trunc(e) || 0 : Math.round(e), e => e < 0 ? Math.floor(e) : Math.ceil(e), e => Math.sign(e) * Math.round(Math.abs(e)) || 0, e => hasHalf(e) ? (e = Math.trunc(e) || 0) + e % 2 : Math.round(e) ], Mn = "UTC", Pn = 5184e3, En = /*@__PURE__*/ isoArgsToEpochSec(1847), vn = /*@__PURE__*/ isoArgsToEpochSec(/*@__PURE__*/ (/*@__PURE__*/ new Date).getUTCFullYear() + 10), Fn = /0+$/, bn = /*@__PURE__*/ createLazyGenerator(_zonedEpochSlotsToIso, WeakMap), Sn = /*@__PURE__*/ createLazyGenerator(computeDurationSign, WeakMap), wn = /*@__PURE__*/ createLazyGenerator((e => {
+}, an = /*@__PURE__*/ bindArgs(refineUnitOption, He), sn = /*@__PURE__*/ bindArgs(refineUnitOption, "largestUnit"), cn = /*@__PURE__*/ bindArgs(refineUnitOption, Ge), un = /*@__PURE__*/ bindArgs(refineChoiceOption, "overflow", Ke), ln = /*@__PURE__*/ bindArgs(refineChoiceOption, "disambiguation", Xe), fn = /*@__PURE__*/ bindArgs(refineChoiceOption, "offset", en), dn = /*@__PURE__*/ bindArgs(refineChoiceOption, "calendarName", nn), mn = /*@__PURE__*/ bindArgs(refineChoiceOption, "timeZoneName", tn), pn = /*@__PURE__*/ bindArgs(refineChoiceOption, "offset", on), hn = /*@__PURE__*/ bindArgs(refineChoiceOption, "roundingMode", rn), Tn = "PlainYearMonth", gn = "PlainMonthDay", Dn = "PlainDate", In = "PlainDateTime", Mn = "PlainTime", Nn = "ZonedDateTime", yn = "Instant", vn = "Duration", Pn = [ Math.floor, e => hasHalf(e) ? Math.floor(e) : Math.round(e), Math.ceil, e => hasHalf(e) ? Math.ceil(e) : Math.round(e), Math.trunc, e => hasHalf(e) ? Math.trunc(e) || 0 : Math.round(e), e => e < 0 ? Math.floor(e) : Math.ceil(e), e => Math.sign(e) * Math.round(Math.abs(e)) || 0, e => hasHalf(e) ? (e = Math.trunc(e) || 0) + e % 2 : Math.round(e) ], En = "UTC", Sn = 5184e3, Fn = /*@__PURE__*/ isoArgsToEpochSec(1847), bn = /*@__PURE__*/ isoArgsToEpochSec(/*@__PURE__*/ (/*@__PURE__*/ new Date).getUTCFullYear() + 10), On = /0+$/, wn = /*@__PURE__*/ memoize(_zonedEpochSlotsToIso, WeakMap), Bn = 2 ** 32 - 1, kn = /*@__PURE__*/ memoize((e => {
   const n = getTimeZoneEssence(e);
   return "object" == typeof n ? new IntlTimeZone(n) : new FixedTimeZone(n || 0);
 }));
@@ -4863,7 +4887,7 @@ class FixedTimeZone {
 
 class IntlTimeZone {
   constructor(e) {
-    this.B = (e => {
+    this.R = (e => {
       function getOffsetSec(e) {
         const i = clampNumber(e, o, r), [a, s] = computePeriod(i), c = n(a), u = n(s);
         return c === u ? c : pinch(t(a, s), c, u, e);
@@ -4876,10 +4900,10 @@ class IntlTimeZone {
         }
         return i;
       }
-      const n = createLazyGenerator(e), t = createLazyGenerator(createSplitTuple);
-      let o = En, r = vn;
+      const n = memoize(e), t = memoize(createSplitTuple);
+      let o = Fn, r = bn;
       return {
-        R(e) {
+        q(e) {
           const n = getOffsetSec(e - 86400), t = getOffsetSec(e + 86400), o = e - n, r = e - t;
           if (n === t) {
             return [ o ];
@@ -4887,11 +4911,11 @@ class IntlTimeZone {
           const i = getOffsetSec(o);
           return i === getOffsetSec(r) ? [ e - i ] : n > t ? [ o, r ] : [];
         },
-        q: getOffsetSec,
+        L: getOffsetSec,
         C(e, i) {
           const a = clampNumber(e, o, r);
           let [s, c] = computePeriod(a);
-          const u = Pn * i, l = i < 0 ? () => c > o || (o = a, 0) : () => s < r || (r = a, 
+          const u = Sn * i, l = i < 0 ? () => c > o || (o = a, 0) : () => s < r || (r = a, 
           0);
           for (;l(); ) {
             const o = n(s), r = n(c);
@@ -4908,27 +4932,27 @@ class IntlTimeZone {
         }
       };
     })((e => n => {
-      const t = hashIntlFormatParts(e, n * B);
+      const t = hashIntlFormatParts(e, n * Z);
       return isoArgsToEpochSec(parseIntlPartsYear(t), parseInt(t.month), parseInt(t.day), parseInt(t.hour), parseInt(t.minute), parseInt(t.second)) - n;
     })(e));
   }
   getOffsetNanosecondsFor(e) {
-    return this.B.q(epochNanoToSec(e)) * z;
+    return this.R.L(epochNanoToSec(e)) * A;
   }
   getPossibleInstantsFor(e) {
-    const [n, t] = [ isoArgsToEpochSec((o = e).isoYear, o.isoMonth, o.isoDay, o.isoHour, o.isoMinute, o.isoSecond), o.isoMillisecond * Z + o.isoMicrosecond * R + o.isoNanosecond ];
+    const [n, t] = [ isoArgsToEpochSec((o = e).isoYear, o.isoMonth, o.isoDay, o.isoHour, o.isoMinute, o.isoSecond), o.isoMillisecond * q + o.isoMicrosecond * z + o.isoNanosecond ];
     var o;
-    return this.B.R(n).map((e => checkEpochNanoInBounds(addDayTimeNanoAndNumber(numberToDayTimeNano(e, z), t))));
+    return this.R.q(n).map((e => checkEpochNanoInBounds(addBigNanoAndNumber(numberToBigNano(e, A), t))));
   }
   C(e, n) {
-    const [t, o] = (e => dayTimeNanoToNumberRemainder(e, z))(e), r = this.B.C(t + (n > 0 || o ? 1 : 0), n);
+    const [t, o] = epochNanoToSecMod(e), r = this.R.C(t + (n > 0 || o ? 1 : 0), n);
     if (void 0 !== r) {
-      return numberToDayTimeNano(r, z);
+      return numberToBigNano(r, A);
     }
   }
 }
 
-const On = "([+−-])", Yn = "(?:[.,](\\d{1,9}))?", kn = `(?:(?:${On}(\\d{6}))|(\\d{4}))-?(\\d{2})`, Cn = "(\\d{2})(?::?(\\d{2})(?::?(\\d{2})" + Yn + ")?)?", Bn = On + Cn, Rn = kn + "-?(\\d{2})(?:[T ]" + Cn + "(Z|" + Bn + ")?)?", Zn = "\\[(!?)([^\\]]*)\\]", zn = `((?:${Zn})*)`, qn = /*@__PURE__*/ createRegExp(kn + zn), Ln = /*@__PURE__*/ createRegExp("(?:--)?(\\d{2})-?(\\d{2})" + zn), An = /*@__PURE__*/ createRegExp(Rn + zn), Un = /*@__PURE__*/ createRegExp("T?" + Cn + "(?:" + Bn + ")?" + zn), jn = /*@__PURE__*/ createRegExp(Bn), Wn = /*@__PURE__*/ new RegExp(Zn, "g"), xn = /*@__PURE__*/ createRegExp(`${On}?P(\\d+Y)?(\\d+M)?(\\d+W)?(\\d+D)?(?:T(?:(\\d+)${Yn}H)?(?:(\\d+)${Yn}M)?(?:(\\d+)${Yn}S)?)?`), $n = /*@__PURE__*/ createLazyGenerator((e => new Fe(be, {
+const Yn = "([+−-])", Cn = "(?:[.,](\\d{1,9}))?", Rn = `(?:(?:${Yn}(\\d{6}))|(\\d{4}))-?(\\d{2})`, Zn = "(\\d{2})(?::?(\\d{2})(?::?(\\d{2})" + Cn + ")?)?", zn = Yn + Zn, qn = Rn + "-?(\\d{2})(?:[T ]" + Zn + "(Z|" + zn + ")?)?", An = "\\[(!?)([^\\]]*)\\]", Ln = `((?:${An}){0,9})`, Un = /*@__PURE__*/ createRegExp(Rn + Ln), Wn = /*@__PURE__*/ createRegExp("(?:--)?(\\d{2})-?(\\d{2})" + Ln), jn = /*@__PURE__*/ createRegExp(qn + Ln), $n = /*@__PURE__*/ createRegExp("T?" + Zn + "(?:" + zn + ")?" + Ln), xn = /*@__PURE__*/ createRegExp(zn), Hn = /*@__PURE__*/ new RegExp(An, "g"), Gn = /*@__PURE__*/ createRegExp(`${Yn}?P(\\d+Y)?(\\d+M)?(\\d+W)?(\\d+D)?(?:T(?:(\\d+)${Cn}H)?(?:(\\d+)${Cn}M)?(?:(\\d+)${Cn}S)?)?`), Vn = /*@__PURE__*/ memoize((e => new Oe(we, {
   timeZone: e,
   era: "short",
   year: "numeric",
@@ -4937,68 +4961,73 @@ const On = "([+−-])", Yn = "(?:[.,](\\d{1,9}))?", kn = `(?:(?:${On}(\\d{6}))|(
   hour: "numeric",
   minute: "numeric",
   second: "numeric"
-}))), Gn = /*@__PURE__*/ createLazyGenerator(createIntlCalendar), Hn = /*@__PURE__*/ createLazyGenerator((e => new Fe(be, {
+}))), _n = /^(AC|AE|AG|AR|AS|BE|BS|CA|CN|CS|CT|EA|EC|IE|IS|JS|MI|NE|NS|PL|PN|PR|PS|SS|VS)T$/, Jn = /*@__PURE__*/ memoize(createIntlCalendar), Kn = /*@__PURE__*/ memoize((e => new Oe(we, {
   calendar: e,
-  timeZone: Mn,
+  timeZone: En,
   era: "short",
   year: "numeric",
   month: "short",
   day: "numeric"
-}))), Vn = {
+}))), Qn = /^M(\d{2})(L?)$/, Xn = {
+  era: toStringViaPrimitive,
+  eraYear: toInteger,
+  year: toInteger,
+  month: toPositiveInteger,
+  monthCode: toStringViaPrimitive,
+  day: toPositiveInteger
+}, et = /*@__PURE__*/ B($, toInteger), nt = /*@__PURE__*/ B(pe, toStrictInteger), tt = /*@__PURE__*/ Object.assign({}, Xn, et, nt, {
+  offset: toStringViaPrimitive
+}), ot = /*@__PURE__*/ bindArgs(remapProps, $, ye), rt = {
   dateAdd(e, n, t) {
     const o = refineOverflowOptions(t);
     let r, {years: i, months: a, weeks: s, days: c} = n;
-    if (c += givenFieldsToDayTimeNano(n, 5, de)[0], i || a) {
+    if (c += givenFieldsToBigNano(n, 5, pe)[0], i || a) {
       let [n, t, s] = this.u(e);
       if (i) {
         const [e, r] = this.l(n, t);
-        n += i, t = monthCodeNumberToMonth(e, r, this.F(n)), t = clampEntity("month", t, 1, this.O(n), o);
+        n += i, t = monthCodeNumberToMonth(e, r, this.O(n)), t = clampEntity("month", t, 1, this.B(n), o);
       }
-      a && ([n, t] = this.L(n, t, a)), s = clampEntity("day", s, 1, this.k(n, t), o), 
-      r = this.U(n, t, s);
+      a && ([n, t] = this.U(n, t, a)), s = clampEntity("day", s, 1, this.k(n, t), o), 
+      r = this.j(n, t, s);
     } else {
       if (!s && !c) {
         return e;
       }
       r = isoToEpochMilli(e);
     }
-    return r += (s * Ze + c) * C, checkIsoDateInBounds(epochMilliToIso(r));
+    return r += (7 * s + c) * R, checkIsoDateInBounds(epochMilliToIso(r));
   },
   dateUntil(e, n, t) {
     if (t <= 7) {
       let o = 0, r = diffDays(e, n);
-      return 7 === t && ([o, r] = divModTrunc(r, Ze)), {
-        ...De,
+      return 7 === t && ([o, r] = divModTrunc(r, 7)), {
+        ...Me,
         weeks: o,
         days: r
       };
     }
     const o = this.u(e), r = this.u(n);
     let [i, a, s] = ((e, n, t, o, r, i, a) => {
-      function updateYearMonth() {
-        const [o, a] = e.l(n, t), [l, f] = e.l(r, i);
-        s = r - n, c = e.O(r), u = s ? l - o || Number(f) - Number(a) : i - Math.min(t, c);
-      }
-      function updateYearMonthDay() {
-        updateYearMonth(), l = e.k(r, i), f = a - Math.min(o, l);
-      }
-      let s, c, u, l, f;
-      updateYearMonthDay();
-      const d = Math.sign(f), m = Math.sign(s) || Math.sign(u) || d;
-      if (m) {
-        if (d === -m) {
-          const n = l;
-          [r, i] = e.L(r, i, -m), updateYearMonthDay(), f += m < 0 ? -n : l;
+      let s = r - n, c = i - t, u = a - o;
+      if (s || c) {
+        const l = Math.sign(s || c);
+        let f = e.k(r, i), d = 0;
+        if (Math.sign(u) === -l) {
+          const o = f;
+          [r, i] = e.U(r, i, -l), s = r - n, c = i - t, f = e.k(r, i), d = l < 0 ? -o : f;
         }
-        if (Math.sign(u) === -m) {
-          const e = c;
-          r -= m, updateYearMonth(), u += m < 0 ? -e : c;
+        if (u = a - Math.min(o, f) + d, s) {
+          const [o, a] = e.l(n, t), [u, f] = e.l(r, i);
+          if (c = u - o || Number(f) - Number(a), Math.sign(c) === -l) {
+            const t = l < 0 && -e.B(r);
+            s = (r -= l) - n, c = i - monthCodeNumberToMonth(o, a, e.O(r)) + (t || e.B(r));
+          }
         }
       }
-      return [ s, u, f ];
+      return [ s, c, u ];
     })(this, ...o, ...r);
-    return 8 === t && (a += this.j(i, o[0]), i = 0), {
-      ...De,
+    return 8 === t && (a += this.$(i, o[0]), i = 0), {
+      ...Me,
       years: i,
       months: a,
       days: s
@@ -5006,53 +5035,53 @@ const On = "([+−-])", Yn = "(?:[.,](\\d{1,9}))?", kn = `(?:(?:${On}(\\d{6}))|(
   },
   dateFromFields(e, n) {
     const t = refineOverflowOptions(n), o = refineYear(this, e), r = refineMonth(this, e, o, t), i = refineDay(this, e, r, o, t);
-    return createPlainDateSlots(checkIsoDateInBounds(this.p(o, r, i)), this.id || ae);
+    return createPlainDateSlots(checkIsoDateInBounds(this.p(o, r, i)), this.id || ce);
   },
   yearMonthFromFields(e, n) {
     const t = refineOverflowOptions(n), o = refineYear(this, e), r = refineMonth(this, e, o, t);
-    return createPlainYearMonthSlots(checkIsoYearMonthInBounds(this.p(o, r, 1)), this.id || ae);
+    return createPlainYearMonthSlots(checkIsoYearMonthInBounds(this.p(o, r, 1)), this.id || ce);
   },
   monthDayFromFields(e, n) {
     const t = refineOverflowOptions(n), o = !this.id, {monthCode: r, year: i, month: a} = e;
-    let s, c, l, d, m;
+    let s, u, f, d, m;
     if (void 0 !== r) {
-      [s, c] = parseMonthCode(r), m = getDefinedProp(e, "day");
-      const n = this.m(s, c, m);
+      [s, u] = parseMonthCode(r), m = getDefinedProp(e, "day");
+      const n = this.m(s, u, m);
       if (!n) {
-        throw new RangeError(f);
+        throw new RangeError(l);
       }
-      if ([l, d] = n, void 0 !== a && a !== d) {
-        throw new RangeError(u);
+      if ([f, d] = n, void 0 !== a && a !== d) {
+        throw new RangeError(c);
       }
-      o && (d = clampEntity("month", d, 1, Re, 1), m = clampEntity("day", m, 1, computeIsoDaysInMonth(void 0 !== i ? i : l, d), t));
+      o && (d = clampEntity("month", d, 1, Ae, 1), m = clampEntity("day", m, 1, computeIsoDaysInMonth(void 0 !== i ? i : f, d), t));
     } else {
-      l = void 0 === i && o ? Be : refineYear(this, e), d = refineMonth(this, e, l, t), 
-      m = refineDay(this, e, d, l, t);
-      const n = this.F(l);
-      c = d === n, s = monthToMonthCodeNumber(d, n);
-      const r = this.m(s, c, m);
+      f = void 0 === i && o ? qe : refineYear(this, e), d = refineMonth(this, e, f, t), 
+      m = refineDay(this, e, d, f, t);
+      const n = this.O(f);
+      u = d === n, s = monthToMonthCodeNumber(d, n);
+      const r = this.m(s, u, m);
       if (!r) {
-        throw new RangeError(f);
+        throw new RangeError(l);
       }
-      [l, d] = r;
+      [f, d] = r;
     }
-    return createPlainMonthDaySlots(this.p(l, d, m), this.id || ae);
+    return createPlainMonthDaySlots(this.p(f, d, m), this.id || ce);
   },
   fields(e) {
-    return getCalendarEraOrigins(this) && e.includes("year") ? [ ...e, ...V ] : e;
+    return getCalendarEraOrigins(this) && e.includes("year") ? [ ...e, ...J ] : e;
   },
   mergeFields(e, n) {
     const t = Object.assign(Object.create(null), e);
-    return spliceFields(t, n, Q), getCalendarEraOrigins(this) && (spliceFields(t, n, _), 
-    this.id === ce && spliceFields(t, n, oe, V)), t;
+    return spliceFields(t, n, ee), getCalendarEraOrigins(this) && (spliceFields(t, n, K), 
+    this.id === le && spliceFields(t, n, ie, J)), t;
   },
   inLeapYear(e) {
     const [n] = this.u(e);
-    return this.$(n);
+    return this.G(n);
   },
   monthsInYear(e) {
     const [n] = this.u(e);
-    return this.O(n);
+    return this.B(n);
   },
   daysInMonth(e) {
     const [n, t] = this.u(e);
@@ -5060,63 +5089,70 @@ const On = "([+−-])", Yn = "(?:[.,](\\d{1,9}))?", kn = `(?:(?:${On}(\\d{6}))|(
   },
   daysInYear(e) {
     const [n] = this.u(e);
-    return this.G(n);
+    return this.V(n);
   },
   era(e) {
-    return this.V(e)[0];
+    return this._(e)[0];
   },
   eraYear(e) {
-    return this.V(e)[1];
+    return this._(e)[1];
   },
   monthCode(e) {
     const [n, t] = this.u(e), [o, r] = this.l(n, t);
-    return ((e, n) => "M" + O(e) + (n ? "L" : ""))(o, r);
+    return ((e, n) => "M" + k(e) + (n ? "L" : ""))(o, r);
   },
   dayOfWeek: computeIsoDayOfWeek,
-  weekOfYear(e) {
-    return computeIsoWeekParts(e)[1];
-  },
-  yearOfWeek(e) {
-    return computeIsoWeekParts(e)[0];
-  },
   daysInWeek() {
-    return Ze;
+    return 7;
   }
-}, _n = /^M(\d{2})(L?)$/, Jn = {
-  era: toStringViaPrimitive,
-  eraYear: toInteger,
-  year: toInteger,
-  month: toPositiveInteger,
-  monthCode: toStringViaPrimitive,
-  day: toPositiveInteger
-}, Kn = /*@__PURE__*/ w(j, toInteger), Qn = /*@__PURE__*/ w(de, toStrictInteger), Xn = /*@__PURE__*/ Object.assign({}, Jn, Kn, Qn, {
-  offset: toStringViaPrimitive
-}), et = /*@__PURE__*/ bindArgs(remapProps, j, ge), nt = /*@__PURE__*/ createNativeOpsCreator(/*@__PURE__*/ Object.assign({}, Vn, {
+}, it = {
+  weekOfYear: computeNativeWeekOfYear,
+  yearOfWeek: computeNativeYearOfWeek,
+  F(e) {
+    function computeWeekShift(e) {
+      return (7 - e < n ? 7 : 0) - e;
+    }
+    function computeWeeksInYear(e) {
+      const n = computeIsoDaysInYear(u + e), t = e || 1;
+      return (n + (computeWeekShift(modFloor(a + n * t, 7)) - s) * t) / 7;
+    }
+    const n = this.id ? 1 : 4, t = computeIsoDayOfWeek(e), o = computeIsoDayOfYear(e), r = modFloor(t - 1, 7), i = o - 1, a = modFloor(r - i, 7), s = computeWeekShift(a);
+    let c = Math.floor((i - s) / 7) + 1, u = e.isoYear;
+    return c ? c > computeWeeksInYear(0) && (c = 1, u++) : (c = computeWeeksInYear(-1), 
+    u--), [ c, u ];
+  }
+}, at = {
+  weekOfYear: computeNativeWeekOfYear,
+  yearOfWeek: computeNativeYearOfWeek,
+  F() {
+    return [];
+  }
+}, st = /*@__PURE__*/ createNativeOpsCreator(/*@__PURE__*/ Object.assign({}, rt, it, {
   u: e => [ e.isoYear, e.isoMonth, e.isoDay ],
-  V(e) {
-    return this.id === se ? computeGregoryEraParts(e) : this.id === ce ? qe(e) : [ void 0, void 0 ];
+  _(e) {
+    return this.id === ue ? computeGregoryEraParts(e) : this.id === le ? Ue(e) : [];
   },
   l: (e, n) => [ n, 0 ],
   m(e, n) {
     if (!n) {
-      return [ Be, e ];
+      return [ qe, e ];
     }
   },
-  $: computeIsoInLeapYear,
-  F() {},
-  O: computeIsoMonthsInYear,
-  j: e => e * Re,
+  G: computeIsoInLeapYear,
+  O() {},
+  B: computeIsoMonthsInYear,
+  $: e => e * Ae,
   k: computeIsoDaysInMonth,
-  G: computeIsoDaysInYear,
+  V: computeIsoDaysInYear,
   dayOfYear: computeIsoDayOfYear,
   p: (e, n, t) => ({
     isoYear: e,
     isoMonth: n,
     isoDay: t
   }),
-  U: isoArgsToEpochMilli,
-  L: (e, n, t) => (e += divTrunc(t, Re), (n += modTrunc(t, Re)) < 1 ? (e--, n += Re) : n > Re && (e++, 
-  n -= Re), [ e, n ]),
+  j: isoArgsToEpochMilli,
+  U: (e, n, t) => (e += divTrunc(t, Ae), (n += modTrunc(t, Ae)) < 1 ? (e--, n += Ae) : n > Ae && (e++, 
+  n -= Ae), [ e, n ]),
   year(e) {
     return e.isoYear;
   },
@@ -5124,9 +5160,9 @@ const On = "([+−-])", Yn = "(?:[.,](\\d{1,9}))?", kn = `(?:(?:${On}(\\d{6}))|(
     return e.isoMonth;
   },
   day: e => e.isoDay
-}), /*@__PURE__*/ Object.assign({}, Vn, {
+}), /*@__PURE__*/ Object.assign({}, rt, at, {
   u: computeIntlDateParts,
-  V(e) {
+  _(e) {
     const n = this.I(e);
     return [ n.era, n.eraYear ];
   },
@@ -5136,8 +5172,8 @@ const On = "([+−-])", Yn = "(?:[.,](\\d{1,9}))?", kn = `(?:(?:${On}(\\d{6}))|(
   },
   m(e, n, t) {
     let [o, r, i] = computeIntlDateParts.call(this, {
-      isoYear: Be,
-      isoMonth: Re,
+      isoYear: qe,
+      isoMonth: Ae,
       isoDay: 31
     });
     const a = computeIntlLeapMonth.call(this, o), s = r === a;
@@ -5149,13 +5185,13 @@ const On = "([+−-])", Yn = "(?:[.,](\\d{1,9}))?", kn = `(?:(?:${On}(\\d{6}))|(
       }
     }
   },
-  $(e) {
+  G(e) {
     const n = computeIntlDaysInYear.call(this, e);
     return n > computeIntlDaysInYear.call(this, e - 1) && n > computeIntlDaysInYear.call(this, e + 1);
   },
-  F: computeIntlLeapMonth,
-  O: computeIntlMonthsInYear,
-  j(e, n) {
+  O: computeIntlLeapMonth,
+  B: computeIntlMonthsInYear,
+  $(e, n) {
     const t = n + e, o = Math.sign(e), r = o < 0 ? -1 : 0;
     let i = 0;
     for (let e = n; e !== t; e += o) {
@@ -5164,33 +5200,30 @@ const On = "([+−-])", Yn = "(?:[.,](\\d{1,9}))?", kn = `(?:(?:${On}(\\d{6}))|(
     return i;
   },
   k: computeIntlDaysInMonth,
-  G: computeIntlDaysInYear,
+  V: computeIntlDaysInYear,
   dayOfYear(e) {
     const n = isoToEpochMilli({
       ...e,
-      ...ve
+      ...be
     }), {year: t} = this.I(e);
-    return diffEpochMilliByDay(computeIntlEpochMilli.call(this, t), n);
+    return diffEpochMilliByDay(computeIntlEpochMilli.call(this, t), n) + 1;
   },
   p(e, n, t) {
     return checkIsoDateInBounds({
       ...epochMilliToIso(computeIntlEpochMilli.call(this, e, n, t))
     });
   },
-  U: computeIntlEpochMilli,
-  L(e, n, t) {
+  j: computeIntlEpochMilli,
+  U(e, n, t) {
     if (t) {
-      if (n += t, t < 0) {
-        if (n < Number.MIN_SAFE_INTEGER) {
-          throw new RangeError(y);
-        }
+      if (n += t, !Number.isSafeInteger(n)) {
+        throw new RangeError(N);
+      }
+      if (t < 0) {
         for (;n < 1; ) {
           n += computeIntlMonthsInYear.call(this, --e);
         }
       } else {
-        if (n > Number.MAX_SAFE_INTEGER) {
-          throw new RangeError(y);
-        }
         let t;
         for (;n > (t = computeIntlMonthsInYear.call(this, e)); ) {
           n -= t, e++;
@@ -5203,47 +5236,47 @@ const On = "([+−-])", Yn = "(?:[.,](\\d{1,9}))?", kn = `(?:(?:${On}(\\d{6}))|(
     return this.I(e).year;
   },
   month(e) {
-    const {year: n, month: t} = this.I(e), {v: o} = this.N(n);
+    const {year: n, month: t} = this.I(e), {P: o} = this.N(n);
     return o[t] + 1;
   },
   day(e) {
     return this.I(e).day;
   }
-})), tt = "numeric", ot = [ "timeZoneName" ], rt = {
-  month: tt,
-  day: tt
-}, it = {
-  year: tt,
-  month: tt
-}, at = /*@__PURE__*/ Object.assign({}, it, {
-  day: tt
-}), st = {
-  hour: tt,
-  minute: tt,
-  second: tt
-}, ct = /*@__PURE__*/ Object.assign({}, at, st), ut = /*@__PURE__*/ Object.assign({}, ct, {
+})), ct = "numeric", ut = [ "timeZoneName" ], lt = {
+  month: ct,
+  day: ct
+}, ft = {
+  year: ct,
+  month: ct
+}, dt = /*@__PURE__*/ Object.assign({}, ft, {
+  day: ct
+}), mt = {
+  hour: ct,
+  minute: ct,
+  second: ct
+}, pt = /*@__PURE__*/ Object.assign({}, dt, mt), ht = /*@__PURE__*/ Object.assign({}, pt, {
   timeZoneName: "short"
-}), lt = /*@__PURE__*/ Object.keys(rt), ft = /*@__PURE__*/ Object.keys(it), dt = /*@__PURE__*/ Object.keys(at), mt = /*@__PURE__*/ Object.keys(st), pt = /*@__PURE__*/ dt.concat([ "weekday", "dateStyle" ]), ht = /*@__PURE__*/ mt.concat([ "dayPeriod", "timeStyle" ]), Tt = /*@__PURE__*/ pt.concat(ht), Dt = /*@__PURE__*/ Tt.concat(ot), It = /*@__PURE__*/ ot.concat(ht), gt = /*@__PURE__*/ ot.concat(pt), yt = /*@__PURE__*/ ot.concat([ "day", "weekday", "dateStyle" ], ht), Nt = /*@__PURE__*/ createOptionsTransformer(lt, rt, /*@__PURE__*/ ot.concat([ "year", "weekday", "dateStyle" ], ht)), Mt = [ /*@__PURE__*/ createOptionsTransformer(ft, it, yt), isoDateFieldsToEpochNano, 1 ], Pt = [ Nt, isoDateFieldsToEpochNano, 1 ], Et = [ /*@__PURE__*/ createOptionsTransformer(pt, at, It), isoDateFieldsToEpochNano ], vt = [ /*@__PURE__*/ createOptionsTransformer(Tt, ct, ot), isoDateFieldsToEpochNano ], Ft = [ /*@__PURE__*/ createOptionsTransformer(ht, st, gt), (e, n) => getSingleInstantFor(wn(n.timeZone), {
-  isoYear: Ce,
+}), Tt = /*@__PURE__*/ Object.keys(lt), gt = /*@__PURE__*/ Object.keys(ft), Dt = /*@__PURE__*/ Object.keys(dt), It = /*@__PURE__*/ Object.keys(mt), Mt = /*@__PURE__*/ Dt.concat([ "weekday", "dateStyle" ]), Nt = /*@__PURE__*/ It.concat([ "dayPeriod", "timeStyle" ]), yt = /*@__PURE__*/ Mt.concat(Nt), vt = /*@__PURE__*/ yt.concat(ut), Pt = /*@__PURE__*/ ut.concat(Nt), Et = /*@__PURE__*/ ut.concat(Mt), St = /*@__PURE__*/ ut.concat([ "day", "weekday", "dateStyle" ], Nt), Ft = /*@__PURE__*/ createOptionsTransformer(Tt, lt, /*@__PURE__*/ ut.concat([ "year", "weekday", "dateStyle" ], Nt)), bt = [ /*@__PURE__*/ createOptionsTransformer(gt, ft, St), isoDateFieldsToEpochNano, 1 ], Ot = [ Ft, isoDateFieldsToEpochNano, 1 ], wt = [ /*@__PURE__*/ createOptionsTransformer(Mt, dt, Pt), isoDateFieldsToEpochNano ], Bt = [ /*@__PURE__*/ createOptionsTransformer(yt, pt, ut), isoDateFieldsToEpochNano ], kt = [ /*@__PURE__*/ createOptionsTransformer(Nt, mt, Et), (e, n) => getSingleInstantFor(kn(n.timeZone), {
+  isoYear: ze,
   isoMonth: 1,
   isoDay: 1,
   ...e
-}) ], bt = [ /*@__PURE__*/ createOptionsTransformer(Tt, ct), extractEpochNano ], St = [ /*@__PURE__*/ createOptionsTransformer(Dt, ut), extractEpochNano, 0, (e, n) => {
+}) ], Yt = [ /*@__PURE__*/ createOptionsTransformer(yt, pt), extractEpochNano ], Ct = [ /*@__PURE__*/ createOptionsTransformer(vt, ht), extractEpochNano, 0, (e, n) => {
   const t = getId(e.timeZone);
   if (n && getId(n.timeZone) !== t) {
-    throw new RangeError(T);
+    throw new RangeError(h);
   }
   return t;
-} ], wt = {};
+} ], Rt = {};
 
-let Ot;
+let Zt;
 
-function createSlotClass(e, t, n, o, r) {
+function createSlotClass(e, t, n, o, a) {
   function Class(...e) {
     if (!(this instanceof Class)) {
-      throw new TypeError(i);
+      throw new TypeError(r);
     }
-    Ea(this, t(...e));
+    za(this, t(...e));
   }
   function bindMethod(e, t) {
     return Object.defineProperties((function(...t) {
@@ -5251,9 +5284,9 @@ function createSlotClass(e, t, n, o, r) {
     }), createNameDescriptors(t));
   }
   function getSpecificSlots(t) {
-    const n = Aa(t);
+    const n = Ua(t);
     if (!n || n.branding !== e) {
-      throw new TypeError(i);
+      throw new TypeError(r);
     }
     return n;
   }
@@ -5262,42 +5295,42 @@ function createSlotClass(e, t, n, o, r) {
     ...createPropDescriptors(mapProps(bindMethod, o)),
     ...createStringTagDescriptors("Temporal." + e)
   }), Object.defineProperties(Class, {
-    ...createPropDescriptors(r),
+    ...createPropDescriptors(a),
     ...createNameDescriptors(e)
   }), [ Class, e => {
     const t = Object.create(Class.prototype);
-    return Ea(t, e), t;
+    return za(t, e), t;
   }, getSpecificSlots ];
 }
 
 function createProtocolValidator(e) {
   return e = e.concat("id").sort(), t => {
     if (!hasAllPropsByName(t, e)) {
-      throw new TypeError(m);
+      throw new TypeError(d);
     }
     return t;
   };
 }
 
 function rejectInvalidBag(e) {
-  if (Aa(e) || void 0 !== e.calendar || void 0 !== e.timeZone) {
-    throw new TypeError(o);
+  if (Ua(e) || void 0 !== e.calendar || void 0 !== e.timeZone) {
+    throw new TypeError(t);
   }
   return e;
 }
 
 function createDateTimeFormatClass() {
-  const e = Fe.prototype, t = Object.getOwnPropertyDescriptors(e), n = Object.getOwnPropertyDescriptors(Fe), DateTimeFormat = function(e, t = {}) {
+  const e = Oe.prototype, t = Object.getOwnPropertyDescriptors(e), n = Object.getOwnPropertyDescriptors(Oe), DateTimeFormat = function(e, t = {}) {
     if (!(this instanceof DateTimeFormat)) {
       return new DateTimeFormat(e, t);
     }
-    Va.set(this, ((e, t = {}) => {
-      const n = new Fe(e, t), o = n.resolvedOptions(), r = o.locale, a = pluckProps(Object.keys(t), o), i = createLazyGenerator(createFormatPrepperForBranding), prepFormat = (...e) => {
+    Ha.set(this, ((e, t = {}) => {
+      const n = new Oe(e, t), o = n.resolvedOptions(), r = o.locale, a = pluckProps(Object.keys(t), o), i = memoize(createFormatPrepperForBranding), prepFormat = (...e) => {
         let t;
         const o = e.map(((e, n) => {
-          const o = Aa(e), r = (o || {}).branding;
+          const o = Ua(e), r = (o || {}).branding;
           if (n && t && t !== r) {
-            throw new TypeError(F);
+            throw new TypeError(b);
           }
           return t = r, o;
         }));
@@ -5318,30 +5351,30 @@ function createDateTimeFormatClass() {
 
 function createFormatMethod(e) {
   return function(...t) {
-    const n = Va.get(this), [o, ...r] = n(...t);
+    const n = Ha.get(this), [o, ...r] = n(...t);
     return o[e](...r);
   };
 }
 
 function createProxiedMethod(e) {
   return function(...t) {
-    return Va.get(this).J[e](...t);
+    return Ha.get(this).J[e](...t);
   };
 }
 
 function createFormatPrepperForBranding(e) {
-  const t = Ja[e];
+  const t = Ka[e];
   if (!t) {
     throw new TypeError(invalidFormatType(e));
   }
-  return createFormatPrepper(t, createLazyGenerator(createFormatForPrep));
+  return createFormatPrepper(t, memoize(createFormatForPrep));
 }
 
 function createCalendarFieldMethods(e, t) {
   const n = {};
   for (const o in e) {
     n[o] = ({K: e}, n) => {
-      const r = Aa(n) || {}, {branding: a} = r, i = a === hn || t.includes(a) ? r : toPlainDateSlots(n);
+      const r = Ua(n) || {}, {branding: a} = r, i = a === Dn || t.includes(a) ? r : toPlainDateSlots(n);
       return e[o](i);
     };
   }
@@ -5353,7 +5386,7 @@ function createCalendarGetters(e) {
   for (const n in e) {
     t[n] = e => {
       const {calendar: t} = e;
-      return (o = t, "string" == typeof o ? nt(o) : (r = o, Object.assign(Object.create(ni), {
+      return (o = t, "string" == typeof o ? st(o) : (r = o, Object.assign(Object.create(mi), {
         X: r
       })))[n](e);
       var o, r;
@@ -5363,85 +5396,56 @@ function createCalendarGetters(e) {
 }
 
 function neverValueOf() {
-  throw new TypeError(r);
+  throw new TypeError(o);
 }
 
 function createCalendarFromSlots({calendar: e}) {
-  return "string" == typeof e ? new ns(e) : e;
+  return "string" == typeof e ? new ds(e) : e;
 }
 
 function toPlainMonthDaySlots(e, t) {
   if (t = copyOptions(t), isObjectLike(e)) {
-    const n = Aa(e);
-    if (n && n.branding === pn) {
+    const n = Ua(e);
+    if (n && n.branding === gn) {
       return refineOverflowOptions(t), n;
     }
     const o = extractCalendarSlotFromBag(e);
-    return refinePlainMonthDayBag(Wi(o || ae), !o, e, t);
+    return refinePlainMonthDayBag(_i(o || ce), !o, e, t);
   }
-  const n = parsePlainMonthDay(nt, e);
+  const n = parsePlainMonthDay(st, e);
   return refineOverflowOptions(t), n;
 }
 
 function getOffsetNanosecondsForAdapter(e, t, n) {
-  return o = t.call(e, hi(createInstantSlots(n))), validateTimeZoneOffset(requireInteger(o));
+  return o = t.call(e, bi(createInstantSlots(n))), validateTimeZoneOffset(requireInteger(o));
   var o;
 }
 
-function createAdapterOps(e, t = ui) {
+function createAdapterOps(e, t = Ci) {
   const n = Object.keys(t).sort(), o = {};
   for (const r of n) {
-    o[r] = bindArgs(t[r], e, je(e[r]));
+    o[r] = bindArgs(t[r], e, xe(e[r]));
   }
   return o;
 }
 
 function createTimeZoneOps(e, t) {
-  return "string" == typeof e ? wn(e) : createAdapterOps(e, t);
+  return "string" == typeof e ? kn(e) : createAdapterOps(e, t);
 }
 
 function createTimeZoneOffsetOps(e) {
-  return createTimeZoneOps(e, di);
-}
-
-function toPlainYearMonthSlots(e, t) {
-  if (t = copyOptions(t), isObjectLike(e)) {
-    const n = Aa(e);
-    return n && n.branding === mn ? (refineOverflowOptions(t), n) : refinePlainYearMonthBag(xi(getCalendarSlotFromBag(e)), e, t);
-  }
-  const n = parsePlainYearMonth(nt, e);
-  return refineOverflowOptions(t), n;
-}
-
-function toZonedDateTimeSlots(e, t) {
-  if (t = copyOptions(t), isObjectLike(e)) {
-    const n = Aa(e);
-    if (n && n.branding === In) {
-      return refineZonedFieldOptions(t), n;
-    }
-    const o = getCalendarSlotFromBag(e);
-    return refineZonedDateTimeBag(refineTimeZoneSlot, createTimeZoneOps, Ri(o), o, e, t);
-  }
-  return parseZonedDateTime(e, t);
-}
-
-function slotsToIso(e) {
-  return bn(e, createTimeZoneOffsetOps);
-}
-
-function adaptDateMethods(e) {
-  return mapProps((e => t => e(slotsToIso(t))), e);
+  return createTimeZoneOps(e, gi);
 }
 
 function toInstantSlots(e) {
   if (isObjectLike(e)) {
-    const t = Aa(e);
+    const t = Ua(e);
     if (t) {
       switch (t.branding) {
-       case gn:
+       case yn:
         return t;
 
-       case In:
+       case Nn:
         return createInstantSlots(t.epochNanoseconds);
       }
     }
@@ -5449,30 +5453,30 @@ function toInstantSlots(e) {
   return parseInstant(e);
 }
 
-function qt() {
-  return hi(createInstantSlots(numberToDayTimeNano(this.valueOf(), Z)));
+function xt() {
+  return bi(createInstantSlots(numberToBigNano(this.valueOf(), q)));
 }
 
 function getImplTransition(e, t, n) {
   const o = t.C(toInstantSlots(n).epochNanoseconds, e);
-  return o ? hi(createInstantSlots(o)) : null;
+  return o ? bi(createInstantSlots(o)) : null;
 }
 
 function refineTimeZoneSlot(e) {
-  return isObjectLike(e) ? (Aa(e) || {}).timeZone || gi(e) : (e => resolveTimeZoneId(parseTimeZoneId(Le(e))))(e);
+  return isObjectLike(e) ? (Ua(e) || {}).timeZone || wi(e) : (e => resolveTimeZoneId(parseTimeZoneId(We(e))))(e);
 }
 
 function toPlainTimeSlots(e, t) {
   if (isObjectLike(e)) {
-    const n = Aa(e) || {};
+    const n = Ua(e) || {};
     switch (n.branding) {
-     case Dn:
+     case Mn:
       return refineOverflowOptions(t), n;
 
-     case Tn:
+     case In:
       return refineOverflowOptions(t), createPlainTimeSlots(n);
 
-     case In:
+     case Nn:
       return refineOverflowOptions(t), zonedDateTimeToPlainTime(createTimeZoneOffsetOps, n);
     }
     return refinePlainTimeBag(e, t);
@@ -5484,23 +5488,32 @@ function optionalToPlainTimeFields(e) {
   return void 0 === e ? void 0 : toPlainTimeSlots(e);
 }
 
+function toPlainYearMonthSlots(e, t) {
+  if (t = copyOptions(t), isObjectLike(e)) {
+    const n = Ua(e);
+    return n && n.branding === Tn ? (refineOverflowOptions(t), n) : refinePlainYearMonthBag(Xi(getCalendarSlotFromBag(e)), e, t);
+  }
+  const n = parsePlainYearMonth(st, e);
+  return refineOverflowOptions(t), n;
+}
+
 function toPlainDateTimeSlots(e, t) {
   if (t = copyOptions(t), isObjectLike(e)) {
-    const n = Aa(e) || {};
+    const n = Ua(e) || {};
     switch (n.branding) {
-     case Tn:
+     case In:
       return refineOverflowOptions(t), n;
 
-     case hn:
+     case Dn:
       return refineOverflowOptions(t), createPlainDateTimeSlots({
         ...n,
-        ...ve
+        ...be
       });
 
-     case In:
+     case Nn:
       return refineOverflowOptions(t), zonedDateTimeToPlainDateTime(createTimeZoneOffsetOps, n);
     }
-    return refinePlainDateTimeBag(Ri(getCalendarSlotFromBag(e)), e, t);
+    return refinePlainDateTimeBag($i(getCalendarSlotFromBag(e)), e, t);
   }
   const n = parsePlainDateTime(e);
   return refineOverflowOptions(t), n;
@@ -5508,29 +5521,29 @@ function toPlainDateTimeSlots(e, t) {
 
 function toPlainDateSlots(e, t) {
   if (t = copyOptions(t), isObjectLike(e)) {
-    const n = Aa(e) || {};
+    const n = Ua(e) || {};
     switch (n.branding) {
-     case hn:
+     case Dn:
       return refineOverflowOptions(t), n;
 
-     case Tn:
+     case In:
       return refineOverflowOptions(t), createPlainDateSlots(n);
 
-     case In:
+     case Nn:
       return refineOverflowOptions(t), zonedDateTimeToPlainDate(createTimeZoneOffsetOps, n);
     }
-    return refinePlainDateBag(Ri(getCalendarSlotFromBag(e)), e, t);
+    return refinePlainDateBag($i(getCalendarSlotFromBag(e)), e, t);
   }
   const n = parsePlainDate(e);
   return refineOverflowOptions(t), n;
 }
 
 function dayAdapter(e, t, n) {
-  return requirePositiveInteger(t.call(e, wi(createPlainDateSlots(n, e))));
+  return requirePositiveInteger(t.call(e, Vi(createPlainDateSlots(n, e))));
 }
 
 function createCompoundOpsCreator(e) {
-  return t => "string" == typeof t ? nt(t) : ((e, t) => {
+  return t => "string" == typeof t ? st(t) : ((e, t) => {
     const n = Object.keys(t).sort(), o = {};
     for (const r of n) {
       o[r] = bindArgs(t[r], e, e[r]);
@@ -5541,8 +5554,8 @@ function createCompoundOpsCreator(e) {
 
 function toDurationSlots(e) {
   if (isObjectLike(e)) {
-    const t = Aa(e);
-    return t && t.branding === yn ? t : refineDurationBag(e);
+    const t = Ua(e);
+    return t && t.branding === vn ? t : refineDurationBag(e);
   }
   return parseDuration(e);
 }
@@ -5550,27 +5563,27 @@ function toDurationSlots(e) {
 function refinePublicRelativeTo(e) {
   if (void 0 !== e) {
     if (isObjectLike(e)) {
-      const t = Aa(e) || {};
+      const t = Ua(e) || {};
       switch (t.branding) {
-       case In:
-       case hn:
+       case Nn:
+       case Dn:
         return t;
 
-       case Tn:
+       case In:
         return createPlainDateSlots(t);
       }
       const n = getCalendarSlotFromBag(e);
       return {
-        ...refineMaybeZonedDateTimeBag(refineTimeZoneSlot, createTimeZoneOps, Ri(n), e),
+        ...refineMaybeZonedDateTimeBag(refineTimeZoneSlot, createTimeZoneOps, $i(n), e),
         calendar: n
       };
     }
-    return parseZonedOrPlainDateTime(e);
+    return parseRelativeToSlots(e);
   }
 }
 
 function getCalendarSlotFromBag(e) {
-  return extractCalendarSlotFromBag(e) || ae;
+  return extractCalendarSlotFromBag(e) || ce;
 }
 
 function extractCalendarSlotFromBag(e) {
@@ -5581,210 +5594,157 @@ function extractCalendarSlotFromBag(e) {
 }
 
 function refineCalendarSlot(e) {
-  return isObjectLike(e) ? (Aa(e) || {}).calendar || os(e) : (e => resolveCalendarId(parseCalendarId(Le(e))))(e);
+  return isObjectLike(e) ? (Ua(e) || {}).calendar || fs(e) : (e => resolveCalendarId(parseCalendarId(We(e))))(e);
+}
+
+function toZonedDateTimeSlots(e, t) {
+  if (t = copyOptions(t), isObjectLike(e)) {
+    const n = Ua(e);
+    if (n && n.branding === Nn) {
+      return refineZonedFieldOptions(t), n;
+    }
+    const o = getCalendarSlotFromBag(e);
+    return refineZonedDateTimeBag(refineTimeZoneSlot, createTimeZoneOps, $i(o), o, e, t);
+  }
+  return parseZonedDateTime(e, t);
+}
+
+function slotsToIso(e) {
+  return wn(e, createTimeZoneOffsetOps);
+}
+
+function adaptDateMethods(e) {
+  return mapProps((e => t => e(slotsToIso(t))), e);
 }
 
-const Ya = /*@__PURE__*/ new WeakMap, Aa = /*@__PURE__*/ Ya.get.bind(Ya), Ea = /*@__PURE__*/ Ya.set.bind(Ya), kt = /*@__PURE__*/ createDateTimeFormatClass(), Va = /*@__PURE__*/ new WeakMap, Ja = {
-  PlainYearMonth: Mt,
-  PlainMonthDay: Pt,
-  PlainDate: Et,
-  PlainDateTime: vt,
-  PlainTime: Ft,
-  Instant: bt
-}, La = /*@__PURE__*/ createFormatPrepper(Mt), ka = /*@__PURE__*/ createFormatPrepper(Pt), qa = /*@__PURE__*/ createFormatPrepper(Et), xa = /*@__PURE__*/ createFormatPrepper(vt), Ra = /*@__PURE__*/ createFormatPrepper(Ft), Wa = /*@__PURE__*/ createFormatPrepper(bt), Ga = /*@__PURE__*/ createFormatPrepper(St), Ua = {
+const Ga = /*@__PURE__*/ new WeakMap, Ua = /*@__PURE__*/ Ga.get.bind(Ga), za = /*@__PURE__*/ Ga.set.bind(Ga), qt = /*@__PURE__*/ createDateTimeFormatClass(), Ha = /*@__PURE__*/ new WeakMap, Ka = {
+  PlainYearMonth: bt,
+  PlainMonthDay: Ot,
+  PlainDate: wt,
+  PlainDateTime: Bt,
+  PlainTime: kt,
+  Instant: Yt
+}, Qa = /*@__PURE__*/ createFormatPrepper(bt), Xa = /*@__PURE__*/ createFormatPrepper(Ot), $a = /*@__PURE__*/ createFormatPrepper(wt), _a = /*@__PURE__*/ createFormatPrepper(Bt), ei = /*@__PURE__*/ createFormatPrepper(kt), ti = /*@__PURE__*/ createFormatPrepper(Yt), ni = /*@__PURE__*/ createFormatPrepper(Ct), oi = {
   era: requireStringOrUndefined,
   eraYear: requireIntegerOrUndefined,
   year: requireInteger,
   month: requirePositiveInteger,
   daysInMonth: requirePositiveInteger,
   daysInYear: requirePositiveInteger,
-  inLeapYear: Ae,
+  inLeapYear: je,
   monthsInYear: requirePositiveInteger
-}, za = {
-  monthCode: Le
-}, Ha = {
+}, ri = {
+  monthCode: We
+}, ai = {
   day: requirePositiveInteger
-}, Ka = {
+}, ii = {
   dayOfWeek: requirePositiveInteger,
   dayOfYear: requirePositiveInteger,
-  weekOfYear: requirePositiveInteger,
-  yearOfWeek: requireInteger,
+  weekOfYear: requirePositiveIntegerOrUndefined,
+  yearOfWeek: requireIntegerOrUndefined,
   daysInWeek: requirePositiveInteger
-}, Qa = /*@__PURE__*/ Object.assign({}, Ua, za, Ha, Ka), Xa = {
-  ...createCalendarFieldMethods(Ua, [ mn ]),
-  ...createCalendarFieldMethods(Ka, []),
-  ...createCalendarFieldMethods(za, [ mn, pn ]),
-  ...createCalendarFieldMethods(Ha, [ pn ])
-}, $a = /*@__PURE__*/ createCalendarGetters(Qa), _a = /*@__PURE__*/ createCalendarGetters({
-  ...Ua,
-  ...za
-}), ei = /*@__PURE__*/ createCalendarGetters({
-  ...za,
-  ...Ha
-}), ti = {
+}, si = /*@__PURE__*/ Object.assign({}, oi, ri, ai, ii), li = {
+  ...createCalendarFieldMethods(oi, [ Tn ]),
+  ...createCalendarFieldMethods(ii, []),
+  ...createCalendarFieldMethods(ri, [ Tn, gn ]),
+  ...createCalendarFieldMethods(ai, [ gn ])
+}, ci = /*@__PURE__*/ createCalendarGetters(si), ui = /*@__PURE__*/ createCalendarGetters({
+  ...oi,
+  ...ri
+}), di = /*@__PURE__*/ createCalendarGetters({
+  ...ri,
+  ...ai
+}), fi = {
   calendarId: e => getId(e.calendar)
-}, ni = /*@__PURE__*/ mapProps(((e, t) => function(n) {
+}, mi = /*@__PURE__*/ mapProps(((e, t) => function(n) {
   const {X: o} = this;
-  return e(o[t](wi(createPlainDateSlots(n, o))));
-}), Qa), oi = /*@__PURE__*/ mapPropNames((e => t => t[e]), de), ri = /*@__PURE__*/ mapPropNames(((e, t) => e => e[ge[t]]), j), ai = {
+  return e(o[t](Vi(createPlainDateSlots(n, o))));
+}), si), Si = /*@__PURE__*/ mapPropNames((e => t => t[e]), pe.concat("sign")), Oi = /*@__PURE__*/ mapPropNames(((e, t) => e => e[ye[t]]), $), Ti = {
   epochSeconds: getEpochSeconds,
   epochMilliseconds: getEpochMilliseconds,
   epochMicroseconds: getEpochMicroseconds,
   epochNanoseconds: getEpochNanoseconds
-}, ii = /*@__PURE__*/ bindArgs(excludePropsByName, new Set([ "branding" ])), [si, li, ci] = createSlotClass(pn, bindArgs(constructPlainMonthDaySlots, refineCalendarSlot), {
-  ...ti,
-  ...ei
+}, pi = /*@__PURE__*/ bindArgs(excludePropsByName, new Set([ "branding" ])), [hi, Pi, Di] = createSlotClass(gn, bindArgs(constructPlainMonthDaySlots, refineCalendarSlot), {
+  ...fi,
+  ...di
 }, {
   with(e, t, n) {
-    return li(plainMonthDayWithFields(zi, e, this, rejectInvalidBag(t), n));
+    return Pi(plainMonthDayWithFields(ns, e, this, rejectInvalidBag(t), n));
   },
   equals: (e, t) => plainMonthDaysEqual(e, toPlainMonthDaySlots(t)),
   toString: formatPlainMonthDayIso,
   toJSON: e => formatPlainMonthDayIso(e),
   toLocaleString(e, t, n) {
-    const [o, r] = ka(t, n, e);
+    const [o, r] = Xa(t, n, e);
     return o.format(r);
   },
   toPlainDate(e, t) {
-    return wi(plainMonthDayToPlainDate(Ui, e, this, t));
+    return Vi(plainMonthDayToPlainDate(ts, e, this, t));
   },
-  getISOFields: ii,
+  getISOFields: pi,
   getCalendar: createCalendarFromSlots,
   valueOf: neverValueOf
 }, {
-  from: (e, t) => li(toPlainMonthDaySlots(e, t))
-}), ui = {
+  from: (e, t) => Pi(toPlainMonthDaySlots(e, t))
+}), Ci = {
   getOffsetNanosecondsFor: getOffsetNanosecondsForAdapter,
   getPossibleInstantsFor(e, t, n) {
-    return [ ...t.call(e, Ii(createPlainDateTimeSlots(n, ae))) ].map((e => Pi(e).epochNanoseconds));
+    const o = [ ...t.call(e, Ai(createPlainDateTimeSlots(n, ce))) ].map((e => Fi(e).epochNanoseconds)), r = o.length;
+    return r > 1 && (o.sort(compareBigNanos), validateTimeZoneGap(bigNanoToNumber(diffBigNanos(o[0], o[r - 1])))), o;
   }
-}, di = {
+}, gi = {
   getOffsetNanosecondsFor: getOffsetNanosecondsForAdapter
-}, [fi, mi, Si] = createSlotClass(mn, bindArgs(constructPlainYearMonthSlots, refineCalendarSlot), {
-  ...ti,
-  ..._a
-}, {
-  with(e, t, n) {
-    return mi(plainYearMonthWithFields(Gi, e, this, rejectInvalidBag(t), n));
-  },
-  add: (e, t, n) => mi(movePlainYearMonth(Qi, 0, e, toDurationSlots(t), n)),
-  subtract: (e, t, n) => mi(movePlainYearMonth(Qi, 1, e, toDurationSlots(t), n)),
-  until: (e, t, n) => _i(diffPlainYearMonth(Xi, 0, e, toPlainYearMonthSlots(t), n)),
-  since: (e, t, n) => _i(diffPlainYearMonth(Xi, 1, e, toPlainYearMonthSlots(t), n)),
-  equals: (e, t) => plainYearMonthsEqual(e, toPlainYearMonthSlots(t)),
-  toString: formatPlainYearMonthIso,
-  toJSON: e => formatPlainYearMonthIso(e),
-  toLocaleString(e, t, n) {
-    const [o, r] = La(t, n, e);
-    return o.format(r);
-  },
-  toPlainDate(e, t) {
-    return wi(plainYearMonthToPlainDate(Ui, e, this, t));
-  },
-  getISOFields: ii,
-  getCalendar: createCalendarFromSlots,
-  valueOf: neverValueOf
-}, {
-  from: (e, t) => mi(toPlainYearMonthSlots(e, t)),
-  compare: (e, t) => compareIsoDateFields(toPlainYearMonthSlots(e), toPlainYearMonthSlots(t))
-}), [Oi, Ti] = createSlotClass(In, bindArgs(constructZonedDateTimeSlots, refineCalendarSlot, refineTimeZoneSlot), {
-  ...ai,
-  ...ti,
-  ...adaptDateMethods($a),
-  ...adaptDateMethods(ri),
-  hoursInDay: e => computeHoursInDay(createTimeZoneOps, e),
-  offsetNanoseconds: e => slotsToIso(e).offsetNanoseconds,
-  offset: e => formatOffsetNano(slotsToIso(e).offsetNanoseconds),
-  timeZoneId: e => getId(e.timeZone)
-}, {
-  with(e, t, n) {
-    return Ti(zonedDateTimeWithFields(Ui, createTimeZoneOps, e, this, rejectInvalidBag(t), n));
-  },
-  withPlainTime: (e, t) => Ti(zonedDateTimeWithPlainTime(createTimeZoneOps, e, optionalToPlainTimeFields(t))),
-  withPlainDate: (e, t) => Ti(zonedDateTimeWithPlainDate(createTimeZoneOps, e, toPlainDateSlots(t))),
-  withTimeZone: (e, t) => Ti(slotsWithTimeZone(e, refineTimeZoneSlot(t))),
-  withCalendar: (e, t) => Ti(slotsWithCalendar(e, refineCalendarSlot(t))),
-  add: (e, t, n) => Ti(moveZonedDateTime(Hi, createTimeZoneOps, 0, e, toDurationSlots(t), n)),
-  subtract: (e, t, n) => Ti(moveZonedDateTime(Hi, createTimeZoneOps, 1, e, toDurationSlots(t), n)),
-  until: (e, t, n) => _i(createDurationSlots(diffZonedDateTimes(Ki, createTimeZoneOps, 0, e, toZonedDateTimeSlots(t), n))),
-  since: (e, t, n) => _i(createDurationSlots(diffZonedDateTimes(Ki, createTimeZoneOps, 1, e, toZonedDateTimeSlots(t), n))),
-  round: (e, t) => Ti(roundZonedDateTime(createTimeZoneOps, e, t)),
-  startOfDay: e => Ti(computeStartOfDay(createTimeZoneOps, e)),
-  equals: (e, t) => zonedDateTimesEqual(e, toZonedDateTimeSlots(t)),
-  toString: (e, t) => formatZonedDateTimeIso(createTimeZoneOffsetOps, e, t),
-  toJSON: e => formatZonedDateTimeIso(createTimeZoneOffsetOps, e),
-  toLocaleString(e, t, n = {}) {
-    const [o, r] = Ga(t, n, e);
-    return o.format(r);
-  },
-  toInstant: e => hi(zonedDateTimeToInstant(e)),
-  toPlainDate: e => wi(zonedDateTimeToPlainDate(createTimeZoneOffsetOps, e)),
-  toPlainTime: e => bi(zonedDateTimeToPlainTime(createTimeZoneOffsetOps, e)),
-  toPlainDateTime: e => Ii(zonedDateTimeToPlainDateTime(createTimeZoneOffsetOps, e)),
-  toPlainYearMonth(e) {
-    return mi(zonedDateTimeToPlainYearMonth(xi, e, this));
-  },
-  toPlainMonthDay(e) {
-    return li(zonedDateTimeToPlainMonthDay(Wi, e, this));
-  },
-  getISOFields: e => buildZonedIsoFields(createTimeZoneOffsetOps, e),
-  getCalendar: createCalendarFromSlots,
-  getTimeZone: ({timeZone: e}) => "string" == typeof e ? new Di(e) : e,
-  valueOf: neverValueOf
-}, {
-  from: (e, t) => Ti(toZonedDateTimeSlots(e, t)),
-  compare: (e, t) => compareZonedDateTimes(toZonedDateTimeSlots(e), toZonedDateTimeSlots(t))
-}), [pi, hi, Pi] = createSlotClass(gn, constructInstantSlots, ai, {
-  add: (e, t) => hi(moveInstant(0, e, toDurationSlots(t))),
-  subtract: (e, t) => hi(moveInstant(1, e, toDurationSlots(t))),
-  until: (e, t, n) => _i(diffInstants(0, e, toInstantSlots(t), n)),
-  since: (e, t, n) => _i(diffInstants(1, e, toInstantSlots(t), n)),
-  round: (e, t) => hi(roundInstant(e, t)),
+}, [Zi, bi, Fi] = createSlotClass(yn, constructInstantSlots, Ti, {
+  add: (e, t) => bi(moveInstant(0, e, toDurationSlots(t))),
+  subtract: (e, t) => bi(moveInstant(1, e, toDurationSlots(t))),
+  until: (e, t, n) => ls(diffInstants(0, e, toInstantSlots(t), n)),
+  since: (e, t, n) => ls(diffInstants(1, e, toInstantSlots(t), n)),
+  round: (e, t) => bi(roundInstant(e, t)),
   equals: (e, t) => instantsEqual(e, toInstantSlots(t)),
   toString: (e, t) => formatInstantIso(refineTimeZoneSlot, createTimeZoneOffsetOps, e, t),
   toJSON: e => formatInstantIso(refineTimeZoneSlot, createTimeZoneOffsetOps, e),
   toLocaleString(e, t, n) {
-    const [o, r] = Wa(t, n, e);
+    const [o, r] = ti(t, n, e);
     return o.format(r);
   },
-  toZonedDateTimeISO: (e, t) => Ti(instantToZonedDateTime(e, refineTimeZoneSlot(t))),
+  toZonedDateTimeISO: (e, t) => Ss(instantToZonedDateTime(e, refineTimeZoneSlot(t))),
   toZonedDateTime(e, t) {
     const n = requireObjectLike(t);
-    return Ti(instantToZonedDateTime(e, refineTimeZoneSlot(n.timeZone), refineCalendarSlot(n.calendar)));
+    return Ss(instantToZonedDateTime(e, refineTimeZoneSlot(n.timeZone), refineCalendarSlot(n.calendar)));
   },
   valueOf: neverValueOf
 }, {
-  from: e => hi(toInstantSlots(e)),
-  fromEpochSeconds: e => hi(epochSecToInstant(e)),
-  fromEpochMilliseconds: e => hi(epochMilliToInstant(e)),
-  fromEpochMicroseconds: e => hi(epochMicroToInstant(e)),
-  fromEpochNanoseconds: e => hi(epochNanoToInstant(e)),
+  from: e => bi(toInstantSlots(e)),
+  fromEpochSeconds: e => bi(epochSecToInstant(e)),
+  fromEpochMilliseconds: e => bi(epochMilliToInstant(e)),
+  fromEpochMicroseconds: e => bi(epochMicroToInstant(e)),
+  fromEpochNanoseconds: e => bi(epochNanoToInstant(e)),
   compare: (e, t) => compareInstants(toInstantSlots(e), toInstantSlots(t))
-}), [Di, Ci] = createSlotClass("TimeZone", (e => {
+}), [Ii, vi] = createSlotClass("TimeZone", (e => {
   const t = resolveTimeZoneId(e);
   return {
     branding: "TimeZone",
     id: t,
-    K: wn(t)
+    K: kn(t)
   };
 }), {
   id: e => e.id
 }, {
   toString: e => e.id,
   toJSON: e => e.id,
-  getPossibleInstantsFor: ({K: e}, t) => e.getPossibleInstantsFor(toPlainDateTimeSlots(t)).map((e => hi(createInstantSlots(e)))),
+  getPossibleInstantsFor: ({K: e}, t) => e.getPossibleInstantsFor(toPlainDateTimeSlots(t)).map((e => bi(createInstantSlots(e)))),
   getOffsetNanosecondsFor: ({K: e}, t) => e.getOffsetNanosecondsFor(toInstantSlots(t).epochNanoseconds),
   getOffsetStringFor(e, t) {
-    const n = toInstantSlots(t).epochNanoseconds, o = createAdapterOps(this, di).getOffsetNanosecondsFor(n);
+    const n = toInstantSlots(t).epochNanoseconds, o = createAdapterOps(this, gi).getOffsetNanosecondsFor(n);
     return formatOffsetNano(o);
   },
-  getPlainDateTimeFor(e, t, n = ae) {
-    const o = toInstantSlots(t).epochNanoseconds, r = createAdapterOps(this, di).getOffsetNanosecondsFor(o);
-    return Ii(createPlainDateTimeSlots(epochNanoToIso(o, r), refineCalendarSlot(n)));
+  getPlainDateTimeFor(e, t, n = ce) {
+    const o = toInstantSlots(t).epochNanoseconds, r = createAdapterOps(this, gi).getOffsetNanosecondsFor(o);
+    return Ai(createPlainDateTimeSlots(epochNanoToIso(o, r), refineCalendarSlot(n)));
   },
   getInstantFor(e, t, n) {
     const o = toPlainDateTimeSlots(t), r = refineEpochDisambigOptions(n), a = createAdapterOps(this);
-    return hi(createInstantSlots(getSingleInstantFor(a, o, r)));
+    return bi(createInstantSlots(getSingleInstantFor(a, o, r)));
   },
   getNextTransition: ({K: e}, t) => getImplTransition(1, e, t),
   getPreviousTransition: ({K: e}, t) => getImplTransition(-1, e, t),
@@ -5794,153 +5754,179 @@ const Ya = /*@__PURE__*/ new WeakMap, Aa = /*@__PURE__*/ Ya.get.bind(Ya), Ea = /
 }, {
   from(e) {
     const t = refineTimeZoneSlot(e);
-    return "string" == typeof t ? new Di(t) : t;
+    return "string" == typeof t ? new Ii(t) : t;
   }
-}), gi = /*@__PURE__*/ createProtocolValidator(Object.keys(ui)), [Zi, bi] = createSlotClass(Dn, constructPlainTimeSlots, ri, {
+}), wi = /*@__PURE__*/ createProtocolValidator(Object.keys(Ci)), [ji, Mi] = createSlotClass(Mn, constructPlainTimeSlots, Oi, {
   with(e, t, n) {
-    return bi(plainTimeWithFields(this, rejectInvalidBag(t), n));
+    return Mi(plainTimeWithFields(this, rejectInvalidBag(t), n));
   },
-  add: (e, t) => bi(movePlainTime(0, e, toDurationSlots(t))),
-  subtract: (e, t) => bi(movePlainTime(1, e, toDurationSlots(t))),
-  until: (e, t, n) => _i(diffPlainTimes(0, e, toPlainTimeSlots(t), n)),
-  since: (e, t, n) => _i(diffPlainTimes(1, e, toPlainTimeSlots(t), n)),
-  round: (e, t) => bi(roundPlainTime(e, t)),
+  add: (e, t) => Mi(movePlainTime(0, e, toDurationSlots(t))),
+  subtract: (e, t) => Mi(movePlainTime(1, e, toDurationSlots(t))),
+  until: (e, t, n) => ls(diffPlainTimes(0, e, toPlainTimeSlots(t), n)),
+  since: (e, t, n) => ls(diffPlainTimes(1, e, toPlainTimeSlots(t), n)),
+  round: (e, t) => Mi(roundPlainTime(e, t)),
   equals: (e, t) => plainTimesEqual(e, toPlainTimeSlots(t)),
   toString: formatPlainTimeIso,
   toJSON: e => formatPlainTimeIso(e),
   toLocaleString(e, t, n) {
-    const [o, r] = Ra(t, n, e);
+    const [o, r] = ei(t, n, e);
     return o.format(r);
   },
-  toZonedDateTime: (e, t) => Ti(plainTimeToZonedDateTime(refineTimeZoneSlot, toPlainDateSlots, createTimeZoneOps, e, t)),
-  toPlainDateTime: (e, t) => Ii(plainTimeToPlainDateTime(e, toPlainDateSlots(t))),
-  getISOFields: ii,
+  toZonedDateTime: (e, t) => Ss(plainTimeToZonedDateTime(refineTimeZoneSlot, toPlainDateSlots, createTimeZoneOps, e, t)),
+  toPlainDateTime: (e, t) => Ai(plainTimeToPlainDateTime(e, toPlainDateSlots(t))),
+  getISOFields: pi,
   valueOf: neverValueOf
 }, {
-  from: (e, t) => bi(toPlainTimeSlots(e, t)),
+  from: (e, t) => Mi(toPlainTimeSlots(e, t)),
   compare: (e, t) => compareIsoTimeFields(toPlainTimeSlots(e), toPlainTimeSlots(t))
-}), [Fi, Ii] = createSlotClass(Tn, bindArgs(constructPlainDateTimeSlots, refineCalendarSlot), {
-  ...ti,
-  ...$a,
-  ...ri
+}), [yi, Ni, Bi] = createSlotClass(Tn, bindArgs(constructPlainYearMonthSlots, refineCalendarSlot), {
+  ...fi,
+  ...ui
 }, {
   with(e, t, n) {
-    return Ii(plainDateTimeWithFields(Ui, e, this, rejectInvalidBag(t), n));
+    return Ni(plainYearMonthWithFields(es, e, this, rejectInvalidBag(t), n));
+  },
+  add: (e, t, n) => Ni(movePlainYearMonth(as, 0, e, toDurationSlots(t), n)),
+  subtract: (e, t, n) => Ni(movePlainYearMonth(as, 1, e, toDurationSlots(t), n)),
+  until: (e, t, n) => ls(diffPlainYearMonth(is, 0, e, toPlainYearMonthSlots(t), n)),
+  since: (e, t, n) => ls(diffPlainYearMonth(is, 1, e, toPlainYearMonthSlots(t), n)),
+  equals: (e, t) => plainYearMonthsEqual(e, toPlainYearMonthSlots(t)),
+  toString: formatPlainYearMonthIso,
+  toJSON: e => formatPlainYearMonthIso(e),
+  toLocaleString(e, t, n) {
+    const [o, r] = Qa(t, n, e);
+    return o.format(r);
   },
-  withPlainTime: (e, t) => Ii(plainDateTimeWithPlainTime(e, optionalToPlainTimeFields(t))),
-  withPlainDate: (e, t) => Ii(plainDateTimeWithPlainDate(e, toPlainDateSlots(t))),
-  withCalendar: (e, t) => Ii(slotsWithCalendar(e, refineCalendarSlot(t))),
-  add: (e, t, n) => Ii(movePlainDateTime(Hi, 0, e, toDurationSlots(t), n)),
-  subtract: (e, t, n) => Ii(movePlainDateTime(Hi, 1, e, toDurationSlots(t), n)),
-  until: (e, t, n) => _i(diffPlainDateTimes(Ki, 0, e, toPlainDateTimeSlots(t), n)),
-  since: (e, t, n) => _i(diffPlainDateTimes(Ki, 1, e, toPlainDateTimeSlots(t), n)),
-  round: (e, t) => Ii(roundPlainDateTime(e, t)),
+  toPlainDate(e, t) {
+    return Vi(plainYearMonthToPlainDate(ts, e, this, t));
+  },
+  getISOFields: pi,
+  getCalendar: createCalendarFromSlots,
+  valueOf: neverValueOf
+}, {
+  from: (e, t) => Ni(toPlainYearMonthSlots(e, t)),
+  compare: (e, t) => compareIsoDateFields(toPlainYearMonthSlots(e), toPlainYearMonthSlots(t))
+}), [Yi, Ai] = createSlotClass(In, bindArgs(constructPlainDateTimeSlots, refineCalendarSlot), {
+  ...fi,
+  ...ci,
+  ...Oi
+}, {
+  with(e, t, n) {
+    return Ai(plainDateTimeWithFields(ts, e, this, rejectInvalidBag(t), n));
+  },
+  withPlainTime: (e, t) => Ai(plainDateTimeWithPlainTime(e, optionalToPlainTimeFields(t))),
+  withPlainDate: (e, t) => Ai(plainDateTimeWithPlainDate(e, toPlainDateSlots(t))),
+  withCalendar: (e, t) => Ai(slotsWithCalendar(e, refineCalendarSlot(t))),
+  add: (e, t, n) => Ai(movePlainDateTime(os, 0, e, toDurationSlots(t), n)),
+  subtract: (e, t, n) => Ai(movePlainDateTime(os, 1, e, toDurationSlots(t), n)),
+  until: (e, t, n) => ls(diffPlainDateTimes(rs, 0, e, toPlainDateTimeSlots(t), n)),
+  since: (e, t, n) => ls(diffPlainDateTimes(rs, 1, e, toPlainDateTimeSlots(t), n)),
+  round: (e, t) => Ai(roundPlainDateTime(e, t)),
   equals: (e, t) => plainDateTimesEqual(e, toPlainDateTimeSlots(t)),
   toString: (e, t) => formatPlainDateTimeIso(e, t),
   toJSON: e => formatPlainDateTimeIso(e),
   toLocaleString(e, t, n) {
-    const [o, r] = xa(t, n, e);
+    const [o, r] = _a(t, n, e);
     return o.format(r);
   },
-  toZonedDateTime: (e, t, n) => Ti(plainDateTimeToZonedDateTime(createTimeZoneOps, e, refineTimeZoneSlot(t), n)),
-  toPlainDate: e => wi(createPlainDateSlots(e)),
+  toZonedDateTime: (e, t, n) => Ss(plainDateTimeToZonedDateTime(createTimeZoneOps, e, refineTimeZoneSlot(t), n)),
+  toPlainDate: e => Vi(createPlainDateSlots(e)),
   toPlainYearMonth(e) {
-    return mi(plainDateTimeToPlainYearMonth(xi, e, this));
+    return Ni(plainDateTimeToPlainYearMonth(Xi, e, this));
   },
   toPlainMonthDay(e) {
-    return li(plainDateTimeToPlainMonthDay(Wi, e, this));
+    return Pi(plainDateTimeToPlainMonthDay(_i, e, this));
   },
-  toPlainTime: e => bi(createPlainTimeSlots(e)),
-  getISOFields: ii,
+  toPlainTime: e => Mi(createPlainTimeSlots(e)),
+  getISOFields: pi,
   getCalendar: createCalendarFromSlots,
   valueOf: neverValueOf
 }, {
-  from: (e, t) => Ii(toPlainDateTimeSlots(e, t)),
+  from: (e, t) => Ai(toPlainDateTimeSlots(e, t)),
   compare: (e, t) => compareIsoDateTimeFields(toPlainDateTimeSlots(e), toPlainDateTimeSlots(t))
-}), [vi, wi, ji] = createSlotClass(hn, bindArgs(constructPlainDateSlots, refineCalendarSlot), {
-  ...ti,
-  ...$a
+}), [Ei, Vi, Ji] = createSlotClass(Dn, bindArgs(constructPlainDateSlots, refineCalendarSlot), {
+  ...fi,
+  ...ci
 }, {
   with(e, t, n) {
-    return wi(plainDateWithFields(Ui, e, this, rejectInvalidBag(t), n));
+    return Vi(plainDateWithFields(ts, e, this, rejectInvalidBag(t), n));
   },
-  withCalendar: (e, t) => wi(slotsWithCalendar(e, refineCalendarSlot(t))),
-  add: (e, t, n) => wi(movePlainDate(Hi, 0, e, toDurationSlots(t), n)),
-  subtract: (e, t, n) => wi(movePlainDate(Hi, 1, e, toDurationSlots(t), n)),
-  until: (e, t, n) => _i(diffPlainDates(Ki, 0, e, toPlainDateSlots(t), n)),
-  since: (e, t, n) => _i(diffPlainDates(Ki, 1, e, toPlainDateSlots(t), n)),
+  withCalendar: (e, t) => Vi(slotsWithCalendar(e, refineCalendarSlot(t))),
+  add: (e, t, n) => Vi(movePlainDate(os, 0, e, toDurationSlots(t), n)),
+  subtract: (e, t, n) => Vi(movePlainDate(os, 1, e, toDurationSlots(t), n)),
+  until: (e, t, n) => ls(diffPlainDates(rs, 0, e, toPlainDateSlots(t), n)),
+  since: (e, t, n) => ls(diffPlainDates(rs, 1, e, toPlainDateSlots(t), n)),
   equals: (e, t) => plainDatesEqual(e, toPlainDateSlots(t)),
   toString: formatPlainDateIso,
   toJSON: e => formatPlainDateIso(e),
   toLocaleString(e, t, n) {
-    const [o, r] = qa(t, n, e);
+    const [o, r] = $a(t, n, e);
     return o.format(r);
   },
   toZonedDateTime(e, t) {
-    const n = !isObjectLike(t) || t instanceof Di ? {
+    const n = !isObjectLike(t) || t instanceof Ii ? {
       timeZone: t
     } : t;
-    return Ti(plainDateToZonedDateTime(refineTimeZoneSlot, toPlainTimeSlots, createTimeZoneOps, e, n));
+    return Ss(plainDateToZonedDateTime(refineTimeZoneSlot, toPlainTimeSlots, createTimeZoneOps, e, n));
   },
-  toPlainDateTime: (e, t) => Ii(plainDateToPlainDateTime(e, optionalToPlainTimeFields(t))),
+  toPlainDateTime: (e, t) => Ai(plainDateToPlainDateTime(e, optionalToPlainTimeFields(t))),
   toPlainYearMonth(e) {
-    return mi(plainDateToPlainYearMonth(xi, e, this));
+    return Ni(plainDateToPlainYearMonth(Xi, e, this));
   },
   toPlainMonthDay(e) {
-    return li(plainDateToPlainMonthDay(Wi, e, this));
+    return Pi(plainDateToPlainMonthDay(_i, e, this));
   },
-  getISOFields: ii,
+  getISOFields: pi,
   getCalendar: createCalendarFromSlots,
   valueOf: neverValueOf
 }, {
-  from: (e, t) => wi(toPlainDateSlots(e, t)),
+  from: (e, t) => Vi(toPlainDateSlots(e, t)),
   compare: (e, t) => compareIsoDateFields(toPlainDateSlots(e), toPlainDateSlots(t))
-}), Mi = {
+}), Li = {
   fields(e, t, n) {
     return [ ...t.call(e, n) ];
   }
-}, yi = /*@__PURE__*/ Object.assign({
+}, qi = /*@__PURE__*/ Object.assign({
   dateFromFields(e, t, n, o) {
-    return ji(t.call(e, Object.assign(Object.create(null), n), o));
+    return Ji(t.call(e, Object.assign(Object.create(null), n), o));
   }
-}, Mi), Ni = /*@__PURE__*/ Object.assign({
+}, Li), ki = /*@__PURE__*/ Object.assign({
   yearMonthFromFields(e, t, n, o) {
-    return Si(t.call(e, Object.assign(Object.create(null), n), o));
+    return Bi(t.call(e, Object.assign(Object.create(null), n), o));
   }
-}, Mi), Bi = /*@__PURE__*/ Object.assign({
+}, Li), xi = /*@__PURE__*/ Object.assign({
   monthDayFromFields(e, t, n, o) {
-    return ci(t.call(e, Object.assign(Object.create(null), n), o));
+    return Di(t.call(e, Object.assign(Object.create(null), n), o));
   }
-}, Mi), Yi = {
+}, Li), Ri = {
   mergeFields(e, t, n, o) {
     return requireObjectLike(t.call(e, Object.assign(Object.create(null), n), Object.assign(Object.create(null), o)));
   }
-}, Ai = /*@__PURE__*/ Object.assign({}, yi, Yi), Ei = /*@__PURE__*/ Object.assign({}, Ni, Yi), Vi = /*@__PURE__*/ Object.assign({}, Bi, Yi), Ji = {
+}, Wi = /*@__PURE__*/ Object.assign({}, qi, Ri), Gi = /*@__PURE__*/ Object.assign({}, ki, Ri), Ui = /*@__PURE__*/ Object.assign({}, xi, Ri), zi = {
   dateAdd(e, t, n, o, r) {
-    return ji(t.call(e, wi(createPlainDateSlots(n, e)), _i(createDurationSlots(o)), r));
+    return Ji(t.call(e, Vi(createPlainDateSlots(n, e)), ls(createDurationSlots(o)), r));
   }
-}, Li = /*@__PURE__*/ Object.assign({}, Ji, {
+}, Hi = /*@__PURE__*/ Object.assign({}, zi, {
   dateUntil(e, t, n, o, r, a) {
-    return es(t.call(e, wi(createPlainDateSlots(n, e)), wi(createPlainDateSlots(o, e)), Object.assign(Object.create(null), a, {
-      largestUnit: k[r]
+    return cs(t.call(e, Vi(createPlainDateSlots(n, e)), Vi(createPlainDateSlots(o, e)), Object.assign(Object.create(null), a, {
+      largestUnit: C[r]
     })));
   }
-}), ki = /*@__PURE__*/ Object.assign({}, Ji, {
+}), Ki = /*@__PURE__*/ Object.assign({}, zi, {
   day: dayAdapter
-}), qi = /*@__PURE__*/ Object.assign({}, Li, {
+}), Qi = /*@__PURE__*/ Object.assign({}, Hi, {
   day: dayAdapter
-}), xi = /*@__PURE__*/ createCompoundOpsCreator(Ni), Ri = /*@__PURE__*/ createCompoundOpsCreator(yi), Wi = /*@__PURE__*/ createCompoundOpsCreator(Bi), Gi = /*@__PURE__*/ createCompoundOpsCreator(Ei), Ui = /*@__PURE__*/ createCompoundOpsCreator(Ai), zi = /*@__PURE__*/ createCompoundOpsCreator(Vi), Hi = /*@__PURE__*/ createCompoundOpsCreator(Ji), Ki = /*@__PURE__*/ createCompoundOpsCreator(Li), Qi = /*@__PURE__*/ createCompoundOpsCreator(ki), Xi = /*@__PURE__*/ createCompoundOpsCreator(qi), [$i, _i, es] = createSlotClass(yn, constructDurationSlots, {
-  ...oi,
-  blank: e => queryDurationBlank(e),
-  sign: e => Sn(e)
+}), Xi = /*@__PURE__*/ createCompoundOpsCreator(ki), $i = /*@__PURE__*/ createCompoundOpsCreator(qi), _i = /*@__PURE__*/ createCompoundOpsCreator(xi), es = /*@__PURE__*/ createCompoundOpsCreator(Gi), ts = /*@__PURE__*/ createCompoundOpsCreator(Wi), ns = /*@__PURE__*/ createCompoundOpsCreator(Ui), os = /*@__PURE__*/ createCompoundOpsCreator(zi), rs = /*@__PURE__*/ createCompoundOpsCreator(Hi), as = /*@__PURE__*/ createCompoundOpsCreator(Ki), is = /*@__PURE__*/ createCompoundOpsCreator(Qi), [ss, ls, cs] = createSlotClass(vn, constructDurationSlots, {
+  ...Si,
+  blank: getDurationBlank
 }, {
-  with: (e, t) => _i(durationWithFields(e, t)),
-  add: (e, t, n) => _i(addDurations(refinePublicRelativeTo, Ki, createTimeZoneOps, 0, e, toDurationSlots(t), n)),
-  subtract: (e, t, n) => _i(addDurations(refinePublicRelativeTo, Ki, createTimeZoneOps, 1, e, toDurationSlots(t), n)),
-  negated: e => _i(negateDuration(e)),
-  abs: e => _i(absDuration(e)),
-  round: (e, t) => _i(roundDuration(refinePublicRelativeTo, Ki, createTimeZoneOps, e, t)),
-  total: (e, t) => totalDuration(refinePublicRelativeTo, Ki, createTimeZoneOps, e, t),
+  with: (e, t) => ls(durationWithFields(e, t)),
+  add: (e, t, n) => ls(addDurations(refinePublicRelativeTo, rs, createTimeZoneOps, 0, e, toDurationSlots(t), n)),
+  subtract: (e, t, n) => ls(addDurations(refinePublicRelativeTo, rs, createTimeZoneOps, 1, e, toDurationSlots(t), n)),
+  negated: e => ls(negateDuration(e)),
+  abs: e => ls(absDuration(e)),
+  round: (e, t) => ls(roundDuration(refinePublicRelativeTo, rs, createTimeZoneOps, e, t)),
+  total: (e, t) => totalDuration(refinePublicRelativeTo, rs, createTimeZoneOps, e, t),
   toString: formatDurationIso,
   toLocaleString(e, t, n) {
     return Intl.DurationFormat ? new Intl.DurationFormat(t, n).format(this) : formatDurationIso(e);
@@ -5948,21 +5934,21 @@ const Ya = /*@__PURE__*/ new WeakMap, Aa = /*@__PURE__*/ Ya.get.bind(Ya), Ea = /
   toJSON: e => formatDurationIso(e),
   valueOf: neverValueOf
 }, {
-  from: e => _i(toDurationSlots(e)),
-  compare: (e, t, n) => compareDurations(refinePublicRelativeTo, Ki, createTimeZoneOps, toDurationSlots(e), toDurationSlots(t), n)
-}), ts = {
+  from: e => ls(toDurationSlots(e)),
+  compare: (e, t, n) => compareDurations(refinePublicRelativeTo, os, createTimeZoneOps, toDurationSlots(e), toDurationSlots(t), n)
+}), us = {
   toString: e => e.id,
   toJSON: e => e.id,
-  ...Xa,
-  dateAdd: ({id: e, K: t}, n, o, r) => wi(createPlainDateSlots(t.dateAdd(toPlainDateSlots(n), toDurationSlots(o), r), e)),
-  dateUntil: ({K: e}, t, n, o) => _i(createDurationSlots(e.dateUntil(toPlainDateSlots(t), toPlainDateSlots(n), refineCalendarDiffOptions(o)))),
-  dateFromFields: ({id: e, K: t}, n, o) => wi(refinePlainDateBag(t, n, o, getRequiredDateFields(e))),
-  yearMonthFromFields: ({id: e, K: t}, n, o) => mi(refinePlainYearMonthBag(t, n, o, getRequiredYearMonthFields(e))),
-  monthDayFromFields: ({id: e, K: t}, n, o) => li(refinePlainMonthDayBag(t, 0, n, o, getRequiredMonthDayFields(e))),
+  ...li,
+  dateAdd: ({id: e, K: t}, n, o, r) => Vi(createPlainDateSlots(t.dateAdd(toPlainDateSlots(n), toDurationSlots(o), r), e)),
+  dateUntil: ({K: e}, t, n, o) => ls(createDurationSlots(e.dateUntil(toPlainDateSlots(t), toPlainDateSlots(n), refineCalendarDiffOptions(o)))),
+  dateFromFields: ({id: e, K: t}, n, o) => Vi(refinePlainDateBag(t, n, o, getRequiredDateFields(e))),
+  yearMonthFromFields: ({id: e, K: t}, n, o) => Ni(refinePlainYearMonthBag(t, n, o, getRequiredYearMonthFields(e))),
+  monthDayFromFields: ({id: e, K: t}, n, o) => Pi(refinePlainMonthDayBag(t, 0, n, o, getRequiredMonthDayFields(e))),
   fields({K: e}, t) {
-    const n = new Set(te), o = [];
+    const n = new Set(re), o = [];
     for (const e of t) {
-      if (Le(e), !n.has(e)) {
+      if (We(e), !n.has(e)) {
         throw new RangeError(forbiddenField(e));
       }
       n.delete(e), o.push(e);
@@ -5970,47 +5956,94 @@ const Ya = /*@__PURE__*/ new WeakMap, Aa = /*@__PURE__*/ Ya.get.bind(Ya), Ea = /
     return e.fields(o);
   },
   mergeFields: ({K: e}, t, n) => e.mergeFields(excludeUndefinedProps(requireNonNullish(t)), excludeUndefinedProps(requireNonNullish(n)))
-}, [ns] = createSlotClass("Calendar", (e => {
-  const t = resolveCalendarId(Le(e));
+}, [ds] = createSlotClass("Calendar", (e => {
+  const t = resolveCalendarId(We(e));
   return {
     branding: "Calendar",
     id: t,
-    K: nt(t)
+    K: st(t)
   };
 }), {
   id: e => e.id
-}, ts, {
+}, us, {
   from(e) {
     const t = refineCalendarSlot(e);
-    return "string" == typeof t ? new ns(t) : t;
+    return "string" == typeof t ? new ds(t) : t;
   }
-}), os = /*@__PURE__*/ createProtocolValidator(Object.keys(ts).slice(4)), rs = /*@__PURE__*/ Object.defineProperties({}, {
+}), fs = /*@__PURE__*/ createProtocolValidator(Object.keys(us).slice(4)), [ms, Ss] = createSlotClass(Nn, bindArgs(constructZonedDateTimeSlots, refineCalendarSlot, refineTimeZoneSlot), {
+  ...Ti,
+  ...fi,
+  ...adaptDateMethods(ci),
+  ...adaptDateMethods(Oi),
+  hoursInDay: e => computeHoursInDay(createTimeZoneOps, e),
+  offsetNanoseconds: e => slotsToIso(e).offsetNanoseconds,
+  offset: e => formatOffsetNano(slotsToIso(e).offsetNanoseconds),
+  timeZoneId: e => getId(e.timeZone)
+}, {
+  with(e, t, n) {
+    return Ss(zonedDateTimeWithFields(ts, createTimeZoneOps, e, this, rejectInvalidBag(t), n));
+  },
+  withPlainTime: (e, t) => Ss(zonedDateTimeWithPlainTime(createTimeZoneOps, e, optionalToPlainTimeFields(t))),
+  withPlainDate: (e, t) => Ss(zonedDateTimeWithPlainDate(createTimeZoneOps, e, toPlainDateSlots(t))),
+  withTimeZone: (e, t) => Ss(slotsWithTimeZone(e, refineTimeZoneSlot(t))),
+  withCalendar: (e, t) => Ss(slotsWithCalendar(e, refineCalendarSlot(t))),
+  add: (e, t, n) => Ss(moveZonedDateTime(os, createTimeZoneOps, 0, e, toDurationSlots(t), n)),
+  subtract: (e, t, n) => Ss(moveZonedDateTime(os, createTimeZoneOps, 1, e, toDurationSlots(t), n)),
+  until: (e, t, n) => ls(createDurationSlots(diffZonedDateTimes(rs, createTimeZoneOps, 0, e, toZonedDateTimeSlots(t), n))),
+  since: (e, t, n) => ls(createDurationSlots(diffZonedDateTimes(rs, createTimeZoneOps, 1, e, toZonedDateTimeSlots(t), n))),
+  round: (e, t) => Ss(roundZonedDateTime(createTimeZoneOps, e, t)),
+  startOfDay: e => Ss(computeStartOfDay(createTimeZoneOps, e)),
+  equals: (e, t) => zonedDateTimesEqual(e, toZonedDateTimeSlots(t)),
+  toString: (e, t) => formatZonedDateTimeIso(createTimeZoneOffsetOps, e, t),
+  toJSON: e => formatZonedDateTimeIso(createTimeZoneOffsetOps, e),
+  toLocaleString(e, t, n = {}) {
+    const [o, r] = ni(t, n, e);
+    return o.format(r);
+  },
+  toInstant: e => bi(zonedDateTimeToInstant(e)),
+  toPlainDate: e => Vi(zonedDateTimeToPlainDate(createTimeZoneOffsetOps, e)),
+  toPlainTime: e => Mi(zonedDateTimeToPlainTime(createTimeZoneOffsetOps, e)),
+  toPlainDateTime: e => Ai(zonedDateTimeToPlainDateTime(createTimeZoneOffsetOps, e)),
+  toPlainYearMonth(e) {
+    return Ni(zonedDateTimeToPlainYearMonth(Xi, e, this));
+  },
+  toPlainMonthDay(e) {
+    return Pi(zonedDateTimeToPlainMonthDay(_i, e, this));
+  },
+  getISOFields: e => buildZonedIsoFields(createTimeZoneOffsetOps, e),
+  getCalendar: createCalendarFromSlots,
+  getTimeZone: ({timeZone: e}) => "string" == typeof e ? new Ii(e) : e,
+  valueOf: neverValueOf
+}, {
+  from: (e, t) => Ss(toZonedDateTimeSlots(e, t)),
+  compare: (e, t) => compareZonedDateTimes(toZonedDateTimeSlots(e), toZonedDateTimeSlots(t))
+}), Os = /*@__PURE__*/ Object.defineProperties({}, {
   ...createStringTagDescriptors("Temporal.Now"),
   ...createPropDescriptors({
     timeZoneId: () => getCurrentTimeZoneId(),
-    instant: () => hi(createInstantSlots(getCurrentEpochNanoseconds())),
-    zonedDateTime: (e, t = getCurrentTimeZoneId()) => Ti(createZonedDateTimeSlots(getCurrentEpochNanoseconds(), refineTimeZoneSlot(t), refineCalendarSlot(e))),
-    zonedDateTimeISO: (e = getCurrentTimeZoneId()) => Ti(createZonedDateTimeSlots(getCurrentEpochNanoseconds(), refineTimeZoneSlot(e), ae)),
-    plainDateTime: (e, t = getCurrentTimeZoneId()) => Ii(createPlainDateTimeSlots(getCurrentIsoDateTime(createTimeZoneOffsetOps(refineTimeZoneSlot(t))), refineCalendarSlot(e))),
-    plainDateTimeISO: (e = getCurrentTimeZoneId()) => Ii(createPlainDateTimeSlots(getCurrentIsoDateTime(createTimeZoneOffsetOps(refineTimeZoneSlot(e))), ae)),
-    plainDate: (e, t = getCurrentTimeZoneId()) => wi(createPlainDateSlots(getCurrentIsoDateTime(createTimeZoneOffsetOps(refineTimeZoneSlot(t))), refineCalendarSlot(e))),
-    plainDateISO: (e = getCurrentTimeZoneId()) => wi(createPlainDateSlots(getCurrentIsoDateTime(createTimeZoneOffsetOps(refineTimeZoneSlot(e))), ae)),
-    plainTimeISO: (e = getCurrentTimeZoneId()) => bi(createPlainTimeSlots(getCurrentIsoDateTime(createTimeZoneOffsetOps(refineTimeZoneSlot(e)))))
+    instant: () => bi(createInstantSlots(getCurrentEpochNano())),
+    zonedDateTime: (e, t = getCurrentTimeZoneId()) => Ss(createZonedDateTimeSlots(getCurrentEpochNano(), refineTimeZoneSlot(t), refineCalendarSlot(e))),
+    zonedDateTimeISO: (e = getCurrentTimeZoneId()) => Ss(createZonedDateTimeSlots(getCurrentEpochNano(), refineTimeZoneSlot(e), ce)),
+    plainDateTime: (e, t = getCurrentTimeZoneId()) => Ai(createPlainDateTimeSlots(getCurrentIsoDateTime(createTimeZoneOffsetOps(refineTimeZoneSlot(t))), refineCalendarSlot(e))),
+    plainDateTimeISO: (e = getCurrentTimeZoneId()) => Ai(createPlainDateTimeSlots(getCurrentIsoDateTime(createTimeZoneOffsetOps(refineTimeZoneSlot(e))), ce)),
+    plainDate: (e, t = getCurrentTimeZoneId()) => Vi(createPlainDateSlots(getCurrentIsoDateTime(createTimeZoneOffsetOps(refineTimeZoneSlot(t))), refineCalendarSlot(e))),
+    plainDateISO: (e = getCurrentTimeZoneId()) => Vi(createPlainDateSlots(getCurrentIsoDateTime(createTimeZoneOffsetOps(refineTimeZoneSlot(e))), ce)),
+    plainTimeISO: (e = getCurrentTimeZoneId()) => Mi(createPlainTimeSlots(getCurrentIsoDateTime(createTimeZoneOffsetOps(refineTimeZoneSlot(e)))))
   })
 }), jt = /*@__PURE__*/ Object.defineProperties({}, {
   ...createStringTagDescriptors("Temporal"),
   ...createPropDescriptors({
-    PlainYearMonth: fi,
-    PlainMonthDay: si,
-    PlainDate: vi,
-    PlainTime: Zi,
-    PlainDateTime: Fi,
-    ZonedDateTime: Oi,
-    Instant: pi,
-    Calendar: ns,
-    TimeZone: Di,
-    Duration: $i,
-    Now: rs
+    PlainYearMonth: yi,
+    PlainMonthDay: hi,
+    PlainDate: Ei,
+    PlainTime: ji,
+    PlainDateTime: Yi,
+    ZonedDateTime: ms,
+    Instant: Zi,
+    Calendar: ds,
+    TimeZone: Ii,
+    Duration: ss,
+    Now: Os
   })
 });
 
@@ -7477,9 +7510,9 @@ function pad4(number) {
 Object.defineProperties(globalThis, createPropDescriptors({
   Temporal: jt
 })), Object.defineProperties(Intl, createPropDescriptors({
-  DateTimeFormat: kt
+  DateTimeFormat: qt
 })), Object.defineProperties(Date.prototype, createPropDescriptors({
-  toTemporalInstant: qt
+  toTemporalInstant: xt
 }));
 
 /**
@@ -9782,6 +9815,14 @@ const staticModernHolidays = [{
   mm: Cheshvan,
   dd: 7,
   desc: 'Yom HaAliyah School Observance'
+},
+// https://www.gov.il/he/departments/policies/2012_des5234
+{
+  firstYear: 5773,
+  mm: months.TEVET,
+  dd: 21,
+  desc: 'Hebrew Language Day',
+  friSatMovetoThu: true
 }];
 
 /*
@@ -10320,7 +10361,7 @@ class DailyLearning {
 }
 
 // DO NOT EDIT THIS AUTO-GENERATED FILE!
-const version = '5.2.2';
+const version = '5.3.0';
 
 const NONE$1 = 0;
 const HALF = 1;
@@ -10684,6 +10725,7 @@ var poHe = {
       "Jabotinsky Day": ["יוֹם ז׳בוטינסקי"],
       "Herzl Day": ["יוֹם הרצל"],
       "Ben-Gurion Day": ["יוֹם בן־גוריון"],
+      "Hebrew Language Day": ["יוֹם הַשָׂפָה הַעִברִית"],
       "Birkat Hachamah": ["בִרְכַּת הַחַמָּה"],
       "Shushan Purim Katan": ["שׁוּשָׁן פּוּרִים קָטָן"],
       "Purim Meshulash": ["פּוּרִים מְשׁוּלָּשׁ"],