@rikdotcodes/temporal-polyfill 0.3.1

package/global.js

@@ -0,0 +1,3422 @@
+!function() {
+  "use strict";
+  function clampProp(props, propName, min, max, overflow) {
+    return clampEntity(propName, ((props, propName) => {
+      const propVal = props[propName];
+      if (void 0 === propVal) {
+        throw new TypeError(missingField(propName));
+      }
+      return propVal;
+    })(props, propName), min, max, overflow);
+  }
+  function clampEntity(entityName, num, min, max, overflow, choices) {
+    const clamped = clampNumber(num, min, max);
+    if (overflow && num !== clamped) {
+      throw new RangeError(numberOutOfRange(entityName, num, min, max, choices));
+    }
+    return clamped;
+  }
+  function isObjectLike(arg) {
+    return null !== arg && /object|function/.test(typeof arg);
+  }
+  function memoize(generator, MapClass = Map) {
+    const map = new MapClass;
+    return (key, ...otherArgs) => {
+      if (map.has(key)) {
+        return map.get(key);
+      }
+      const val = generator(key, ...otherArgs);
+      return map.set(key, val), val;
+    };
+  }
+  function createNameDescriptors(name) {
+    return createPropDescriptors({
+      name: name
+    }, 1);
+  }
+  function createPropDescriptors(propVals, readonly) {
+    return mapProps((value => ({
+      value: value,
+      configurable: 1,
+      writable: !readonly
+    })), propVals);
+  }
+  function createGetterDescriptors(getters) {
+    return mapProps((getter => ({
+      get: getter,
+      configurable: 1
+    })), getters);
+  }
+  function createStringTagDescriptors(value) {
+    return {
+      [Symbol.toStringTag]: {
+        value: value,
+        configurable: 1
+      }
+    };
+  }
+  function zipProps(propNamesRev, args) {
+    const res = {};
+    let i = propNamesRev.length;
+    for (const arg of args) {
+      res[propNamesRev[--i]] = arg;
+    }
+    return res;
+  }
+  function mapProps(transformer, props, extraArg) {
+    const res = {};
+    for (const propName in props) {
+      res[propName] = transformer(props[propName], propName, extraArg);
+    }
+    return res;
+  }
+  function mapPropNames(generator, propNames, extraArg) {
+    const props = {};
+    for (let i = 0; i < propNames.length; i++) {
+      const propName = propNames[i];
+      props[propName] = generator(propName, i, extraArg);
+    }
+    return props;
+  }
+  function remapProps(oldNames, newNames, oldProps) {
+    const newProps = {};
+    for (let i = 0; i < oldNames.length; i++) {
+      newProps[newNames[i]] = oldProps[oldNames[i]];
+    }
+    return newProps;
+  }
+  function pluckProps(propNames, props) {
+    const res = Object.create(null);
+    for (const propName of propNames) {
+      res[propName] = props[propName];
+    }
+    return res;
+  }
+  function hasAnyPropsByName(props, names) {
+    for (const name of names) {
+      if (name in props) {
+        return 1;
+      }
+    }
+    return 0;
+  }
+  function allPropsEqual(propNames, props0, props1) {
+    for (const propName of propNames) {
+      if (props0[propName] !== props1[propName]) {
+        return 0;
+      }
+    }
+    return 1;
+  }
+  function zeroOutProps(propNames, clearUntilI, props) {
+    const copy = {
+      ...props
+    };
+    for (let i = 0; i < clearUntilI; i++) {
+      copy[propNames[i]] = 0;
+    }
+    return copy;
+  }
+  function bindArgs(f, ...boundArgs) {
+    return (...dynamicArgs) => f(...boundArgs, ...dynamicArgs);
+  }
+  function capitalize(s) {
+    return s[0].toUpperCase() + s.substring(1);
+  }
+  function sortStrings(strs) {
+    return strs.slice().sort();
+  }
+  function padNumber(digits, num) {
+    return String(num).padStart(digits, "0");
+  }
+  function compareNumbers(a, b) {
+    return Math.sign(a - b);
+  }
+  function clampNumber(num, min, max) {
+    return Math.min(Math.max(num, min), max);
+  }
+  function divModFloor(num, divisor) {
+    return [ Math.floor(num / divisor), modFloor(num, divisor) ];
+  }
+  function modFloor(num, divisor) {
+    return (num % divisor + divisor) % divisor;
+  }
+  function divModTrunc(num, divisor) {
+    return [ divTrunc(num, divisor), modTrunc(num, divisor) ];
+  }
+  function divTrunc(num, divisor) {
+    return Math.trunc(num / divisor) || 0;
+  }
+  function modTrunc(num, divisor) {
+    return num % divisor || 0;
+  }
+  function hasHalf(num) {
+    return .5 === Math.abs(num % 1);
+  }
+  function givenFieldsToBigNano(fields, largestUnit, fieldNames) {
+    let timeNano = 0, days = 0;
+    for (let unit = 0; unit <= largestUnit; unit++) {
+      const fieldVal = fields[fieldNames[unit]], unitNano = unitNanoMap[unit], unitInDay = nanoInUtcDay / unitNano, [unitDays, leftoverUnits] = divModTrunc(fieldVal, unitInDay);
+      timeNano += leftoverUnits * unitNano, days += unitDays;
+    }
+    const [timeDays, leftoverNano] = divModTrunc(timeNano, nanoInUtcDay);
+    return [ days + timeDays, leftoverNano ];
+  }
+  function nanoToGivenFields(nano, largestUnit, fieldNames) {
+    const fields = {};
+    for (let unit = largestUnit; unit >= 0; unit--) {
+      const divisor = unitNanoMap[unit];
+      fields[fieldNames[unit]] = divTrunc(nano, divisor), nano = modTrunc(nano, divisor);
+    }
+    return fields;
+  }
+  function createBigNano(days, timeNano) {
+    let [extraDays, newTimeNano] = divModTrunc(timeNano, nanoInUtcDay), newDays = days + extraDays;
+    const newDaysSign = Math.sign(newDays);
+    return newDaysSign && newDaysSign === -Math.sign(newTimeNano) && (newDays -= newDaysSign, 
+    newTimeNano += newDaysSign * nanoInUtcDay), [ newDays, newTimeNano ];
+  }
+  function addBigNanos(a, b, sign = 1) {
+    return createBigNano(a[0] + b[0] * sign, a[1] + b[1] * sign);
+  }
+  function moveBigNano(a, b) {
+    return createBigNano(a[0], a[1] + b);
+  }
+  function diffBigNanos(a, b) {
+    return addBigNanos(b, a, -1);
+  }
+  function compareBigNanos(a, b) {
+    return compareNumbers(a[0], b[0]) || compareNumbers(a[1], b[1]);
+  }
+  function bigNanoOutside(subject, rangeStart, rangeEndExcl) {
+    return -1 === compareBigNanos(subject, rangeStart) || 1 === compareBigNanos(subject, rangeEndExcl);
+  }
+  function bigIntToBigNano(num, multiplierNano = 1) {
+    const wholeInDay = BigInt(nanoInUtcDay / multiplierNano);
+    return [ Number(num / wholeInDay), Number(num % wholeInDay) * multiplierNano ];
+  }
+  function numberToBigNano(num, multiplierNano = 1) {
+    const wholeInDay = nanoInUtcDay / multiplierNano, [days, remainder] = divModTrunc(num, wholeInDay);
+    return [ days, remainder * multiplierNano ];
+  }
+  function bigNanoToNumber(bigNano, divisorNano = 1, exact) {
+    const [days, timeNano] = bigNano, [whole, remainderNano] = divModTrunc(timeNano, divisorNano);
+    return days * (nanoInUtcDay / divisorNano) + (whole + (exact ? remainderNano / divisorNano : 0));
+  }
+  function divModBigNano(bigNano, divisorNano, divModFunc = divModFloor) {
+    const [days, timeNano] = bigNano, [whole, remainderNano] = divModFunc(timeNano, divisorNano);
+    return [ days * (nanoInUtcDay / divisorNano) + whole, remainderNano ];
+  }
+  function requireIntegerOrUndefined(input) {
+    if (void 0 !== input) {
+      return requireInteger(input);
+    }
+  }
+  function requirePositiveInteger(arg) {
+    return requireNumberIsPositive(requireInteger(arg));
+  }
+  function requireInteger(arg) {
+    return requireNumberIsInteger(requireNumber(arg));
+  }
+  function requirePropDefined(optionName, optionVal) {
+    if (null == optionVal) {
+      throw new RangeError(missingField(optionName));
+    }
+    return optionVal;
+  }
+  function requireObjectLike(arg) {
+    if (!isObjectLike(arg)) {
+      throw new TypeError(invalidObject);
+    }
+    return arg;
+  }
+  function requireType(typeName, arg, entityName = typeName) {
+    if (typeof arg !== typeName) {
+      throw new TypeError(invalidEntity(entityName, arg));
+    }
+    return arg;
+  }
+  function requireNumberIsInteger(num, entityName = "number") {
+    if (!Number.isInteger(num)) {
+      throw new RangeError(expectedInteger(entityName, num));
+    }
+    return num || 0;
+  }
+  function requireNumberIsPositive(num, entityName = "number") {
+    if (num <= 0) {
+      throw new RangeError(expectedPositive(entityName, num));
+    }
+    return num;
+  }
+  function toString(arg) {
+    if ("symbol" == typeof arg) {
+      throw new TypeError(forbiddenSymbolToString);
+    }
+    return String(arg);
+  }
+  function toStringViaPrimitive(arg, entityName) {
+    return isObjectLike(arg) ? String(arg) : requireString(arg, entityName);
+  }
+  function toBigInt(bi) {
+    if ("string" == typeof bi) {
+      return BigInt(bi);
+    }
+    if ("bigint" != typeof bi) {
+      throw new TypeError(invalidBigInt(bi));
+    }
+    return bi;
+  }
+  function toNumber(arg, entityName = "number") {
+    if ("bigint" == typeof arg) {
+      throw new TypeError(forbiddenBigIntToNumber(entityName));
+    }
+    if (arg = Number(arg), !Number.isFinite(arg)) {
+      throw new RangeError(expectedFinite(entityName, arg));
+    }
+    return arg;
+  }
+  function toInteger(arg, entityName) {
+    return Math.trunc(toNumber(arg, entityName)) || 0;
+  }
+  function toStrictInteger(arg, entityName) {
+    return requireNumberIsInteger(toNumber(arg, entityName), entityName);
+  }
+  function toPositiveInteger(arg, entityName) {
+    return requireNumberIsPositive(toInteger(arg, entityName), entityName);
+  }
+  function checkIsoYearMonthInBounds(isoFields) {
+    return clampProp(isoFields, "isoYear", isoYearMin, isoYearMax, 1), isoFields.isoYear === isoYearMin ? clampProp(isoFields, "isoMonth", 4, 12, 1) : isoFields.isoYear === isoYearMax && clampProp(isoFields, "isoMonth", 1, 9, 1), 
+    isoFields;
+  }
+  function checkIsoDateInBounds(isoFields) {
+    return checkIsoDateTimeInBounds({
+      ...isoFields,
+      ...isoTimeFieldDefaults,
+      isoHour: 12
+    }), isoFields;
+  }
+  function checkIsoDateTimeInBounds(isoFields) {
+    const isoYear = clampProp(isoFields, "isoYear", isoYearMin, isoYearMax, 1), nudge = isoYear === isoYearMin ? 1 : isoYear === isoYearMax ? -1 : 0;
+    return nudge && checkEpochNanoInBounds(isoToEpochNano({
+      ...isoFields,
+      isoDay: isoFields.isoDay + nudge,
+      isoNanosecond: isoFields.isoNanosecond - nudge
+    })), isoFields;
+  }
+  function checkEpochNanoInBounds(epochNano) {
+    if (!epochNano || bigNanoOutside(epochNano, epochNanoMin, epochNanoMax)) {
+      throw new RangeError(outOfBoundsDate);
+    }
+    return epochNano;
+  }
+  function isoTimeFieldsToNano(isoTimeFields) {
+    return givenFieldsToBigNano(isoTimeFields, 5, isoTimeFieldNamesAsc)[1];
+  }
+  function nanoToIsoTimeAndDay(nano) {
+    const [dayDelta, timeNano] = divModFloor(nano, nanoInUtcDay);
+    return [ nanoToGivenFields(timeNano, 5, isoTimeFieldNamesAsc), dayDelta ];
+  }
+  function epochNanoToSecMod(epochNano) {
+    return divModBigNano(epochNano, nanoInSec);
+  }
+  function isoToEpochMilli(isoDateTimeFields) {
+    return isoArgsToEpochMilli(isoDateTimeFields.isoYear, isoDateTimeFields.isoMonth, isoDateTimeFields.isoDay, isoDateTimeFields.isoHour, isoDateTimeFields.isoMinute, isoDateTimeFields.isoSecond, isoDateTimeFields.isoMillisecond);
+  }
+  function isoToEpochNano(isoFields) {
+    const epochMilli = isoToEpochMilli(isoFields);
+    if (void 0 !== epochMilli) {
+      const [days, milliRemainder] = divModTrunc(epochMilli, milliInDay);
+      return [ days, milliRemainder * nanoInMilli + (isoFields.isoMicrosecond || 0) * nanoInMicro + (isoFields.isoNanosecond || 0) ];
+    }
+  }
+  function isoToEpochNanoWithOffset(isoFields, offsetNano) {
+    const [newIsoTimeFields, dayDelta] = nanoToIsoTimeAndDay(isoTimeFieldsToNano(isoFields) - offsetNano);
+    return checkEpochNanoInBounds(isoToEpochNano({
+      ...isoFields,
+      isoDay: isoFields.isoDay + dayDelta,
+      ...newIsoTimeFields
+    }));
+  }
+  function isoArgsToEpochSec(...args) {
+    return isoArgsToEpochMilli(...args) / milliInSec;
+  }
+  function isoArgsToEpochMilli(...args) {
+    const [legacyDate, daysNudged] = isoToLegacyDate(...args), epochMilli = legacyDate.valueOf();
+    if (!isNaN(epochMilli)) {
+      return epochMilli - daysNudged * milliInDay;
+    }
+  }
+  function isoToLegacyDate(isoYear, isoMonth = 1, isoDay = 1, isoHour = 0, isoMinute = 0, isoSec = 0, isoMilli = 0) {
+    const daysNudged = isoYear === isoYearMin ? 1 : isoYear === isoYearMax ? -1 : 0, legacyDate = new Date(0);
+    return legacyDate.setUTCHours(isoHour, isoMinute, isoSec, isoMilli), legacyDate.setUTCFullYear(isoYear, isoMonth - 1, isoDay + daysNudged), 
+    [ legacyDate, daysNudged ];
+  }
+  function epochNanoToIso(epochNano, offsetNano) {
+    let [days, timeNano] = moveBigNano(epochNano, offsetNano);
+    timeNano < 0 && (timeNano += nanoInUtcDay, days -= 1);
+    const [timeMilli, nanoRemainder] = divModFloor(timeNano, nanoInMilli), [isoMicrosecond, isoNanosecond] = divModFloor(nanoRemainder, nanoInMicro);
+    return epochMilliToIso(days * milliInDay + timeMilli, isoMicrosecond, isoNanosecond);
+  }
+  function epochMilliToIso(epochMilli, isoMicrosecond = 0, isoNanosecond = 0) {
+    const daysOver = Math.ceil(Math.max(0, Math.abs(epochMilli) - maxMilli) / milliInDay) * Math.sign(epochMilli), legacyDate = new Date(epochMilli - daysOver * milliInDay);
+    return zipProps(isoDateTimeFieldNamesAsc, [ legacyDate.getUTCFullYear(), legacyDate.getUTCMonth() + 1, legacyDate.getUTCDate() + daysOver, legacyDate.getUTCHours(), legacyDate.getUTCMinutes(), legacyDate.getUTCSeconds(), legacyDate.getUTCMilliseconds(), isoMicrosecond, isoNanosecond ]);
+  }
+  function hashIntlFormatParts(intlFormat, epochMilli) {
+    if (epochMilli < -maxMilli) {
+      throw new RangeError(outOfBoundsDate);
+    }
+    const parts = intlFormat.formatToParts(epochMilli), hash = {};
+    for (const part of parts) {
+      hash[part.type] = part.value;
+    }
+    return hash;
+  }
+  function computeIsoDateParts(isoFields) {
+    return [ isoFields.isoYear, isoFields.isoMonth, isoFields.isoDay ];
+  }
+  function computeIsoMonthCodeParts(_isoYear, isoMonth) {
+    return [ isoMonth, 0 ];
+  }
+  function computeIsoMonthsInYear() {
+    return isoMonthsInYear;
+  }
+  function computeIsoDaysInMonth(isoYear, isoMonth) {
+    switch (isoMonth) {
+     case 2:
+      return computeIsoInLeapYear(isoYear) ? 29 : 28;
+
+     case 4:
+     case 6:
+     case 9:
+     case 11:
+      return 30;
+    }
+    return 31;
+  }
+  function computeIsoDaysInYear(isoYear) {
+    return computeIsoInLeapYear(isoYear) ? 366 : 365;
+  }
+  function computeIsoInLeapYear(isoYear) {
+    return isoYear % 4 == 0 && (isoYear % 100 != 0 || isoYear % 400 == 0);
+  }
+  function computeIsoDayOfWeek(isoDateFields) {
+    const [legacyDate, daysNudged] = isoToLegacyDate(isoDateFields.isoYear, isoDateFields.isoMonth, isoDateFields.isoDay);
+    return modFloor(legacyDate.getUTCDay() - daysNudged, 7) || 7;
+  }
+  function computeIsoEraParts(isoFields) {
+    return this.id === gregoryCalendarId ? (({isoYear: isoYear}) => isoYear < 1 ? [ "gregory-inverse", 1 - isoYear ] : [ "gregory", isoYear ])(isoFields) : "japanese" === this.id ? queryJapaneseEraParts(isoFields) : [];
+  }
+  function checkIsoDateTimeFields(isoDateTimeFields) {
+    return checkIsoDateFields(isoDateTimeFields), constrainIsoTimeFields(isoDateTimeFields, 1), 
+    isoDateTimeFields;
+  }
+  function checkIsoDateFields(isoInternals) {
+    return constrainIsoDateFields(isoInternals, 1), isoInternals;
+  }
+  function isIsoDateFieldsValid(isoFields) {
+    return allPropsEqual(isoDateFieldNamesAsc, isoFields, constrainIsoDateFields(isoFields));
+  }
+  function constrainIsoDateFields(isoFields, overflow) {
+    const {isoYear: isoYear} = isoFields, isoMonth = clampProp(isoFields, "isoMonth", 1, computeIsoMonthsInYear(), overflow);
+    return {
+      isoYear: isoYear,
+      isoMonth: isoMonth,
+      isoDay: clampProp(isoFields, "isoDay", 1, computeIsoDaysInMonth(isoYear, isoMonth), overflow)
+    };
+  }
+  function constrainIsoTimeFields(isoTimeFields, overflow) {
+    return zipProps(isoTimeFieldNamesAsc, [ clampProp(isoTimeFields, "isoHour", 0, 23, overflow), clampProp(isoTimeFields, "isoMinute", 0, 59, overflow), clampProp(isoTimeFields, "isoSecond", 0, 59, overflow), clampProp(isoTimeFields, "isoMillisecond", 0, 999, overflow), clampProp(isoTimeFields, "isoMicrosecond", 0, 999, overflow), clampProp(isoTimeFields, "isoNanosecond", 0, 999, overflow) ]);
+  }
+  function createIntlFieldCache(epochMilliToIntlFields) {
+    return memoize((isoDateFields => {
+      const epochMilli = isoToEpochMilli(isoDateFields);
+      return epochMilliToIntlFields(epochMilli);
+    }), WeakMap);
+  }
+  function createIntlYearDataCache(epochMilliToIntlFields) {
+    const yearCorrection = epochMilliToIntlFields(0).year - isoEpochOriginYear;
+    return memoize((year => {
+      let intlFields, epochMilli = isoArgsToEpochMilli(year - yearCorrection), iterations = 0;
+      const millisReversed = [], monthStringsReversed = [];
+      do {
+        epochMilli += 400 * milliInDay;
+      } while ((intlFields = epochMilliToIntlFields(epochMilli)).year <= year);
+      do {
+        if (epochMilli += (1 - intlFields.day) * milliInDay, intlFields.year === year && (millisReversed.push(epochMilli), 
+        monthStringsReversed.push(intlFields.monthString)), epochMilli -= milliInDay, ++iterations > 100 || epochMilli < -maxMilli) {
+          throw new RangeError(invalidProtocolResults);
+        }
+      } while ((intlFields = epochMilliToIntlFields(epochMilli)).year >= year);
+      return {
+        monthEpochMillis: millisReversed.reverse(),
+        monthStringToIndex: mapPropNamesToIndex(monthStringsReversed.reverse())
+      };
+    }));
+  }
+  function parseIntlYear(intlParts, calendarIdBase) {
+    let era, eraYear, year = parseIntlPartsYear(intlParts);
+    if (intlParts.era) {
+      const eraOrigins = eraOriginsByCalendarId[calendarIdBase], eraRemaps = eraRemapsByCalendarId[calendarIdBase] || {};
+      void 0 !== eraOrigins && (era = "islamic" === calendarIdBase ? "ah" : intlParts.era.normalize("NFD").toLowerCase().replace(/[^a-z0-9]/g, ""), 
+      "bc" === era || "b" === era ? era = "bce" : "ad" === era || "a" === era ? era = "ce" : "beforeroc" === era && (era = "broc"), 
+      era = eraRemaps[era] || era, eraYear = year, year = eraYearToYear(eraYear, eraOrigins[era] || 0));
+    }
+    return {
+      era: era,
+      eraYear: eraYear,
+      year: year
+    };
+  }
+  function parseIntlPartsYear(intlParts) {
+    return parseInt(intlParts.relatedYear || intlParts.year);
+  }
+  function computeIntlDateParts(isoFields) {
+    const {year: year, monthString: monthString, day: day} = this.queryFields(isoFields), {monthStringToIndex: monthStringToIndex} = this.queryYearData(year);
+    return [ year, monthStringToIndex[monthString] + 1, day ];
+  }
+  function computeIntlEpochMilli(year, month = 1, day = 1) {
+    return this.queryYearData(year).monthEpochMillis[month - 1] + (day - 1) * milliInDay;
+  }
+  function computeIntlMonthCodeParts(year, month) {
+    const leapMonth = computeIntlLeapMonth.call(this, year);
+    return [ monthToMonthCodeNumber(month, leapMonth), leapMonth === month ];
+  }
+  function computeIntlLeapMonth(year) {
+    const currentMonthStrings = queryMonthStrings(this, year), prevMonthStrings = queryMonthStrings(this, year - 1), currentLength = currentMonthStrings.length;
+    if (currentLength > prevMonthStrings.length) {
+      const leapMonthMeta = getCalendarLeapMonthMeta(this);
+      if (leapMonthMeta < 0) {
+        return -leapMonthMeta;
+      }
+      for (let i = 0; i < currentLength; i++) {
+        if (currentMonthStrings[i] !== prevMonthStrings[i]) {
+          return i + 1;
+        }
+      }
+    }
+  }
+  function computeIntlDaysInYear(year) {
+    return diffEpochMilliByDay(computeIntlEpochMilli.call(this, year), computeIntlEpochMilli.call(this, year + 1));
+  }
+  function computeIntlDaysInMonth(year, month) {
+    const {monthEpochMillis: monthEpochMillis} = this.queryYearData(year);
+    let nextMonth = month + 1, nextMonthEpochMilli = monthEpochMillis;
+    return nextMonth > monthEpochMillis.length && (nextMonth = 1, nextMonthEpochMilli = this.queryYearData(year + 1).monthEpochMillis), 
+    diffEpochMilliByDay(monthEpochMillis[month - 1], nextMonthEpochMilli[nextMonth - 1]);
+  }
+  function computeIntlMonthsInYear(year) {
+    return this.queryYearData(year).monthEpochMillis.length;
+  }
+  function computeIntlEraParts(isoFields) {
+    const intlFields = this.queryFields(isoFields);
+    return [ intlFields.era, intlFields.eraYear ];
+  }
+  function queryMonthStrings(intlCalendar, year) {
+    return Object.keys(intlCalendar.queryYearData(year).monthStringToIndex);
+  }
+  function refineCalendarId(id) {
+    return resolveCalendarId(requireString(id));
+  }
+  function resolveCalendarId(id) {
+    if ((id = id.toLowerCase()) !== isoCalendarId && id !== gregoryCalendarId) {
+      const canonId = queryCalendarIntlFormat(id).resolvedOptions().calendar;
+      if (computeCalendarIdBase(id) !== computeCalendarIdBase(canonId)) {
+        throw new RangeError(invalidCalendar(id));
+      }
+      return canonId;
+    }
+    return id;
+  }
+  function computeCalendarIdBase(id) {
+    return "islamicc" === id && (id = "islamic"), id.split("-")[0];
+  }
+  function computeNativeWeekOfYear(isoFields) {
+    return this.weekParts(isoFields)[0];
+  }
+  function computeNativeYearOfWeek(isoFields) {
+    return this.weekParts(isoFields)[1];
+  }
+  function computeNativeDayOfYear(isoFields) {
+    const [year] = this.dateParts(isoFields);
+    return diffEpochMilliByDay(this.epochMilli(year), isoToEpochMilli(isoFields)) + 1;
+  }
+  function parseMonthCode(monthCode) {
+    const m = monthCodeRegExp.exec(monthCode);
+    if (!m) {
+      throw new RangeError(invalidMonthCode(monthCode));
+    }
+    return [ parseInt(m[1]), Boolean(m[2]) ];
+  }
+  function formatMonthCode(monthCodeNumber, isLeapMonth) {
+    return "M" + padNumber2(monthCodeNumber) + (isLeapMonth ? "L" : "");
+  }
+  function monthCodeNumberToMonth(monthCodeNumber, isLeapMonth, leapMonth) {
+    return monthCodeNumber + (isLeapMonth || leapMonth && monthCodeNumber >= leapMonth ? 1 : 0);
+  }
+  function monthToMonthCodeNumber(month, leapMonth) {
+    return month - (leapMonth && month >= leapMonth ? 1 : 0);
+  }
+  function eraYearToYear(eraYear, eraOrigin) {
+    return (eraOrigin + eraYear) * (Math.sign(eraOrigin) || 1) || 0;
+  }
+  function getCalendarEraOrigins(native) {
+    return eraOriginsByCalendarId[getCalendarIdBase(native)];
+  }
+  function getCalendarLeapMonthMeta(native) {
+    return leapMonthMetas[getCalendarIdBase(native)];
+  }
+  function getCalendarIdBase(native) {
+    return computeCalendarIdBase(native.id || isoCalendarId);
+  }
+  function refineOverflowOptions(options) {
+    return void 0 === options ? 0 : refineOverflow(requireObjectLike(options));
+  }
+  function refineZonedFieldOptions(options, defaultOffsetDisambig = 0) {
+    options = normalizeOptions(options);
+    const epochDisambig = refineEpochDisambig(options), offsetDisambig = refineOffsetDisambig(options, defaultOffsetDisambig);
+    return [ refineOverflow(options), offsetDisambig, epochDisambig ];
+  }
+  function refineDiffOptions(roundingModeInvert, options, defaultLargestUnit, maxUnit = 9, minUnit = 0, defaultRoundingMode = 4) {
+    options = normalizeOptions(options);
+    let largestUnit = refineLargestUnit(options, maxUnit, minUnit), roundingInc = parseRoundingIncInteger(options), roundingMode = refineRoundingMode(options, defaultRoundingMode);
+    const smallestUnit = refineSmallestUnit(options, maxUnit, minUnit, 1);
+    return null == largestUnit ? largestUnit = Math.max(defaultLargestUnit, smallestUnit) : checkLargestSmallestUnit(largestUnit, smallestUnit), 
+    roundingInc = refineRoundingInc(roundingInc, smallestUnit, 1), roundingModeInvert && (roundingMode = (roundingMode => roundingMode < 4 ? (roundingMode + 2) % 4 : roundingMode)(roundingMode)), 
+    [ largestUnit, smallestUnit, roundingInc, roundingMode ];
+  }
+  function refineRoundingOptions(options, maxUnit = 6, solarMode) {
+    let roundingInc = parseRoundingIncInteger(options = normalizeOptionsOrString(options, smallestUnitStr));
+    const roundingMode = refineRoundingMode(options, 7);
+    let smallestUnit = refineSmallestUnit(options, maxUnit);
+    return smallestUnit = requirePropDefined(smallestUnitStr, smallestUnit), roundingInc = refineRoundingInc(roundingInc, smallestUnit, void 0, solarMode), 
+    [ smallestUnit, roundingInc, roundingMode ];
+  }
+  function refineDateDisplayOptions(options) {
+    return refineCalendarDisplay(normalizeOptions(options));
+  }
+  function refineTimeDisplayOptions(options, maxSmallestUnit) {
+    return refineTimeDisplayTuple(normalizeOptions(options), maxSmallestUnit);
+  }
+  function refineTimeDisplayTuple(options, maxSmallestUnit = 4) {
+    const subsecDigits = refineSubsecDigits(options);
+    return [ refineRoundingMode(options, 4), ...refineSmallestUnitAndSubsecDigits(refineSmallestUnit(options, maxSmallestUnit), subsecDigits) ];
+  }
+  function refineSmallestUnitAndSubsecDigits(smallestUnit, subsecDigits) {
+    return null != smallestUnit ? [ unitNanoMap[smallestUnit], smallestUnit < 4 ? 9 - 3 * smallestUnit : -1 ] : [ void 0 === subsecDigits ? 1 : 10 ** (9 - subsecDigits), subsecDigits ];
+  }
+  function parseRoundingIncInteger(options) {
+    const roundingInc = options[roundingIncName];
+    return void 0 === roundingInc ? 1 : toInteger(roundingInc, roundingIncName);
+  }
+  function refineRoundingInc(roundingInc, smallestUnit, allowManyLargeUnits, solarMode) {
+    const upUnitNano = solarMode ? nanoInUtcDay : unitNanoMap[smallestUnit + 1];
+    if (upUnitNano) {
+      const unitNano = unitNanoMap[smallestUnit];
+      if (upUnitNano % ((roundingInc = clampEntity(roundingIncName, roundingInc, 1, upUnitNano / unitNano - (solarMode ? 0 : 1), 1)) * unitNano)) {
+        throw new RangeError(invalidEntity(roundingIncName, roundingInc));
+      }
+    } else {
+      roundingInc = clampEntity(roundingIncName, roundingInc, 1, allowManyLargeUnits ? 10 ** 9 : 1, 1);
+    }
+    return roundingInc;
+  }
+  function refineSubsecDigits(options) {
+    let subsecDigits = options[subsecDigitsName];
+    if (void 0 !== subsecDigits) {
+      if ("number" != typeof subsecDigits) {
+        if ("auto" === toString(subsecDigits)) {
+          return;
+        }
+        throw new RangeError(invalidEntity(subsecDigitsName, subsecDigits));
+      }
+      subsecDigits = clampEntity(subsecDigitsName, Math.floor(subsecDigits), 0, 9, 1);
+    }
+    return subsecDigits;
+  }
+  function normalizeOptions(options) {
+    return void 0 === options ? {} : requireObjectLike(options);
+  }
+  function normalizeOptionsOrString(options, optionName) {
+    return "string" == typeof options ? {
+      [optionName]: options
+    } : requireObjectLike(options);
+  }
+  function fabricateOverflowOptions(overflow) {
+    return {
+      overflow: overflowMapNames[overflow]
+    };
+  }
+  function refineUnitOption(optionName, options, maxUnit = 9, minUnit = 0, ensureDefined) {
+    let unitStr = options[optionName];
+    if (void 0 === unitStr) {
+      return ensureDefined ? minUnit : void 0;
+    }
+    if (unitStr = toString(unitStr), "auto" === unitStr) {
+      return ensureDefined ? minUnit : null;
+    }
+    let unit = unitNameMap[unitStr];
+    if (void 0 === unit && (unit = durationFieldIndexes[unitStr]), void 0 === unit) {
+      throw new RangeError(invalidChoice(optionName, unitStr, unitNameMap));
+    }
+    return clampEntity(optionName, unit, minUnit, maxUnit, 1, unitNamesAsc), unit;
+  }
+  function refineChoiceOption(optionName, enumNameMap, options, defaultChoice = 0) {
+    const enumArg = options[optionName];
+    if (void 0 === enumArg) {
+      return defaultChoice;
+    }
+    const enumStr = toString(enumArg), enumNum = enumNameMap[enumStr];
+    if (void 0 === enumNum) {
+      throw new RangeError(invalidChoice(optionName, enumStr, enumNameMap));
+    }
+    return enumNum;
+  }
+  function checkLargestSmallestUnit(largestUnit, smallestUnit) {
+    if (smallestUnit > largestUnit) {
+      throw new RangeError(flippedSmallestLargestUnit);
+    }
+  }
+  function createInstantSlots(epochNano) {
+    return {
+      branding: InstantBranding,
+      epochNanoseconds: epochNano
+    };
+  }
+  function createZonedDateTimeSlots(epochNano, timeZoneId, calendarId) {
+    return {
+      branding: ZonedDateTimeBranding,
+      calendar: calendarId,
+      timeZone: timeZoneId,
+      epochNanoseconds: epochNano
+    };
+  }
+  function createPlainDateTimeSlots(isoFields, calendar = isoFields.calendar) {
+    return {
+      branding: PlainDateTimeBranding,
+      calendar: calendar,
+      ...pluckProps(isoDateTimeFieldNamesAlpha, isoFields)
+    };
+  }
+  function createPlainDateSlots(isoFields, calendar = isoFields.calendar) {
+    return {
+      branding: PlainDateBranding,
+      calendar: calendar,
+      ...pluckProps(isoDateFieldNamesAlpha, isoFields)
+    };
+  }
+  function createPlainYearMonthSlots(isoFields, calendar = isoFields.calendar) {
+    return {
+      branding: PlainYearMonthBranding,
+      calendar: calendar,
+      ...pluckProps(isoDateFieldNamesAlpha, isoFields)
+    };
+  }
+  function createPlainMonthDaySlots(isoFields, calendar = isoFields.calendar) {
+    return {
+      branding: PlainMonthDayBranding,
+      calendar: calendar,
+      ...pluckProps(isoDateFieldNamesAlpha, isoFields)
+    };
+  }
+  function createPlainTimeSlots(isoFields) {
+    return {
+      branding: PlainTimeBranding,
+      ...pluckProps(isoTimeFieldNamesAlpha, isoFields)
+    };
+  }
+  function createDurationSlots(durationFields) {
+    return {
+      branding: DurationBranding,
+      sign: computeDurationSign(durationFields),
+      ...pluckProps(durationFieldNamesAlpha, durationFields)
+    };
+  }
+  function getEpochMilli(slots) {
+    return divModBigNano(slots.epochNanoseconds, nanoInMilli)[0];
+  }
+  function extractEpochNano(slots) {
+    return slots.epochNanoseconds;
+  }
+  function totalDayTimeDuration(durationFields, totalUnit) {
+    return bigNanoToNumber(durationFieldsToBigNano(durationFields), unitNanoMap[totalUnit], 1);
+  }
+  function clampRelativeDuration(calendarOps, durationFields, clampUnit, clampDistance, marker, markerToEpochNano, moveMarker) {
+    const unitName = durationFieldNamesAsc[clampUnit], durationPlusDistance = {
+      ...durationFields,
+      [unitName]: durationFields[unitName] + clampDistance
+    }, marker0 = moveMarker(calendarOps, marker, durationFields), marker1 = moveMarker(calendarOps, marker, durationPlusDistance);
+    return [ markerToEpochNano(marker0), markerToEpochNano(marker1) ];
+  }
+  function computeEpochNanoFrac(epochNanoProgress, epochNano0, epochNano1) {
+    const denom = bigNanoToNumber(diffBigNanos(epochNano0, epochNano1));
+    if (!denom) {
+      throw new RangeError(invalidProtocolResults);
+    }
+    return bigNanoToNumber(diffBigNanos(epochNano0, epochNanoProgress)) / denom;
+  }
+  function roundDateTime(isoFields, smallestUnit, roundingInc, roundingMode) {
+    return roundDateTimeToNano(isoFields, computeNanoInc(smallestUnit, roundingInc), roundingMode);
+  }
+  function roundDateTimeToNano(isoFields, nanoInc, roundingMode) {
+    const [roundedIsoFields, dayDelta] = roundTimeToNano(isoFields, nanoInc, roundingMode);
+    return checkIsoDateTimeInBounds({
+      ...moveByDays(isoFields, dayDelta),
+      ...roundedIsoFields
+    });
+  }
+  function roundTimeToNano(isoFields, nanoInc, roundingMode) {
+    return nanoToIsoTimeAndDay(roundByInc(isoTimeFieldsToNano(isoFields), nanoInc, roundingMode));
+  }
+  function roundToMinute(offsetNano) {
+    return roundByInc(offsetNano, nanoInMinute, 7);
+  }
+  function computeNanoInc(smallestUnit, roundingInc) {
+    return unitNanoMap[smallestUnit] * roundingInc;
+  }
+  function computeDayInterval(isoFields) {
+    const isoFields0 = computeDayFloor(isoFields);
+    return [ isoFields0, moveByDays(isoFields0, 1) ];
+  }
+  function computeDayFloor(isoFields) {
+    return clearIsoFields(6, isoFields);
+  }
+  function roundDayTimeDurationByInc(durationFields, nanoInc, roundingMode) {
+    const maxUnit = Math.min(getMaxDurationUnit(durationFields), 6);
+    return nanoToDurationDayTimeFields(roundBigNanoByInc(durationFieldsToBigNano(durationFields, maxUnit), nanoInc, roundingMode), maxUnit);
+  }
+  function roundRelativeDuration(durationFields, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode, calendarOps, marker, markerToEpochNano, moveMarker) {
+    if (0 === smallestUnit && 1 === roundingInc) {
+      return durationFields;
+    }
+    const nudgeFunc = isUniformUnit(smallestUnit, marker) ? isZonedEpochSlots(marker) && smallestUnit < 6 && largestUnit >= 6 ? nudgeZonedTimeDuration : nudgeDayTimeDuration : nudgeRelativeDuration;
+    let [roundedDurationFields, roundedEpochNano, grewBigUnit] = nudgeFunc(durationFields, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode, calendarOps, marker, markerToEpochNano, moveMarker);
+    return grewBigUnit && 7 !== smallestUnit && (roundedDurationFields = ((durationFields, endEpochNano, largestUnit, smallestUnit, calendarOps, marker, markerToEpochNano, moveMarker) => {
+      const sign = computeDurationSign(durationFields);
+      for (let currentUnit = smallestUnit + 1; currentUnit <= largestUnit; currentUnit++) {
+        if (7 === currentUnit && 7 !== largestUnit) {
+          continue;
+        }
+        const baseDurationFields = clearDurationFields(currentUnit, durationFields);
+        baseDurationFields[durationFieldNamesAsc[currentUnit]] += sign;
+        const beyondThresholdNano = bigNanoToNumber(diffBigNanos(markerToEpochNano(moveMarker(calendarOps, marker, baseDurationFields)), endEpochNano));
+        if (beyondThresholdNano && Math.sign(beyondThresholdNano) !== sign) {
+          break;
+        }
+        durationFields = baseDurationFields;
+      }
+      return durationFields;
+    })(roundedDurationFields, roundedEpochNano, largestUnit, Math.max(6, smallestUnit), calendarOps, marker, markerToEpochNano, moveMarker)), 
+    roundedDurationFields;
+  }
+  function roundBigNano(bigNano, smallestUnit, roundingInc, roundingMode, useDayOrigin) {
+    if (6 === smallestUnit) {
+      const daysExact = (bigNano => bigNano[0] + bigNano[1] / nanoInUtcDay)(bigNano);
+      return [ roundByInc(daysExact, roundingInc, roundingMode), 0 ];
+    }
+    return roundBigNanoByInc(bigNano, computeNanoInc(smallestUnit, roundingInc), roundingMode, useDayOrigin);
+  }
+  function roundBigNanoByInc(bigNano, nanoInc, roundingMode, useDayOrigin) {
+    let [days, timeNano] = bigNano;
+    useDayOrigin && timeNano < 0 && (timeNano += nanoInUtcDay, days -= 1);
+    const [dayDelta, roundedTimeNano] = divModFloor(roundByInc(timeNano, nanoInc, roundingMode), nanoInUtcDay);
+    return createBigNano(days + dayDelta, roundedTimeNano);
+  }
+  function roundByInc(num, inc, roundingMode) {
+    return roundWithMode(num / inc, roundingMode) * inc;
+  }
+  function roundWithMode(num, roundingMode) {
+    return roundingModeFuncs[roundingMode](num);
+  }
+  function nudgeDayTimeDuration(durationFields, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode) {
+    const sign = computeDurationSign(durationFields), bigNano = durationFieldsToBigNano(durationFields), roundedBigNano = roundBigNano(bigNano, smallestUnit, roundingInc, roundingMode), nanoDiff = diffBigNanos(bigNano, roundedBigNano), expandedBigUnit = Math.sign(roundedBigNano[0] - bigNano[0]) === sign, roundedDayTimeFields = nanoToDurationDayTimeFields(roundedBigNano, Math.min(largestUnit, 6));
+    return [ {
+      ...durationFields,
+      ...roundedDayTimeFields
+    }, addBigNanos(endEpochNano, nanoDiff), expandedBigUnit ];
+  }
+  function nudgeZonedTimeDuration(durationFields, endEpochNano, _largestUnit, smallestUnit, roundingInc, roundingMode, calendarOps, marker, markerToEpochNano, moveMarker) {
+    const sign = computeDurationSign(durationFields) || 1, timeNano = bigNanoToNumber(durationFieldsToBigNano(durationFields, 5)), nanoInc = computeNanoInc(smallestUnit, roundingInc);
+    let roundedTimeNano = roundByInc(timeNano, nanoInc, roundingMode);
+    const [dayEpochNano0, dayEpochNano1] = clampRelativeDuration(calendarOps, {
+      ...durationFields,
+      ...durationTimeFieldDefaults
+    }, 6, sign, marker, markerToEpochNano, moveMarker), beyondDayNano = roundedTimeNano - bigNanoToNumber(diffBigNanos(dayEpochNano0, dayEpochNano1));
+    let dayDelta = 0;
+    beyondDayNano && Math.sign(beyondDayNano) !== sign ? endEpochNano = moveBigNano(dayEpochNano0, roundedTimeNano) : (dayDelta += sign, 
+    roundedTimeNano = roundByInc(beyondDayNano, nanoInc, roundingMode), endEpochNano = moveBigNano(dayEpochNano1, roundedTimeNano));
+    const durationTimeFields = nanoToDurationTimeFields(roundedTimeNano);
+    return [ {
+      ...durationFields,
+      ...durationTimeFields,
+      days: durationFields.days + dayDelta
+    }, endEpochNano, Boolean(dayDelta) ];
+  }
+  function nudgeRelativeDuration(durationFields, endEpochNano, _largestUnit, smallestUnit, roundingInc, roundingMode, calendarOps, marker, markerToEpochNano, moveMarker) {
+    const sign = computeDurationSign(durationFields), smallestUnitFieldName = durationFieldNamesAsc[smallestUnit], baseDurationFields = clearDurationFields(smallestUnit, durationFields);
+    7 === smallestUnit && (durationFields = {
+      ...durationFields,
+      weeks: durationFields.weeks + Math.trunc(durationFields.days / 7)
+    });
+    const truncedVal = divTrunc(durationFields[smallestUnitFieldName], roundingInc) * roundingInc;
+    baseDurationFields[smallestUnitFieldName] = truncedVal;
+    const [epochNano0, epochNano1] = clampRelativeDuration(calendarOps, baseDurationFields, smallestUnit, roundingInc * sign, marker, markerToEpochNano, moveMarker), exactVal = truncedVal + computeEpochNanoFrac(endEpochNano, epochNano0, epochNano1) * sign * roundingInc, roundedVal = roundByInc(exactVal, roundingInc, roundingMode), expanded = Math.sign(roundedVal - exactVal) === sign;
+    return baseDurationFields[smallestUnitFieldName] = roundedVal, [ baseDurationFields, expanded ? epochNano1 : epochNano0, expanded ];
+  }
+  function formatInstantIso(refineTimeZoneString, getTimeZoneOps, instantSlots, options) {
+    const [timeZoneArg, roundingMode, nanoInc, subsecDigits] = (options => {
+      const timeDisplayTuple = refineTimeDisplayTuple(options = normalizeOptions(options));
+      return [ options.timeZone, ...timeDisplayTuple ];
+    })(options), providedTimeZone = void 0 !== timeZoneArg;
+    return ((providedTimeZone, timeZoneOps, epochNano, roundingMode, nanoInc, subsecDigits) => {
+      epochNano = roundBigNanoByInc(epochNano, nanoInc, roundingMode, 1);
+      const offsetNano = timeZoneOps.getOffsetNanosecondsFor(epochNano);
+      return formatIsoDateTimeFields(epochNanoToIso(epochNano, offsetNano), subsecDigits) + (providedTimeZone ? formatOffsetNano(roundToMinute(offsetNano)) : "Z");
+    })(providedTimeZone, getTimeZoneOps(providedTimeZone ? refineTimeZoneString(timeZoneArg) : utcTimeZoneId), instantSlots.epochNanoseconds, roundingMode, nanoInc, subsecDigits);
+  }
+  function formatZonedDateTimeIso(getTimeZoneOps, zonedDateTimeSlots0, options) {
+    const [a, b, c, d, e, f] = (options => {
+      options = normalizeOptions(options);
+      const calendarDisplay = refineCalendarDisplay(options), subsecDigits = refineSubsecDigits(options), offsetDisplay = refineOffsetDisplay(options), roundingMode = refineRoundingMode(options, 4), smallestUnit = refineSmallestUnit(options, 4);
+      return [ calendarDisplay, refineTimeZoneDisplay(options), offsetDisplay, roundingMode, ...refineSmallestUnitAndSubsecDigits(smallestUnit, subsecDigits) ];
+    })(options);
+    return ((getTimeZoneOps, calendarId, timeZoneId, epochNano, calendarDisplay, timeZoneDisplay, offsetDisplay, roundingMode, nanoInc, subsecDigits) => {
+      epochNano = roundBigNanoByInc(epochNano, nanoInc, roundingMode, 1);
+      const offsetNano = getTimeZoneOps(timeZoneId).getOffsetNanosecondsFor(epochNano);
+      return formatIsoDateTimeFields(epochNanoToIso(epochNano, offsetNano), subsecDigits) + formatOffsetNano(roundToMinute(offsetNano), offsetDisplay) + ((timeZoneId, timeZoneDisplay) => 1 !== timeZoneDisplay ? "[" + (2 === timeZoneDisplay ? "!" : "") + timeZoneId + "]" : "")(timeZoneId, timeZoneDisplay) + formatCalendar(calendarId, calendarDisplay);
+    })(getTimeZoneOps, zonedDateTimeSlots0.calendar, zonedDateTimeSlots0.timeZone, zonedDateTimeSlots0.epochNanoseconds, a, b, c, d, e, f);
+  }
+  function formatPlainDateTimeIso(plainDateTimeSlots0, options) {
+    const [a, b, c, d] = (options => (options = normalizeOptions(options), [ refineCalendarDisplay(options), ...refineTimeDisplayTuple(options) ]))(options);
+    return calendarId = plainDateTimeSlots0.calendar, calendarDisplay = a, subsecDigits = d, 
+    formatIsoDateTimeFields(roundDateTimeToNano(plainDateTimeSlots0, c, b), subsecDigits) + formatCalendar(calendarId, calendarDisplay);
+    var calendarId, calendarDisplay, subsecDigits;
+  }
+  function formatPlainDateIso(plainDateSlots, options) {
+    return calendarId = plainDateSlots.calendar, isoFields = plainDateSlots, calendarDisplay = refineDateDisplayOptions(options), 
+    formatIsoDateFields(isoFields) + formatCalendar(calendarId, calendarDisplay);
+    var calendarId, isoFields, calendarDisplay;
+  }
+  function formatPlainYearMonthIso(plainYearMonthSlots, options) {
+    return formatDateLikeIso(plainYearMonthSlots.calendar, formatIsoYearMonthFields, plainYearMonthSlots, refineDateDisplayOptions(options));
+  }
+  function formatPlainMonthDayIso(plainMonthDaySlots, options) {
+    return formatDateLikeIso(plainMonthDaySlots.calendar, formatIsoMonthDayFields, plainMonthDaySlots, refineDateDisplayOptions(options));
+  }
+  function formatPlainTimeIso(slots, options) {
+    const [a, b, c] = refineTimeDisplayOptions(options);
+    return subsecDigits = c, formatIsoTimeFields(roundTimeToNano(slots, b, a)[0], subsecDigits);
+    var subsecDigits;
+  }
+  function formatDurationIso(slots, options) {
+    const [roundingMode, nanoInc, subsecDigits] = refineTimeDisplayOptions(options, 3);
+    return nanoInc > 1 && checkDurationUnits(slots = {
+      ...slots,
+      ...roundDayTimeDurationByInc(slots, nanoInc, roundingMode)
+    }), ((durationSlots, subsecDigits) => {
+      const {sign: sign} = durationSlots, abs = -1 === sign ? negateDurationFields(durationSlots) : durationSlots, {hours: hours, minutes: minutes} = abs, [wholeSec, subsecNano] = divModBigNano(durationFieldsToBigNano(abs, 3), nanoInSec, divModTrunc);
+      checkDurationTimeUnit(wholeSec);
+      const subsecNanoString = formatSubsecNano(subsecNano, subsecDigits), forceSec = subsecDigits >= 0 || !sign || subsecNanoString;
+      return (sign < 0 ? "-" : "") + "P" + formatDurationFragments({
+        Y: formatDurationNumber(abs.years),
+        M: formatDurationNumber(abs.months),
+        W: formatDurationNumber(abs.weeks),
+        D: formatDurationNumber(abs.days)
+      }) + (hours || minutes || wholeSec || forceSec ? "T" + formatDurationFragments({
+        H: formatDurationNumber(hours),
+        M: formatDurationNumber(minutes),
+        S: formatDurationNumber(wholeSec, forceSec) + subsecNanoString
+      }) : "");
+    })(slots, subsecDigits);
+  }
+  function formatDateLikeIso(calendarId, formatSimple, isoFields, calendarDisplay) {
+    const showCalendar = calendarDisplay > 1 || 0 === calendarDisplay && calendarId !== isoCalendarId;
+    return 1 === calendarDisplay ? calendarId === isoCalendarId ? formatSimple(isoFields) : formatIsoDateFields(isoFields) : showCalendar ? formatIsoDateFields(isoFields) + formatCalendarId(calendarId, 2 === calendarDisplay) : formatSimple(isoFields);
+  }
+  function formatDurationFragments(fragObj) {
+    const parts = [];
+    for (const fragName in fragObj) {
+      const fragVal = fragObj[fragName];
+      fragVal && parts.push(fragVal, fragName);
+    }
+    return parts.join("");
+  }
+  function formatIsoDateTimeFields(isoDateTimeFields, subsecDigits) {
+    return formatIsoDateFields(isoDateTimeFields) + "T" + formatIsoTimeFields(isoDateTimeFields, subsecDigits);
+  }
+  function formatIsoDateFields(isoDateFields) {
+    return formatIsoYearMonthFields(isoDateFields) + "-" + padNumber2(isoDateFields.isoDay);
+  }
+  function formatIsoYearMonthFields(isoDateFields) {
+    const {isoYear: isoYear} = isoDateFields;
+    return (isoYear < 0 || isoYear > 9999 ? getSignStr(isoYear) + padNumber(6, Math.abs(isoYear)) : padNumber(4, isoYear)) + "-" + padNumber2(isoDateFields.isoMonth);
+  }
+  function formatIsoMonthDayFields(isoDateFields) {
+    return padNumber2(isoDateFields.isoMonth) + "-" + padNumber2(isoDateFields.isoDay);
+  }
+  function formatIsoTimeFields(isoTimeFields, subsecDigits) {
+    const parts = [ padNumber2(isoTimeFields.isoHour), padNumber2(isoTimeFields.isoMinute) ];
+    return -1 !== subsecDigits && parts.push(padNumber2(isoTimeFields.isoSecond) + ((isoMillisecond, isoMicrosecond, isoNanosecond, subsecDigits) => formatSubsecNano(isoMillisecond * nanoInMilli + isoMicrosecond * nanoInMicro + isoNanosecond, subsecDigits))(isoTimeFields.isoMillisecond, isoTimeFields.isoMicrosecond, isoTimeFields.isoNanosecond, subsecDigits)), 
+    parts.join(":");
+  }
+  function formatOffsetNano(offsetNano, offsetDisplay = 0) {
+    if (1 === offsetDisplay) {
+      return "";
+    }
+    const [hour, nanoRemainder0] = divModFloor(Math.abs(offsetNano), nanoInHour), [minute, nanoRemainder1] = divModFloor(nanoRemainder0, nanoInMinute), [second, nanoRemainder2] = divModFloor(nanoRemainder1, nanoInSec);
+    return getSignStr(offsetNano) + padNumber2(hour) + ":" + padNumber2(minute) + (second || nanoRemainder2 ? ":" + padNumber2(second) + formatSubsecNano(nanoRemainder2) : "");
+  }
+  function formatCalendar(calendarId, calendarDisplay) {
+    return 1 !== calendarDisplay && (calendarDisplay > 1 || 0 === calendarDisplay && calendarId !== isoCalendarId) ? formatCalendarId(calendarId, 2 === calendarDisplay) : "";
+  }
+  function formatCalendarId(calendarId, isCritical) {
+    return "[" + (isCritical ? "!" : "") + "u-ca=" + calendarId + "]";
+  }
+  function formatSubsecNano(totalNano, subsecDigits) {
+    let s = padNumber(9, totalNano);
+    return s = void 0 === subsecDigits ? s.replace(trailingZerosRE, "") : s.slice(0, subsecDigits), 
+    s ? "." + s : "";
+  }
+  function getSignStr(num) {
+    return num < 0 ? "-" : "+";
+  }
+  function formatDurationNumber(n, force) {
+    return n || force ? n.toLocaleString("fullwide", {
+      useGrouping: 0
+    }) : "";
+  }
+  function getMatchingInstantFor(timeZoneOps, isoFields, offsetNano, offsetDisambig = 0, epochDisambig = 0, epochFuzzy, hasZ) {
+    if (void 0 !== offsetNano && 1 === offsetDisambig && (1 === offsetDisambig || hasZ)) {
+      return isoToEpochNanoWithOffset(isoFields, offsetNano);
+    }
+    const possibleEpochNanos = timeZoneOps.getPossibleInstantsFor(isoFields);
+    if (void 0 !== offsetNano && 3 !== offsetDisambig) {
+      const matchingEpochNano = ((possibleEpochNanos, isoDateTimeFields, offsetNano, fuzzy) => {
+        const zonedEpochNano = isoToEpochNano(isoDateTimeFields);
+        fuzzy && (offsetNano = roundToMinute(offsetNano));
+        for (const possibleEpochNano of possibleEpochNanos) {
+          let possibleOffsetNano = bigNanoToNumber(diffBigNanos(possibleEpochNano, zonedEpochNano));
+          if (fuzzy && (possibleOffsetNano = roundToMinute(possibleOffsetNano)), possibleOffsetNano === offsetNano) {
+            return possibleEpochNano;
+          }
+        }
+      })(possibleEpochNanos, isoFields, offsetNano, epochFuzzy);
+      if (void 0 !== matchingEpochNano) {
+        return matchingEpochNano;
+      }
+      if (0 === offsetDisambig) {
+        throw new RangeError(invalidOffsetForTimeZone);
+      }
+    }
+    return hasZ ? isoToEpochNano(isoFields) : getSingleInstantFor(timeZoneOps, isoFields, epochDisambig, possibleEpochNanos);
+  }
+  function getSingleInstantFor(timeZoneOps, isoFields, disambig = 0, possibleEpochNanos = timeZoneOps.getPossibleInstantsFor(isoFields)) {
+    if (1 === possibleEpochNanos.length) {
+      return possibleEpochNanos[0];
+    }
+    if (1 === disambig) {
+      throw new RangeError(ambigOffset);
+    }
+    if (possibleEpochNanos.length) {
+      return possibleEpochNanos[3 === disambig ? 1 : 0];
+    }
+    const zonedEpochNano = isoToEpochNano(isoFields), gapNano = ((timeZoneOps, zonedEpochNano) => {
+      const startOffsetNano = timeZoneOps.getOffsetNanosecondsFor(moveBigNano(zonedEpochNano, -nanoInUtcDay));
+      return (gapNano => {
+        if (gapNano > nanoInUtcDay) {
+          throw new RangeError(outOfBoundsDstGap);
+        }
+        return gapNano;
+      })(timeZoneOps.getOffsetNanosecondsFor(moveBigNano(zonedEpochNano, nanoInUtcDay)) - startOffsetNano);
+    })(timeZoneOps, zonedEpochNano), shiftNano = gapNano * (2 === disambig ? -1 : 1);
+    return (possibleEpochNanos = timeZoneOps.getPossibleInstantsFor(epochNanoToIso(zonedEpochNano, shiftNano)))[2 === disambig ? 0 : possibleEpochNanos.length - 1];
+  }
+  function getStartOfDayInstantFor(timeZoneOps, isoFields) {
+    const possibleEpochNanos = timeZoneOps.getPossibleInstantsFor(isoFields);
+    if (possibleEpochNanos.length) {
+      return possibleEpochNanos[0];
+    }
+    const zonedEpochNanoDayBefore = moveBigNano(isoToEpochNano(isoFields), -nanoInUtcDay);
+    return timeZoneOps.getTransition(zonedEpochNanoDayBefore, 1);
+  }
+  function moveInstant(doSubtract, instantSlots, durationSlots) {
+    return createInstantSlots(checkEpochNanoInBounds(addBigNanos(instantSlots.epochNanoseconds, (fields => {
+      if (durationHasDateParts(fields)) {
+        throw new RangeError(invalidLargeUnits);
+      }
+      return durationFieldsToBigNano(fields, 5);
+    })(doSubtract ? negateDurationFields(durationSlots) : durationSlots))));
+  }
+  function moveZonedDateTime(getCalendarOps, getTimeZoneOps, doSubtract, zonedDateTimeSlots, durationSlots, options = Object.create(null)) {
+    const timeZoneOps = getTimeZoneOps(zonedDateTimeSlots.timeZone), calendarOps = getCalendarOps(zonedDateTimeSlots.calendar);
+    return {
+      ...zonedDateTimeSlots,
+      ...moveZonedEpochs(timeZoneOps, calendarOps, zonedDateTimeSlots, doSubtract ? negateDurationFields(durationSlots) : durationSlots, options)
+    };
+  }
+  function movePlainDateTime(getCalendarOps, doSubtract, plainDateTimeSlots, durationSlots, options = Object.create(null)) {
+    const {calendar: calendar} = plainDateTimeSlots;
+    return createPlainDateTimeSlots(moveDateTime(getCalendarOps(calendar), plainDateTimeSlots, doSubtract ? negateDurationFields(durationSlots) : durationSlots, options), calendar);
+  }
+  function movePlainDate(getCalendarOps, doSubtract, plainDateSlots, durationSlots, options) {
+    const {calendar: calendar} = plainDateSlots;
+    return createPlainDateSlots(moveDate(getCalendarOps(calendar), plainDateSlots, doSubtract ? negateDurationFields(durationSlots) : durationSlots, options), calendar);
+  }
+  function movePlainYearMonth(getCalendarOps, doSubtract, plainYearMonthSlots, durationSlots, options) {
+    const calendarId = plainYearMonthSlots.calendar, calendarOps = getCalendarOps(calendarId);
+    let isoDateFields = checkIsoDateInBounds(moveToDayOfMonthUnsafe(calendarOps, plainYearMonthSlots));
+    doSubtract && (durationSlots = negateDuration(durationSlots)), durationSlots.sign < 0 && (isoDateFields = calendarOps.dateAdd(isoDateFields, {
+      ...durationFieldDefaults,
+      months: 1
+    }), isoDateFields = moveByDays(isoDateFields, -1));
+    const movedIsoDateFields = calendarOps.dateAdd(isoDateFields, durationSlots, options);
+    return createPlainYearMonthSlots(moveToDayOfMonthUnsafe(calendarOps, movedIsoDateFields), calendarId);
+  }
+  function movePlainTime(doSubtract, slots, durationSlots) {
+    return createPlainTimeSlots(moveTime(slots, doSubtract ? negateDurationFields(durationSlots) : durationSlots)[0]);
+  }
+  function moveZonedEpochs(timeZoneOps, calendarOps, slots, durationFields, options) {
+    const timeOnlyNano = durationFieldsToBigNano(durationFields, 5);
+    let epochNano = slots.epochNanoseconds;
+    if (durationHasDateParts(durationFields)) {
+      const isoDateTimeFields = zonedEpochSlotsToIso(slots, timeZoneOps);
+      epochNano = addBigNanos(getSingleInstantFor(timeZoneOps, {
+        ...moveDate(calendarOps, isoDateTimeFields, {
+          ...durationFields,
+          ...durationTimeFieldDefaults
+        }, options),
+        ...pluckProps(isoTimeFieldNamesAsc, isoDateTimeFields)
+      }), timeOnlyNano);
+    } else {
+      epochNano = addBigNanos(epochNano, timeOnlyNano), refineOverflowOptions(options);
+    }
+    return {
+      epochNanoseconds: checkEpochNanoInBounds(epochNano)
+    };
+  }
+  function moveDateTime(calendarOps, isoDateTimeFields, durationFields, options) {
+    const [movedIsoTimeFields, dayDelta] = moveTime(isoDateTimeFields, durationFields);
+    return checkIsoDateTimeInBounds({
+      ...moveDate(calendarOps, isoDateTimeFields, {
+        ...durationFields,
+        ...durationTimeFieldDefaults,
+        days: durationFields.days + dayDelta
+      }, options),
+      ...movedIsoTimeFields
+    });
+  }
+  function moveDate(calendarOps, isoDateFields, durationFields, options) {
+    if (durationFields.years || durationFields.months || durationFields.weeks) {
+      return calendarOps.dateAdd(isoDateFields, durationFields, options);
+    }
+    refineOverflowOptions(options);
+    const days = durationFields.days + durationFieldsToBigNano(durationFields, 5)[0];
+    return days ? checkIsoDateInBounds(moveByDays(isoDateFields, days)) : isoDateFields;
+  }
+  function moveToDayOfMonthUnsafe(calendarOps, isoFields, dayOfMonth = 1) {
+    return moveByDays(isoFields, dayOfMonth - calendarOps.day(isoFields));
+  }
+  function moveTime(isoFields, durationFields) {
+    const [durDays, durTimeNano] = durationFieldsToBigNano(durationFields, 5), [newIsoFields, overflowDays] = nanoToIsoTimeAndDay(isoTimeFieldsToNano(isoFields) + durTimeNano);
+    return [ newIsoFields, durDays + overflowDays ];
+  }
+  function moveByDays(isoFields, days) {
+    return days ? {
+      ...isoFields,
+      ...epochMilliToIso(isoToEpochMilli(isoFields) + days * milliInDay)
+    } : isoFields;
+  }
+  function diffInstants(invert, instantSlots0, instantSlots1, options) {
+    const optionsTuple = refineDiffOptions(invert, options, 3, 5), durationFields = diffEpochNanos(instantSlots0.epochNanoseconds, instantSlots1.epochNanoseconds, ...optionsTuple);
+    return createDurationSlots(invert ? negateDurationFields(durationFields) : durationFields);
+  }
+  function diffZonedDateTimes(getCalendarOps, getTimeZoneOps, invert, slots0, slots1, options) {
+    const calendarId = getCommonCalendarId(slots0.calendar, slots1.calendar), [largestUnit, smallestUnit, roundingInc, roundingMode] = refineDiffOptions(invert, options, 5), epochNano0 = slots0.epochNanoseconds, epochNano1 = slots1.epochNanoseconds, sign = compareBigNanos(epochNano1, epochNano0);
+    let durationFields;
+    if (sign) {
+      if (largestUnit < 6) {
+        durationFields = diffEpochNanos(epochNano0, epochNano1, largestUnit, smallestUnit, roundingInc, roundingMode);
+      } else {
+        const timeZoneOps = getTimeZoneOps(((a, b) => {
+          if (!isTimeZoneIdsEqual(a, b)) {
+            throw new RangeError(mismatchingTimeZones);
+          }
+          return a;
+        })(slots0.timeZone, slots1.timeZone)), calendarOps = getCalendarOps(calendarId);
+        durationFields = diffZonedEpochsBig(calendarOps, timeZoneOps, slots0, slots1, sign, largestUnit, options), 
+        durationFields = roundRelativeDuration(durationFields, epochNano1, largestUnit, smallestUnit, roundingInc, roundingMode, calendarOps, slots0, extractEpochNano, bindArgs(moveZonedEpochs, timeZoneOps));
+      }
+    } else {
+      durationFields = durationFieldDefaults;
+    }
+    return createDurationSlots(invert ? negateDurationFields(durationFields) : durationFields);
+  }
+  function diffPlainDateTimes(getCalendarOps, invert, plainDateTimeSlots0, plainDateTimeSlots1, options) {
+    const calendarId = getCommonCalendarId(plainDateTimeSlots0.calendar, plainDateTimeSlots1.calendar), [largestUnit, smallestUnit, roundingInc, roundingMode] = refineDiffOptions(invert, options, 6), startEpochNano = isoToEpochNano(plainDateTimeSlots0), endEpochNano = isoToEpochNano(plainDateTimeSlots1), sign = compareBigNanos(endEpochNano, startEpochNano);
+    let durationFields;
+    if (sign) {
+      if (largestUnit <= 6) {
+        durationFields = diffEpochNanos(startEpochNano, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode);
+      } else {
+        const calendarOps = getCalendarOps(calendarId);
+        durationFields = diffDateTimesBig(calendarOps, plainDateTimeSlots0, plainDateTimeSlots1, sign, largestUnit, options), 
+        durationFields = roundRelativeDuration(durationFields, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode, calendarOps, plainDateTimeSlots0, isoToEpochNano, moveDateTime);
+      }
+    } else {
+      durationFields = durationFieldDefaults;
+    }
+    return createDurationSlots(invert ? negateDurationFields(durationFields) : durationFields);
+  }
+  function diffPlainDates(getCalendarOps, invert, plainDateSlots0, plainDateSlots1, options) {
+    const calendarId = getCommonCalendarId(plainDateSlots0.calendar, plainDateSlots1.calendar);
+    return diffDateLike(invert, (() => getCalendarOps(calendarId)), plainDateSlots0, plainDateSlots1, ...refineDiffOptions(invert, options, 6, 9, 6));
+  }
+  function diffPlainYearMonth(getCalendarOps, invert, plainYearMonthSlots0, plainYearMonthSlots1, options) {
+    const calendarId = getCommonCalendarId(plainYearMonthSlots0.calendar, plainYearMonthSlots1.calendar), optionsTuple = refineDiffOptions(invert, options, 9, 9, 8), calendarOps = getCalendarOps(calendarId), firstOfMonth0 = moveToDayOfMonthUnsafe(calendarOps, plainYearMonthSlots0), firstOfMonth1 = moveToDayOfMonthUnsafe(calendarOps, plainYearMonthSlots1);
+    return firstOfMonth0.isoYear === firstOfMonth1.isoYear && firstOfMonth0.isoMonth === firstOfMonth1.isoMonth && firstOfMonth0.isoDay === firstOfMonth1.isoDay ? createDurationSlots(durationFieldDefaults) : diffDateLike(invert, (() => calendarOps), checkIsoDateInBounds(firstOfMonth0), checkIsoDateInBounds(firstOfMonth1), ...optionsTuple, 8);
+  }
+  function diffDateLike(invert, getCalendarOps, startIsoFields, endIsoFields, largestUnit, smallestUnit, roundingInc, roundingMode, smallestPrecision = 6) {
+    const startEpochNano = isoToEpochNano(startIsoFields), endEpochNano = isoToEpochNano(endIsoFields);
+    if (void 0 === startEpochNano || void 0 === endEpochNano) {
+      throw new RangeError(outOfBoundsDate);
+    }
+    let durationFields;
+    if (compareBigNanos(endEpochNano, startEpochNano)) {
+      if (6 === largestUnit) {
+        durationFields = diffEpochNanos(startEpochNano, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode);
+      } else {
+        const calendarOps = getCalendarOps();
+        durationFields = calendarOps.dateUntil(startIsoFields, endIsoFields, largestUnit), 
+        smallestUnit === smallestPrecision && 1 === roundingInc || (durationFields = roundRelativeDuration(durationFields, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode, calendarOps, startIsoFields, isoToEpochNano, moveDate));
+      }
+    } else {
+      durationFields = durationFieldDefaults;
+    }
+    return createDurationSlots(invert ? negateDurationFields(durationFields) : durationFields);
+  }
+  function diffPlainTimes(invert, plainTimeSlots0, plainTimeSlots1, options) {
+    const [largestUnit, smallestUnit, roundingInc, roundingMode] = refineDiffOptions(invert, options, 5, 5), timeDiffNano = roundByInc(diffTimes(plainTimeSlots0, plainTimeSlots1), computeNanoInc(smallestUnit, roundingInc), roundingMode), durationFields = {
+      ...durationFieldDefaults,
+      ...nanoToDurationTimeFields(timeDiffNano, largestUnit)
+    };
+    return createDurationSlots(invert ? negateDurationFields(durationFields) : durationFields);
+  }
+  function diffZonedEpochsExact(timeZoneOps, calendarOps, slots0, slots1, largestUnit, origOptions) {
+    const sign = compareBigNanos(slots1.epochNanoseconds, slots0.epochNanoseconds);
+    return sign ? largestUnit < 6 ? diffEpochNanosExact(slots0.epochNanoseconds, slots1.epochNanoseconds, largestUnit) : diffZonedEpochsBig(calendarOps, timeZoneOps, slots0, slots1, sign, largestUnit, origOptions) : durationFieldDefaults;
+  }
+  function diffDateTimesExact(calendarOps, startIsoFields, endIsoFields, largestUnit, origOptions) {
+    const startEpochNano = isoToEpochNano(startIsoFields), endEpochNano = isoToEpochNano(endIsoFields), sign = compareBigNanos(endEpochNano, startEpochNano);
+    return sign ? largestUnit <= 6 ? diffEpochNanosExact(startEpochNano, endEpochNano, largestUnit) : diffDateTimesBig(calendarOps, startIsoFields, endIsoFields, sign, largestUnit, origOptions) : durationFieldDefaults;
+  }
+  function diffZonedEpochsBig(calendarOps, timeZoneOps, slots0, slots1, sign, largestUnit, origOptions) {
+    const [isoFields0, isoFields1, remainderNano] = ((timeZoneOps, slots0, slots1, sign) => {
+      function updateMid() {
+        return midIsoFields = {
+          ...moveByDays(endIsoFields, dayCorrection++ * -sign),
+          ...startIsoTimeFields
+        }, midEpochNano = getSingleInstantFor(timeZoneOps, midIsoFields), compareBigNanos(endEpochNano, midEpochNano) === -sign;
+      }
+      const startIsoFields = zonedEpochSlotsToIso(slots0, timeZoneOps), startIsoTimeFields = pluckProps(isoTimeFieldNamesAsc, startIsoFields), endIsoFields = zonedEpochSlotsToIso(slots1, timeZoneOps), endEpochNano = slots1.epochNanoseconds;
+      let dayCorrection = 0;
+      const timeDiffNano = diffTimes(startIsoFields, endIsoFields);
+      let midIsoFields, midEpochNano;
+      if (Math.sign(timeDiffNano) === -sign && dayCorrection++, updateMid() && (-1 === sign || updateMid())) {
+        throw new RangeError(invalidProtocolResults);
+      }
+      const remainderNano = bigNanoToNumber(diffBigNanos(midEpochNano, endEpochNano));
+      return [ startIsoFields, midIsoFields, remainderNano ];
+    })(timeZoneOps, slots0, slots1, sign);
+    var startIsoFields, endIsoFields;
+    return {
+      ...6 === largestUnit ? (startIsoFields = isoFields0, endIsoFields = isoFields1, 
+      {
+        ...durationFieldDefaults,
+        days: diffDays(startIsoFields, endIsoFields)
+      }) : calendarOps.dateUntil(isoFields0, isoFields1, largestUnit, origOptions),
+      ...nanoToDurationTimeFields(remainderNano)
+    };
+  }
+  function diffDateTimesBig(calendarOps, startIsoFields, endIsoFields, sign, largestUnit, origOptions) {
+    const [startIsoDate, endIsoDate, timeNano] = ((startIsoDateTime, endIsoDateTime, sign) => {
+      let endIsoDate = endIsoDateTime, timeDiffNano = diffTimes(startIsoDateTime, endIsoDateTime);
+      return Math.sign(timeDiffNano) === -sign && (endIsoDate = moveByDays(endIsoDateTime, -sign), 
+      timeDiffNano += nanoInUtcDay * sign), [ startIsoDateTime, endIsoDate, timeDiffNano ];
+    })(startIsoFields, endIsoFields, sign);
+    return {
+      ...calendarOps.dateUntil(startIsoDate, endIsoDate, largestUnit, origOptions),
+      ...nanoToDurationTimeFields(timeNano)
+    };
+  }
+  function diffEpochNanos(startEpochNano, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode) {
+    return {
+      ...durationFieldDefaults,
+      ...nanoToDurationDayTimeFields(roundBigNano(diffBigNanos(startEpochNano, endEpochNano), smallestUnit, roundingInc, roundingMode), largestUnit)
+    };
+  }
+  function diffEpochNanosExact(startEpochNano, endEpochNano, largestUnit) {
+    return {
+      ...durationFieldDefaults,
+      ...nanoToDurationDayTimeFields(diffBigNanos(startEpochNano, endEpochNano), largestUnit)
+    };
+  }
+  function diffDays(startIsoFields, endIsoFields) {
+    return diffEpochMilliByDay(isoToEpochMilli(startIsoFields), isoToEpochMilli(endIsoFields));
+  }
+  function diffEpochMilliByDay(epochMilli0, epochMilli1) {
+    return Math.trunc((epochMilli1 - epochMilli0) / milliInDay);
+  }
+  function diffTimes(isoTime0, isoTime1) {
+    return isoTimeFieldsToNano(isoTime1) - isoTimeFieldsToNano(isoTime0);
+  }
+  function getCommonCalendarId(a, b) {
+    if (a !== b) {
+      throw new RangeError(mismatchingCalendars);
+    }
+    return a;
+  }
+  function createMarkerSystem(getCalendarOps, getTimeZoneOps, relativeToSlots) {
+    const calendarOps = getCalendarOps(relativeToSlots.calendar);
+    return isZonedEpochSlots(relativeToSlots) ? [ relativeToSlots, calendarOps, getTimeZoneOps(relativeToSlots.timeZone) ] : [ {
+      ...relativeToSlots,
+      ...isoTimeFieldDefaults
+    }, calendarOps ];
+  }
+  function createMarkerToEpochNano(timeZoneOps) {
+    return timeZoneOps ? extractEpochNano : isoToEpochNano;
+  }
+  function createMoveMarker(timeZoneOps) {
+    return timeZoneOps ? bindArgs(moveZonedEpochs, timeZoneOps) : moveDateTime;
+  }
+  function createDiffMarkers(timeZoneOps) {
+    return timeZoneOps ? bindArgs(diffZonedEpochsExact, timeZoneOps) : diffDateTimesExact;
+  }
+  function isZonedEpochSlots(marker) {
+    return marker && marker.epochNanoseconds;
+  }
+  function isUniformUnit(unit, marker) {
+    return unit <= 6 - (isZonedEpochSlots(marker) ? 1 : 0);
+  }
+  function addDurations(refineRelativeTo, getCalendarOps, getTimeZoneOps, doSubtract, slots, otherSlots, options) {
+    const relativeToSlots = refineRelativeTo(normalizeOptions(options).relativeTo), maxUnit = Math.max(getMaxDurationUnit(slots), getMaxDurationUnit(otherSlots));
+    if (isUniformUnit(maxUnit, relativeToSlots)) {
+      return createDurationSlots(checkDurationUnits(((a, b, largestUnit, doSubtract) => {
+        const combined = addBigNanos(durationFieldsToBigNano(a), durationFieldsToBigNano(b), doSubtract ? -1 : 1);
+        if (!Number.isFinite(combined[0])) {
+          throw new RangeError(outOfBoundsDate);
+        }
+        return {
+          ...durationFieldDefaults,
+          ...nanoToDurationDayTimeFields(combined, largestUnit)
+        };
+      })(slots, otherSlots, maxUnit, doSubtract)));
+    }
+    if (!relativeToSlots) {
+      throw new RangeError("Missing relativeTo");
+    }
+    doSubtract && (otherSlots = negateDurationFields(otherSlots));
+    const [marker, calendarOps, timeZoneOps] = createMarkerSystem(getCalendarOps, getTimeZoneOps, relativeToSlots), moveMarker = createMoveMarker(timeZoneOps), diffMarkers = createDiffMarkers(timeZoneOps), midMarker = moveMarker(calendarOps, marker, slots);
+    return createDurationSlots(diffMarkers(calendarOps, marker, moveMarker(calendarOps, midMarker, otherSlots), maxUnit));
+  }
+  function negateDuration(slots) {
+    return createDurationSlots(negateDurationFields(slots));
+  }
+  function negateDurationFields(fields) {
+    const res = {};
+    for (const fieldName of durationFieldNamesAsc) {
+      res[fieldName] = -1 * fields[fieldName] || 0;
+    }
+    return res;
+  }
+  function computeDurationSign(fields, fieldNames = durationFieldNamesAsc) {
+    let sign = 0;
+    for (const fieldName of fieldNames) {
+      const fieldSign = Math.sign(fields[fieldName]);
+      if (fieldSign) {
+        if (sign && sign !== fieldSign) {
+          throw new RangeError(forbiddenDurationSigns);
+        }
+        sign = fieldSign;
+      }
+    }
+    return sign;
+  }
+  function checkDurationUnits(fields) {
+    for (const calendarUnit of durationCalendarFieldNamesAsc) {
+      clampEntity(calendarUnit, fields[calendarUnit], -maxCalendarUnit, maxCalendarUnit, 1);
+    }
+    return checkDurationTimeUnit(bigNanoToNumber(durationFieldsToBigNano(fields), nanoInSec)), 
+    fields;
+  }
+  function checkDurationTimeUnit(n) {
+    if (!Number.isSafeInteger(n)) {
+      throw new RangeError(outOfBoundsDuration);
+    }
+  }
+  function durationFieldsToBigNano(fields, largestUnit = 6) {
+    return givenFieldsToBigNano(fields, largestUnit, durationFieldNamesAsc);
+  }
+  function nanoToDurationDayTimeFields(bigNano, largestUnit = 6) {
+    const [days, timeNano] = bigNano, dayTimeFields = nanoToGivenFields(timeNano, largestUnit, durationFieldNamesAsc);
+    if (dayTimeFields[durationFieldNamesAsc[largestUnit]] += days * (nanoInUtcDay / unitNanoMap[largestUnit]), 
+    !Number.isFinite(dayTimeFields[durationFieldNamesAsc[largestUnit]])) {
+      throw new RangeError(outOfBoundsDate);
+    }
+    return dayTimeFields;
+  }
+  function nanoToDurationTimeFields(nano, largestUnit = 5) {
+    return nanoToGivenFields(nano, largestUnit, durationFieldNamesAsc);
+  }
+  function durationHasDateParts(fields) {
+    return Boolean(computeDurationSign(fields, durationDateFieldNamesAsc));
+  }
+  function getMaxDurationUnit(fields) {
+    let unit = 9;
+    for (;unit > 0 && !fields[durationFieldNamesAsc[unit]]; unit--) {}
+    return unit;
+  }
+  function createSplitTuple(startEpochSec, endEpochSec) {
+    return [ startEpochSec, endEpochSec ];
+  }
+  function computePeriod(epochSec) {
+    const startEpochSec = Math.floor(epochSec / periodDur) * periodDur;
+    return [ startEpochSec, startEpochSec + periodDur ];
+  }
+  function parseOffsetNano(s) {
+    const offsetNano = parseOffsetNanoMaybe(s);
+    if (void 0 === offsetNano) {
+      throw new RangeError(failedParse(s));
+    }
+    return offsetNano;
+  }
+  function parsePlainDate(s, isPlainYearMonth, isPlainMonthDay) {
+    let organized = parseDateTimeLike(requireString(s));
+    if (!organized || organized.hasZ) {
+      throw new RangeError(failedParse(s));
+    }
+    return isPlainYearMonth ? organized.calendar === isoCalendarId && (organized = -271821 === organized.isoYear && 4 === organized.isoMonth ? {
+      ...organized,
+      isoDay: 20,
+      ...isoTimeFieldDefaults
+    } : {
+      ...organized,
+      isoDay: 1,
+      ...isoTimeFieldDefaults
+    }) : isPlainMonthDay && organized.calendar === isoCalendarId && (organized = {
+      ...organized,
+      isoYear: isoEpochFirstLeapYear
+    }), createPlainDateSlots(organized.hasTime ? finalizeDateTime(organized) : finalizeDate(organized));
+  }
+  function requireIsoCalendar(organized) {
+    if (organized.calendar !== isoCalendarId) {
+      throw new RangeError(invalidSubstring(organized.calendar));
+    }
+  }
+  function finalizeZonedDateTime(organized, offsetNano, offsetDisambig = 0, epochDisambig = 0) {
+    const timeZoneId = resolveTimeZoneId(organized.timeZone), timeZoneImpl = queryNativeTimeZone(timeZoneId);
+    let epochNano;
+    return checkIsoDateTimeFields(organized), epochNano = organized.hasTime ? getMatchingInstantFor(timeZoneImpl, organized, offsetNano, offsetDisambig, epochDisambig, !timeZoneImpl.offsetNano, organized.hasZ) : getStartOfDayInstantFor(timeZoneImpl, organized), 
+    createZonedDateTimeSlots(epochNano, timeZoneId, resolveCalendarId(organized.calendar));
+  }
+  function finalizeDateTime(organized) {
+    return resolveSlotsCalendar(checkIsoDateTimeInBounds(checkIsoDateTimeFields(organized)));
+  }
+  function finalizeDate(organized) {
+    return resolveSlotsCalendar(checkIsoDateInBounds(checkIsoDateFields(organized)));
+  }
+  function resolveSlotsCalendar(organized) {
+    return {
+      ...organized,
+      calendar: resolveCalendarId(organized.calendar)
+    };
+  }
+  function parseDateTimeLike(s) {
+    const parts = dateTimeRegExp.exec(s);
+    return parts ? (parts => {
+      const zOrOffset = parts[10], hasZ = "Z" === (zOrOffset || "").toUpperCase();
+      return {
+        isoYear: organizeIsoYearParts(parts),
+        isoMonth: parseInt(parts[4]),
+        isoDay: parseInt(parts[5]),
+        ...organizeTimeParts(parts.slice(5)),
+        ...organizeAnnotationParts(parts[16]),
+        hasTime: Boolean(parts[6]),
+        hasZ: hasZ,
+        offset: hasZ ? void 0 : zOrOffset
+      };
+    })(parts) : void 0;
+  }
+  function parseYearMonthOnly(s) {
+    const parts = yearMonthRegExp.exec(s);
+    return parts ? (parts => ({
+      isoYear: organizeIsoYearParts(parts),
+      isoMonth: parseInt(parts[4]),
+      isoDay: 1,
+      ...organizeAnnotationParts(parts[5])
+    }))(parts) : void 0;
+  }
+  function parseMonthDayOnly(s) {
+    const parts = monthDayRegExp.exec(s);
+    return parts ? (parts => ({
+      isoYear: isoEpochFirstLeapYear,
+      isoMonth: parseInt(parts[1]),
+      isoDay: parseInt(parts[2]),
+      ...organizeAnnotationParts(parts[3])
+    }))(parts) : void 0;
+  }
+  function parseOffsetNanoMaybe(s, onlyHourMinute) {
+    const parts = offsetRegExp.exec(s);
+    return parts ? ((parts, onlyHourMinute) => {
+      const firstSubMinutePart = parts[4] || parts[5];
+      if (onlyHourMinute && firstSubMinutePart) {
+        throw new RangeError(invalidSubstring(firstSubMinutePart));
+      }
+      return (offsetNano => {
+        if (Math.abs(offsetNano) >= nanoInUtcDay) {
+          throw new RangeError(outOfBoundsOffset);
+        }
+        return offsetNano;
+      })((parseInt0(parts[2]) * nanoInHour + parseInt0(parts[3]) * nanoInMinute + parseInt0(parts[4]) * nanoInSec + parseSubsecNano(parts[5] || "")) * parseSign(parts[1]));
+    })(parts, onlyHourMinute) : void 0;
+  }
+  function organizeIsoYearParts(parts) {
+    const yearSign = parseSign(parts[1]), year = parseInt(parts[2] || parts[3]);
+    if (yearSign < 0 && !year) {
+      throw new RangeError(invalidSubstring(-0));
+    }
+    return yearSign * year;
+  }
+  function organizeTimeParts(parts) {
+    const isoSecond = parseInt0(parts[3]);
+    return {
+      ...nanoToIsoTimeAndDay(parseSubsecNano(parts[4] || ""))[0],
+      isoHour: parseInt0(parts[1]),
+      isoMinute: parseInt0(parts[2]),
+      isoSecond: 60 === isoSecond ? 59 : isoSecond
+    };
+  }
+  function organizeAnnotationParts(s) {
+    let calendarIsCritical, timeZoneId;
+    const calendarIds = [];
+    if (s.replace(annotationRegExp, ((whole, criticalStr, mainStr) => {
+      const isCritical = Boolean(criticalStr), [val, name] = mainStr.split("=").reverse();
+      if (name) {
+        if ("u-ca" === name) {
+          calendarIds.push(val), calendarIsCritical || (calendarIsCritical = isCritical);
+        } else if (isCritical || /[A-Z]/.test(name)) {
+          throw new RangeError(invalidSubstring(whole));
+        }
+      } else {
+        if (timeZoneId) {
+          throw new RangeError(invalidSubstring(whole));
+        }
+        timeZoneId = val;
+      }
+      return "";
+    })), calendarIds.length > 1 && calendarIsCritical) {
+      throw new RangeError(invalidSubstring(s));
+    }
+    return {
+      timeZone: timeZoneId,
+      calendar: calendarIds[0] || isoCalendarId
+    };
+  }
+  function parseSubsecNano(fracStr) {
+    return parseInt(fracStr.padEnd(9, "0"));
+  }
+  function createRegExp(meat) {
+    return new RegExp(`^${meat}$`, "i");
+  }
+  function parseSign(s) {
+    return s && "+" !== s ? -1 : 1;
+  }
+  function parseInt0(s) {
+    return void 0 === s ? 0 : parseInt(s);
+  }
+  function resolveTimeZoneId(id) {
+    const essence = getTimeZoneEssence(id);
+    return "number" == typeof essence ? formatOffsetNano(essence) : essence ? (id => {
+      if (badCharactersRegExp.test(id)) {
+        throw new RangeError(invalidTimeZone(id));
+      }
+      if (icuRegExp.test(id)) {
+        throw new RangeError(forbiddenIcuTimeZone);
+      }
+      return id.toLowerCase().split("/").map(((part, partI) => (part.length <= 3 || /\d/.test(part)) && !/etc|yap/.test(part) ? part.toUpperCase() : part.replace(/baja|dumont|[a-z]+/g, ((a, i) => a.length <= 2 && !partI || "in" === a || "chat" === a ? a.toUpperCase() : a.length > 2 || !i ? capitalize(a).replace(/island|noronha|murdo|rivadavia|urville/, capitalize) : a)))).join("/");
+    })(id) : utcTimeZoneId;
+  }
+  function getTimeZoneAtomic(id) {
+    const essence = getTimeZoneEssence(id);
+    return "number" == typeof essence ? essence : essence ? essence.resolvedOptions().timeZone : utcTimeZoneId;
+  }
+  function getTimeZoneEssence(id) {
+    const offsetNano = parseOffsetNanoMaybe(id = id.toUpperCase(), 1);
+    return void 0 !== offsetNano ? offsetNano : id !== utcTimeZoneId ? queryTimeZoneIntlFormat(id) : void 0;
+  }
+  function compareInstants(instantSlots0, instantSlots1) {
+    return compareBigNanos(instantSlots0.epochNanoseconds, instantSlots1.epochNanoseconds);
+  }
+  function compareZonedDateTimes(zonedDateTimeSlots0, zonedDateTimeSlots1) {
+    return compareBigNanos(zonedDateTimeSlots0.epochNanoseconds, zonedDateTimeSlots1.epochNanoseconds);
+  }
+  function compareIsoDateTimeFields(isoFields0, isoFields1) {
+    return compareIsoDateFields(isoFields0, isoFields1) || compareIsoTimeFields(isoFields0, isoFields1);
+  }
+  function compareIsoDateFields(isoFields0, isoFields1) {
+    return compareNumbers(isoToEpochMilli(isoFields0), isoToEpochMilli(isoFields1));
+  }
+  function compareIsoTimeFields(isoFields0, isoFields1) {
+    return compareNumbers(isoTimeFieldsToNano(isoFields0), isoTimeFieldsToNano(isoFields1));
+  }
+  function isTimeZoneIdsEqual(a, b) {
+    if (a === b) {
+      return 1;
+    }
+    try {
+      return getTimeZoneAtomic(a) === getTimeZoneAtomic(b);
+    } catch (_a) {}
+  }
+  function createNativeOpsCreator(isoOps, intlOps) {
+    return calendarId => calendarId === isoCalendarId ? isoOps : calendarId === gregoryCalendarId || "japanese" === calendarId ? Object.assign(Object.create(isoOps), {
+      id: calendarId
+    }) : Object.assign(Object.create(intlOps), queryIntlCalendar(calendarId));
+  }
+  function refineCalendarFields(calendarOps, bag, validFieldNames, requiredFieldNames = [], forcedValidFieldNames = []) {
+    return refineFields(bag, [ ...calendarOps.fields(validFieldNames), ...forcedValidFieldNames ].sort(), requiredFieldNames);
+  }
+  function refineFields(bag, validFieldNames, requiredFieldNames, disallowEmpty = !requiredFieldNames) {
+    const res = {};
+    let prevFieldName, anyMatching = 0;
+    for (const fieldName of validFieldNames) {
+      if (fieldName === prevFieldName) {
+        throw new RangeError(duplicateFields(fieldName));
+      }
+      if ("constructor" === fieldName || "__proto__" === fieldName) {
+        throw new RangeError(forbiddenField(fieldName));
+      }
+      let fieldVal = bag[fieldName];
+      if (void 0 !== fieldVal) {
+        anyMatching = 1, builtinRefiners[fieldName] && (fieldVal = builtinRefiners[fieldName](fieldVal, fieldName)), 
+        res[fieldName] = fieldVal;
+      } else if (requiredFieldNames) {
+        if (requiredFieldNames.includes(fieldName)) {
+          throw new TypeError(missingField(fieldName));
+        }
+        res[fieldName] = timeFieldDefaults[fieldName];
+      }
+      prevFieldName = fieldName;
+    }
+    if (disallowEmpty && !anyMatching) {
+      throw new TypeError(noValidFields(validFieldNames));
+    }
+    return res;
+  }
+  function refineTimeBag(fields, overflow) {
+    return constrainIsoTimeFields(timeFieldsToIso({
+      ...timeFieldDefaults,
+      ...fields
+    }), overflow);
+  }
+  function convertToIso(calendarOps, input, inputFieldNames, extra, extraFieldNames) {
+    input = pluckProps(inputFieldNames = calendarOps.fields(inputFieldNames), input), 
+    extra = refineFields(extra, extraFieldNames = calendarOps.fields(extraFieldNames), []);
+    let mergedFields = calendarOps.mergeFields(input, extra);
+    return mergedFields = refineFields(mergedFields, [ ...inputFieldNames, ...extraFieldNames ].sort(), []), 
+    calendarOps.dateFromFields(mergedFields);
+  }
+  function refineYear(calendarNative, fields) {
+    const eraOrigins = getCalendarEraOrigins(calendarNative), eraRemaps = eraRemapsByCalendarId[calendarNative.id || ""] || {};
+    let {era: era, eraYear: eraYear, year: year} = fields;
+    if (void 0 !== era || void 0 !== eraYear) {
+      if (void 0 === era || void 0 === eraYear) {
+        throw new TypeError(mismatchingEraParts);
+      }
+      if (!eraOrigins) {
+        throw new RangeError(forbiddenEraParts);
+      }
+      const eraOrigin = eraOrigins[eraRemaps[era] || era];
+      if (void 0 === eraOrigin) {
+        throw new RangeError(invalidEra(era));
+      }
+      const yearByEra = eraYearToYear(eraYear, eraOrigin);
+      if (void 0 !== year && year !== yearByEra) {
+        throw new RangeError(mismatchingYearAndEra);
+      }
+      year = yearByEra;
+    } else if (void 0 === year) {
+      throw new TypeError(missingYear(eraOrigins));
+    }
+    return year;
+  }
+  function refineMonth(calendarNative, fields, year, overflow) {
+    let {month: month, monthCode: monthCode} = fields;
+    if (void 0 !== monthCode) {
+      const monthByCode = ((calendarNative, monthCode, year, overflow) => {
+        const leapMonth = calendarNative.leapMonth(year), [monthCodeNumber, wantsLeapMonth] = parseMonthCode(monthCode);
+        let month = monthCodeNumberToMonth(monthCodeNumber, wantsLeapMonth, leapMonth);
+        if (wantsLeapMonth) {
+          const leapMonthMeta = getCalendarLeapMonthMeta(calendarNative);
+          if (void 0 === leapMonthMeta) {
+            throw new RangeError(invalidLeapMonth);
+          }
+          if (leapMonthMeta > 0) {
+            if (month > leapMonthMeta) {
+              throw new RangeError(invalidLeapMonth);
+            }
+            if (void 0 === leapMonth) {
+              if (1 === overflow) {
+                throw new RangeError(invalidLeapMonth);
+              }
+              month--;
+            }
+          } else {
+            if (month !== -leapMonthMeta) {
+              throw new RangeError(invalidLeapMonth);
+            }
+            if (void 0 === leapMonth && 1 === overflow) {
+              throw new RangeError(invalidLeapMonth);
+            }
+          }
+        }
+        return month;
+      })(calendarNative, monthCode, year, overflow);
+      if (void 0 !== month && month !== monthByCode) {
+        throw new RangeError(mismatchingMonthAndCode);
+      }
+      month = monthByCode, overflow = 1;
+    } else if (void 0 === month) {
+      throw new TypeError(missingMonth);
+    }
+    return clampEntity("month", month, 1, calendarNative.monthsInYearPart(year), overflow);
+  }
+  function refineDay(calendarNative, fields, month, year, overflow) {
+    return clampProp(fields, "day", 1, calendarNative.daysInMonthParts(year, month), overflow);
+  }
+  function spliceFields(dest, additional, allPropNames, deletablePropNames) {
+    let anyMatching = 0;
+    const nonMatchingPropNames = [];
+    for (const propName of allPropNames) {
+      void 0 !== additional[propName] ? anyMatching = 1 : nonMatchingPropNames.push(propName);
+    }
+    if (Object.assign(dest, additional), anyMatching) {
+      for (const deletablePropName of deletablePropNames || nonMatchingPropNames) {
+        delete dest[deletablePropName];
+      }
+    }
+  }
+  function computeDateEssentials(slots) {
+    const calendarOps = createNativePartOps(slots.calendar), [year, month, day] = calendarOps.dateParts(slots), [monthCodeNumber, isLeapMonth] = calendarOps.monthCodeParts(year, month);
+    return {
+      year: year,
+      monthCode: formatMonthCode(monthCodeNumber, isLeapMonth),
+      day: day
+    };
+  }
+  function zonedDateTimeToPlainDateTime(getTimeZoneOps, zonedDateTimeSlots0) {
+    return createPlainDateTimeSlots(zonedEpochSlotsToIso(zonedDateTimeSlots0, getTimeZoneOps));
+  }
+  function zonedDateTimeToPlainDate(getTimeZoneOps, zonedDateTimeSlots0) {
+    return createPlainDateSlots(zonedEpochSlotsToIso(zonedDateTimeSlots0, getTimeZoneOps));
+  }
+  function zonedDateTimeToPlainTime(getTimeZoneOps, zonedDateTimeSlots0) {
+    return createPlainTimeSlots(zonedEpochSlotsToIso(zonedDateTimeSlots0, getTimeZoneOps));
+  }
+  function createSlotClass(branding, construct, getters, methods, staticMethods) {
+    function Class(...args) {
+      if (!(this instanceof Class)) {
+        throw new TypeError("Invalid calling context");
+      }
+      setSlots(this, construct(...args));
+    }
+    function bindMethod(method, methodName) {
+      return Object.defineProperties((function(...args) {
+        return method.call(this, getSpecificSlots(this), ...args);
+      }), createNameDescriptors(methodName));
+    }
+    function getSpecificSlots(obj) {
+      const slots = getSlots(obj);
+      if (!slots || slots.branding !== branding) {
+        throw new TypeError("Invalid calling context");
+      }
+      return slots;
+    }
+    return Object.defineProperties(Class.prototype, {
+      ...createGetterDescriptors(mapProps(bindMethod, getters)),
+      ...createPropDescriptors(mapProps(bindMethod, methods)),
+      ...createStringTagDescriptors("Temporal." + branding)
+    }), Object.defineProperties(Class, {
+      ...createPropDescriptors(staticMethods),
+      ...createNameDescriptors(branding)
+    }), [ Class, slots => {
+      const instance = Object.create(Class.prototype);
+      return setSlots(instance, slots), instance;
+    }, getSpecificSlots ];
+  }
+  function rejectInvalidBag(bag) {
+    if (getSlots(bag) || void 0 !== bag.calendar || void 0 !== bag.timeZone) {
+      throw new TypeError("Invalid bag");
+    }
+    return bag;
+  }
+  function getCalendarIdFromBag(bag) {
+    return extractCalendarIdFromBag(bag) || isoCalendarId;
+  }
+  function extractCalendarIdFromBag(bag) {
+    const {calendar: calendarArg} = bag;
+    if (void 0 !== calendarArg) {
+      return refineCalendarArg(calendarArg);
+    }
+  }
+  function refineCalendarArg(arg) {
+    if (isObjectLike(arg)) {
+      const {calendar: calendar} = getSlots(arg) || {};
+      if (!calendar) {
+        throw new TypeError(invalidCalendar(arg));
+      }
+      return calendar;
+    }
+    return (arg => resolveCalendarId((s => {
+      const res = parseDateTimeLike(s) || parseYearMonthOnly(s) || parseMonthDayOnly(s);
+      return res ? res.calendar : s;
+    })(requireString(arg))))(arg);
+  }
+  function createCalendarGetters(methodNameMap) {
+    const methods = {};
+    for (const methodName in methodNameMap) {
+      methods[methodName] = slots => {
+        const {calendar: calendar} = slots;
+        return createNativeStandardOps(calendar)[methodName](slots);
+      };
+    }
+    return methods;
+  }
+  function neverValueOf() {
+    throw new TypeError("Cannot use valueOf");
+  }
+  function refineTimeZoneArg(arg) {
+    if (isObjectLike(arg)) {
+      const {timeZone: timeZone} = getSlots(arg) || {};
+      if (!timeZone) {
+        throw new TypeError(invalidTimeZone(arg));
+      }
+      return timeZone;
+    }
+    return (arg => resolveTimeZoneId((s => {
+      const parsed = parseDateTimeLike(s);
+      return parsed && (parsed.timeZone || parsed.hasZ && utcTimeZoneId || parsed.offset) || s;
+    })(requireString(arg))))(arg);
+  }
+  function toDurationSlots(arg) {
+    if (isObjectLike(arg)) {
+      const slots = getSlots(arg);
+      return slots && slots.branding === DurationBranding ? slots : (bag => {
+        const durationFields = refineFields(bag, durationFieldNamesAlpha);
+        return createDurationSlots(checkDurationUnits({
+          ...durationFieldDefaults,
+          ...durationFields
+        }));
+      })(arg);
+    }
+    return (s => {
+      const parsed = (s => {
+        const parts = durationRegExp.exec(s);
+        return parts ? (parts => {
+          function parseUnit(wholeStr, fracStr, timeUnit) {
+            let leftoverUnits = 0, wholeUnits = 0;
+            if (timeUnit && ([leftoverUnits, leftoverNano] = divModFloor(leftoverNano, unitNanoMap[timeUnit])), 
+            void 0 !== wholeStr) {
+              if (hasAnyFrac) {
+                throw new RangeError(invalidSubstring(wholeStr));
+              }
+              wholeUnits = (s => {
+                const n = parseInt(s);
+                if (!Number.isFinite(n)) {
+                  throw new RangeError(invalidSubstring(s));
+                }
+                return n;
+              })(wholeStr), hasAny = 1, fracStr && (leftoverNano = parseSubsecNano(fracStr) * (unitNanoMap[timeUnit] / nanoInSec), 
+              hasAnyFrac = 1);
+            }
+            return leftoverUnits + wholeUnits;
+          }
+          let hasAny = 0, hasAnyFrac = 0, leftoverNano = 0, durationFields = {
+            ...zipProps(durationFieldNamesAsc, [ parseUnit(parts[2]), parseUnit(parts[3]), parseUnit(parts[4]), parseUnit(parts[5]), parseUnit(parts[6], parts[7], 5), parseUnit(parts[8], parts[9], 4), parseUnit(parts[10], parts[11], 3) ]),
+            ...nanoToGivenFields(leftoverNano, 2, durationFieldNamesAsc)
+          };
+          if (!hasAny) {
+            throw new RangeError(noValidFields(durationFieldNamesAsc));
+          }
+          return parseSign(parts[1]) < 0 && (durationFields = negateDurationFields(durationFields)), 
+          durationFields;
+        })(parts) : void 0;
+      })(requireString(s));
+      if (!parsed) {
+        throw new RangeError(failedParse(s));
+      }
+      return createDurationSlots(checkDurationUnits(parsed));
+    })(arg);
+  }
+  function refinePublicRelativeTo(relativeTo) {
+    if (void 0 !== relativeTo) {
+      if (isObjectLike(relativeTo)) {
+        const slots = getSlots(relativeTo) || {};
+        switch (slots.branding) {
+         case ZonedDateTimeBranding:
+         case PlainDateBranding:
+          return slots;
+
+         case PlainDateTimeBranding:
+          return createPlainDateSlots(slots);
+        }
+        const calendarId = getCalendarIdFromBag(relativeTo);
+        return {
+          ...((refineTimeZoneString, getTimeZoneOps, calendarOps, bag) => {
+            const fields = refineCalendarFields(calendarOps, bag, dateFieldNamesAlpha, [], timeAndZoneFieldNames);
+            if (void 0 !== fields.timeZone) {
+              const isoDateFields = calendarOps.dateFromFields(fields), isoTimeFields = refineTimeBag(fields), timeZoneId = refineTimeZoneString(fields.timeZone);
+              return {
+                epochNanoseconds: getMatchingInstantFor(getTimeZoneOps(timeZoneId), {
+                  ...isoDateFields,
+                  ...isoTimeFields
+                }, void 0 !== fields.offset ? parseOffsetNano(fields.offset) : void 0),
+                timeZone: timeZoneId
+              };
+            }
+            return {
+              ...calendarOps.dateFromFields(fields),
+              ...isoTimeFieldDefaults
+            };
+          })(refineTimeZoneArg, queryNativeTimeZone, createNativeStandardOps(calendarId), relativeTo),
+          calendar: calendarId
+        };
+      }
+      return (s => {
+        const organized = parseDateTimeLike(requireString(s));
+        if (!organized) {
+          throw new RangeError(failedParse(s));
+        }
+        if (organized.timeZone) {
+          return finalizeZonedDateTime(organized, organized.offset ? parseOffsetNano(organized.offset) : void 0);
+        }
+        if (organized.hasZ) {
+          throw new RangeError(failedParse(s));
+        }
+        return finalizeDate(organized);
+      })(relativeTo);
+    }
+  }
+  function createOptionsTransformer(standardNames, fallbacks, exclusions) {
+    const excludedNameSet = new Set(exclusions);
+    return (options, strictOptions) => {
+      const hasAnyExclusions = exclusions && hasAnyPropsByName(options, exclusions);
+      if (!hasAnyPropsByName(options = ((propNames, props) => {
+        const filteredProps = {};
+        for (const propName in props) {
+          propNames.has(propName) || (filteredProps[propName] = props[propName]);
+        }
+        return filteredProps;
+      })(excludedNameSet, options), standardNames)) {
+        if (strictOptions && hasAnyExclusions) {
+          throw new TypeError("Invalid formatting options");
+        }
+        options = {
+          ...fallbacks,
+          ...options
+        };
+      }
+      return exclusions && (options.timeZone = utcTimeZoneId, [ "full", "long" ].includes(options.timeStyle) && (options.timeStyle = "medium")), 
+      options;
+    };
+  }
+  function createFormatPrepper(config, queryFormat = createFormatForPrep, strictOptions = 0) {
+    const [transformOptions, , , getForcedTimeZoneId] = config;
+    return (locales, options = emptyOptions, ...slotsList) => {
+      const subformat = queryFormat(getForcedTimeZoneId && getForcedTimeZoneId(...slotsList), locales, options, transformOptions, strictOptions), resolvedOptions = subformat.resolvedOptions();
+      return [ subformat, ...toEpochMillis(config, resolvedOptions, slotsList) ];
+    };
+  }
+  function createFormatForPrep(forcedTimeZoneId, locales, options, transformOptions, strictOptions) {
+    if (options = transformOptions(options, strictOptions), forcedTimeZoneId) {
+      if (void 0 !== options.timeZone) {
+        throw new TypeError(forbiddenFormatTimeZone);
+      }
+      options.timeZone = forcedTimeZoneId;
+    }
+    return new RawDateTimeFormat(locales, options);
+  }
+  function toEpochMillis(config, resolvedOptions, slotsList) {
+    const [, slotsToEpochMilli, strictCalendarCheck] = config;
+    return slotsList.map((slots => (slots.calendar && ((internalCalendarId, resolvedCalendarId, strictCalendarCheck) => {
+      if ((strictCalendarCheck || internalCalendarId !== isoCalendarId) && internalCalendarId !== resolvedCalendarId) {
+        throw new RangeError(mismatchingCalendars);
+      }
+    })(slots.calendar, resolvedOptions.calendar, strictCalendarCheck), slotsToEpochMilli(slots, resolvedOptions))));
+  }
+  function slotsWithCalendarId(slots, calendarId) {
+    return {
+      ...slots,
+      calendar: calendarId
+    };
+  }
+  function toPlainTimeSlots(arg, options) {
+    if (isObjectLike(arg)) {
+      const slots = getSlots(arg) || {};
+      switch (slots.branding) {
+       case PlainTimeBranding:
+        return refineOverflowOptions(options), slots;
+
+       case PlainDateTimeBranding:
+        return refineOverflowOptions(options), createPlainTimeSlots(slots);
+
+       case ZonedDateTimeBranding:
+        return refineOverflowOptions(options), zonedDateTimeToPlainTime(queryNativeTimeZone, slots);
+      }
+      return ((bag, options) => createPlainTimeSlots(refineTimeBag(refineFields(bag, timeFieldNamesAlpha, [], 1), refineOverflowOptions(options))))(arg, options);
+    }
+    const timeSlots = (s => {
+      let altParsed, organized = (s => {
+        const parts = timeRegExp.exec(s);
+        return parts ? (organizeAnnotationParts(parts[10]), organizeTimeParts(parts)) : void 0;
+      })(requireString(s));
+      if (!organized) {
+        if (organized = parseDateTimeLike(s), !organized) {
+          throw new RangeError(failedParse(s));
+        }
+        if (!organized.hasTime) {
+          throw new RangeError(failedParse(s));
+        }
+        if (organized.hasZ) {
+          throw new RangeError(invalidSubstring("Z"));
+        }
+        requireIsoCalendar(organized);
+      }
+      if ((altParsed = parseYearMonthOnly(s)) && isIsoDateFieldsValid(altParsed)) {
+        throw new RangeError(failedParse(s));
+      }
+      if ((altParsed = parseMonthDayOnly(s)) && isIsoDateFieldsValid(altParsed)) {
+        throw new RangeError(failedParse(s));
+      }
+      return createPlainTimeSlots(constrainIsoTimeFields(organized, 1));
+    })(arg);
+    return refineOverflowOptions(options), timeSlots;
+  }
+  function optionalToPlainTimeFields(timeArg) {
+    return void 0 === timeArg ? void 0 : toPlainTimeSlots(timeArg);
+  }
+  function toPlainDateTimeSlots(arg, options) {
+    if (isObjectLike(arg)) {
+      const slots = getSlots(arg) || {};
+      switch (slots.branding) {
+       case PlainDateTimeBranding:
+        return refineOverflowOptions(options), slots;
+
+       case PlainDateBranding:
+        return refineOverflowOptions(options), createPlainDateTimeSlots({
+          ...slots,
+          ...isoTimeFieldDefaults
+        });
+
+       case ZonedDateTimeBranding:
+        return refineOverflowOptions(options), zonedDateTimeToPlainDateTime(queryNativeTimeZone, slots);
+      }
+      return ((calendarOps, bag, options) => {
+        const fields = refineCalendarFields(calendarOps, bag, dateFieldNamesAlpha, [], timeFieldNamesAsc), overflow = refineOverflowOptions(options);
+        return createPlainDateTimeSlots(checkIsoDateTimeInBounds({
+          ...calendarOps.dateFromFields(fields, fabricateOverflowOptions(overflow)),
+          ...refineTimeBag(fields, overflow)
+        }));
+      })(createNativeStandardOps(getCalendarIdFromBag(arg)), arg, options);
+    }
+    const res = (s => {
+      const organized = parseDateTimeLike(requireString(s));
+      if (!organized || organized.hasZ) {
+        throw new RangeError(failedParse(s));
+      }
+      return createPlainDateTimeSlots(finalizeDateTime(organized));
+    })(arg);
+    return refineOverflowOptions(options), res;
+  }
+  function toPlainMonthDaySlots(arg, options) {
+    if (isObjectLike(arg)) {
+      const slots = getSlots(arg);
+      if (slots && slots.branding === PlainMonthDayBranding) {
+        return refineOverflowOptions(options), slots;
+      }
+      const calendarIdMaybe = extractCalendarIdFromBag(arg);
+      return ((calendarOps, calendarAbsent, bag, options) => {
+        const fields = refineCalendarFields(calendarOps, bag, dateFieldNamesAlpha, dayFieldNames);
+        return calendarAbsent && void 0 !== fields.month && void 0 === fields.monthCode && void 0 === fields.year && (fields.year = isoEpochFirstLeapYear), 
+        calendarOps.monthDayFromFields(fields, options);
+      })(createNativeStandardOps(calendarIdMaybe || isoCalendarId), !calendarIdMaybe, arg, options);
+    }
+    const res = ((getCalendarOps, s) => {
+      const organized = parseMonthDayOnly(requireString(s));
+      if (organized) {
+        return requireIsoCalendar(organized), createPlainMonthDaySlots(checkIsoDateFields(organized));
+      }
+      const dateSlots = parsePlainDate(s, 0, 1), {calendar: calendar} = dateSlots, calendarOps = getCalendarOps(calendar), [origYear, origMonth, day] = calendarOps.dateParts(dateSlots), [monthCodeNumber, isLeapMonth] = calendarOps.monthCodeParts(origYear, origMonth), [year, month] = calendarOps.yearMonthForMonthDay(monthCodeNumber, isLeapMonth, day);
+      return createPlainMonthDaySlots(checkIsoDateInBounds(calendarOps.isoFields(year, month, day)), calendar);
+    })(createNativeStandardOps, arg);
+    return refineOverflowOptions(options), res;
+  }
+  function toPlainYearMonthSlots(arg, options) {
+    if (isObjectLike(arg)) {
+      const slots = getSlots(arg);
+      return slots && slots.branding === PlainYearMonthBranding ? (refineOverflowOptions(options), 
+      slots) : ((calendarOps, bag, options) => {
+        const fields = refineCalendarFields(calendarOps, bag, yearMonthFieldNames, void 0);
+        return calendarOps.yearMonthFromFields(fields, options);
+      })(createNativeStandardOps(getCalendarIdFromBag(arg)), arg, options);
+    }
+    const res = ((getCalendarOps, s) => {
+      const organized = parseYearMonthOnly(requireString(s));
+      if (organized) {
+        return requireIsoCalendar(organized), createPlainYearMonthSlots(checkIsoYearMonthInBounds(checkIsoDateFields(organized)));
+      }
+      const isoSlots = parsePlainDate(s, 1);
+      return createPlainYearMonthSlots(moveToDayOfMonthUnsafe(getCalendarOps(isoSlots.calendar), isoSlots));
+    })(createNativeStandardOps, arg);
+    return refineOverflowOptions(options), res;
+  }
+  function toPlainDateSlots(arg, options) {
+    if (isObjectLike(arg)) {
+      const slots = getSlots(arg) || {};
+      switch (slots.branding) {
+       case PlainDateBranding:
+        return refineOverflowOptions(options), slots;
+
+       case PlainDateTimeBranding:
+        return refineOverflowOptions(options), createPlainDateSlots(slots);
+
+       case ZonedDateTimeBranding:
+        return refineOverflowOptions(options), zonedDateTimeToPlainDate(queryNativeTimeZone, slots);
+      }
+      return ((calendarOps, bag, options, requireFields = []) => {
+        const fields = refineCalendarFields(calendarOps, bag, dateFieldNamesAlpha, requireFields);
+        return calendarOps.dateFromFields(fields, options);
+      })(createNativeStandardOps(getCalendarIdFromBag(arg)), arg, options);
+    }
+    const res = parsePlainDate(arg);
+    return refineOverflowOptions(options), res;
+  }
+  function toZonedDateTimeSlots(arg, options) {
+    if (isObjectLike(arg)) {
+      const slots = getSlots(arg);
+      if (slots && slots.branding === ZonedDateTimeBranding) {
+        return refineZonedFieldOptions(options), slots;
+      }
+      const calendarId = getCalendarIdFromBag(arg);
+      return ((refineTimeZoneString, getTimeZoneOps, calendarOps, calendarId, bag, options) => {
+        const fields = refineCalendarFields(calendarOps, bag, dateFieldNamesAlpha, timeZoneFieldNames, timeAndZoneFieldNames), timeZoneId = refineTimeZoneString(fields.timeZone), [overflow, offsetDisambig, epochDisambig] = refineZonedFieldOptions(options), isoDateFields = calendarOps.dateFromFields(fields, fabricateOverflowOptions(overflow)), isoTimeFields = refineTimeBag(fields, overflow);
+        return createZonedDateTimeSlots(getMatchingInstantFor(getTimeZoneOps(timeZoneId), {
+          ...isoDateFields,
+          ...isoTimeFields
+        }, void 0 !== fields.offset ? parseOffsetNano(fields.offset) : void 0, offsetDisambig, epochDisambig), timeZoneId, calendarId);
+      })(refineTimeZoneArg, queryNativeTimeZone, createNativeStandardOps(calendarId), calendarId, arg, options);
+    }
+    return ((s, options) => {
+      const organized = parseDateTimeLike(requireString(s));
+      if (!organized || !organized.timeZone) {
+        throw new RangeError(failedParse(s));
+      }
+      const {offset: offset} = organized, offsetNano = offset ? parseOffsetNano(offset) : void 0, [, offsetDisambig, epochDisambig] = refineZonedFieldOptions(options);
+      return finalizeZonedDateTime(organized, offsetNano, offsetDisambig, epochDisambig);
+    })(arg, options);
+  }
+  function adaptDateMethods(methods) {
+    return mapProps((method => slots => method(slotsToIso(slots))), methods);
+  }
+  function slotsToIso(slots) {
+    return zonedEpochSlotsToIso(slots, queryNativeTimeZone);
+  }
+  function toInstantSlots(arg) {
+    if (isObjectLike(arg)) {
+      const slots = getSlots(arg);
+      if (slots) {
+        switch (slots.branding) {
+         case InstantBranding:
+          return slots;
+
+         case ZonedDateTimeBranding:
+          return createInstantSlots(slots.epochNanoseconds);
+        }
+      }
+    }
+    return (s => {
+      const organized = parseDateTimeLike(s = toStringViaPrimitive(s));
+      if (!organized) {
+        throw new RangeError(failedParse(s));
+      }
+      let offsetNano;
+      if (organized.hasZ) {
+        offsetNano = 0;
+      } else {
+        if (!organized.offset) {
+          throw new RangeError(failedParse(s));
+        }
+        offsetNano = parseOffsetNano(organized.offset);
+      }
+      return organized.timeZone && parseOffsetNanoMaybe(organized.timeZone, 1), createInstantSlots(isoToEpochNanoWithOffset(checkIsoDateTimeFields(organized), offsetNano));
+    })(arg);
+  }
+  function createFormatMethod(methodName) {
+    return Object.defineProperties((function(...formattables) {
+      const prepFormat = internalsMap.get(this), [format, ...rawFormattables] = prepFormat(methodName.includes("Range"), ...formattables);
+      return format[methodName](...rawFormattables);
+    }), createNameDescriptors(methodName));
+  }
+  function createProxiedMethod(methodName) {
+    return Object.defineProperties((function(...args) {
+      return internalsMap.get(this).rawFormat[methodName](...args);
+    }), createNameDescriptors(methodName));
+  }
+  function createFormatPrepperForBranding(branding) {
+    const config = classFormatConfigs[branding];
+    if (!config) {
+      throw new TypeError(invalidFormatType(branding));
+    }
+    return createFormatPrepper(config, memoize(createFormatForPrep), 1);
+  }
+  function getCurrentIsoDateTime(timeZoneOps) {
+    const epochNano = getCurrentEpochNano();
+    return epochNanoToIso(epochNano, timeZoneOps.getOffsetNanosecondsFor(epochNano));
+  }
+  function getCurrentEpochNano() {
+    return numberToBigNano(Date.now(), nanoInMilli);
+  }
+  function getCurrentTimeZoneId() {
+    return currentTimeZoneId || (currentTimeZoneId = (new RawDateTimeFormat).resolvedOptions().timeZone);
+  }
+  const expectedInteger = (entityName, num) => `Non-integer ${entityName}: ${num}`, expectedPositive = (entityName, num) => `Non-positive ${entityName}: ${num}`, expectedFinite = (entityName, num) => `Non-finite ${entityName}: ${num}`, forbiddenBigIntToNumber = entityName => `Cannot convert bigint to ${entityName}`, invalidBigInt = arg => `Invalid bigint: ${arg}`, forbiddenSymbolToString = "Cannot convert Symbol to string", invalidObject = "Invalid object", numberOutOfRange = (entityName, val, min, max, choices) => choices ? numberOutOfRange(entityName, choices[val], choices[min], choices[max]) : invalidEntity(entityName, val) + `; must be between ${min}-${max}`, invalidEntity = (fieldName, val) => `Invalid ${fieldName}: ${val}`, missingField = fieldName => `Missing ${fieldName}`, forbiddenField = fieldName => `Invalid field ${fieldName}`, duplicateFields = fieldName => `Duplicate field ${fieldName}`, noValidFields = validFields => "No valid fields: " + validFields.join(), invalidChoice = (fieldName, val, choiceMap) => invalidEntity(fieldName, val) + "; must be " + Object.keys(choiceMap).join(), forbiddenEraParts = "Forbidden era/eraYear", mismatchingEraParts = "Mismatching era/eraYear", mismatchingYearAndEra = "Mismatching year/eraYear", invalidEra = era => `Invalid era: ${era}`, missingYear = allowEra => "Missing year" + (allowEra ? "/era/eraYear" : ""), invalidMonthCode = monthCode => `Invalid monthCode: ${monthCode}`, mismatchingMonthAndCode = "Mismatching month/monthCode", missingMonth = "Missing month/monthCode", invalidLeapMonth = "Invalid leap month", invalidProtocolResults = "Invalid protocol results", invalidCalendar = calendarId => invalidEntity("Calendar", calendarId), mismatchingCalendars = "Mismatching Calendars", invalidTimeZone = calendarId => invalidEntity("TimeZone", calendarId), mismatchingTimeZones = "Mismatching TimeZones", forbiddenIcuTimeZone = "Forbidden ICU TimeZone", outOfBoundsOffset = "Out-of-bounds offset", outOfBoundsDstGap = "Out-of-bounds TimeZone gap", invalidOffsetForTimeZone = "Invalid TimeZone offset", ambigOffset = "Ambiguous offset", outOfBoundsDate = "Out-of-bounds date", outOfBoundsDuration = "Out-of-bounds duration", forbiddenDurationSigns = "Cannot mix duration signs", invalidLargeUnits = "Cannot use large units", flippedSmallestLargestUnit = "smallestUnit > largestUnit", failedParse = s => `Cannot parse: ${s}`, invalidSubstring = substring => `Invalid substring: ${substring}`, invalidFormatType = branding => `Cannot format ${branding}`, forbiddenFormatTimeZone = "Cannot specify TimeZone", mapPropNamesToIndex = bindArgs(mapPropNames, ((_propVal, i) => i)), mapPropNamesToConstant = bindArgs(mapPropNames, ((_propVal, _i, constant) => constant)), padNumber2 = bindArgs(padNumber, 2), unitNameMap = {
+    nanosecond: 0,
+    microsecond: 1,
+    millisecond: 2,
+    second: 3,
+    minute: 4,
+    hour: 5,
+    day: 6,
+    week: 7,
+    month: 8,
+    year: 9
+  }, unitNamesAsc = Object.keys(unitNameMap), milliInDay = 864e5, milliInSec = 1e3, nanoInMicro = 1e3, nanoInMilli = 1e6, nanoInSec = 1e9, nanoInMinute = 6e10, nanoInHour = 36e11, nanoInUtcDay = 864e11, unitNanoMap = [ 1, nanoInMicro, nanoInMilli, nanoInSec, nanoInMinute, nanoInHour, nanoInUtcDay ], requireString = bindArgs(requireType, "string"), requireBoolean = bindArgs(requireType, "boolean"), requireNumber = bindArgs(requireType, "number"), durationFieldNamesAsc = unitNamesAsc.map((unitName => unitName + "s")), durationFieldNamesAlpha = sortStrings(durationFieldNamesAsc), durationTimeFieldNamesAsc = durationFieldNamesAsc.slice(0, 6), durationDateFieldNamesAsc = durationFieldNamesAsc.slice(6), durationCalendarFieldNamesAsc = durationDateFieldNamesAsc.slice(1), durationFieldIndexes = mapPropNamesToIndex(durationFieldNamesAsc), durationFieldDefaults = mapPropNamesToConstant(durationFieldNamesAsc, 0), durationTimeFieldDefaults = mapPropNamesToConstant(durationTimeFieldNamesAsc, 0), clearDurationFields = bindArgs(zeroOutProps, durationFieldNamesAsc), timeFieldNamesAsc = unitNamesAsc.slice(0, 6), timeFieldNamesAlpha = sortStrings(timeFieldNamesAsc), timeZoneFieldNames = [ "timeZone" ], timeAndOffsetFieldNames = [ ...timeFieldNamesAsc, "offset" ], timeAndZoneFieldNames = [ ...timeAndOffsetFieldNames, ...timeZoneFieldNames ], eraYearFieldNames = [ "era", "eraYear" ], allYearFieldNames = [ ...eraYearFieldNames, "year" ], yearFieldNames = [ "year" ], monthCodeFieldNames = [ "monthCode" ], monthFieldNames = [ "month", ...monthCodeFieldNames ], dayFieldNames = [ "day" ], yearMonthFieldNames = [ ...monthFieldNames, ...yearFieldNames ], yearMonthCodeFieldNames = [ ...monthCodeFieldNames, ...yearFieldNames ], dateFieldNamesAlpha = [ ...dayFieldNames, ...yearMonthFieldNames ], monthDayFieldNames = [ ...dayFieldNames, ...monthFieldNames ], monthCodeDayFieldNames = [ ...dayFieldNames, ...monthCodeFieldNames ], timeFieldDefaults = mapPropNamesToConstant(timeFieldNamesAsc, 0), isoCalendarId = "iso8601", gregoryCalendarId = "gregory", eraOriginsByCalendarId = {
+    [gregoryCalendarId]: {
+      "gregory-inverse": -1,
+      gregory: 0
+    },
+    japanese: {
+      "japanese-inverse": -1,
+      japanese: 0,
+      meiji: 1867,
+      taisho: 1911,
+      showa: 1925,
+      heisei: 1988,
+      reiwa: 2018
+    },
+    ethiopic: {
+      ethioaa: 0,
+      ethiopic: 5500
+    },
+    coptic: {
+      "coptic-inverse": -1,
+      coptic: 0
+    },
+    roc: {
+      "roc-inverse": -1,
+      roc: 0
+    },
+    buddhist: {
+      be: 0
+    },
+    islamic: {
+      ah: 0
+    },
+    indian: {
+      saka: 0
+    },
+    persian: {
+      ap: 0
+    }
+  }, eraRemapsByCalendarId = {
+    [gregoryCalendarId]: {
+      bce: "gregory-inverse",
+      ce: "gregory"
+    },
+    japanese: {
+      bce: "japanese-inverse",
+      ce: "japanese"
+    },
+    ethiopic: {
+      era0: "ethioaa",
+      era1: "ethiopic"
+    },
+    coptic: {
+      era0: "coptic-inverse",
+      era1: "coptic"
+    },
+    roc: {
+      broc: "roc-inverse",
+      minguo: "roc"
+    }
+  }, leapMonthMetas = {
+    chinese: 13,
+    dangi: 13,
+    hebrew: -6
+  }, isoTimeFieldNamesAsc = [ "isoNanosecond", "isoMicrosecond", "isoMillisecond", "isoSecond", "isoMinute", "isoHour" ], isoDateFieldNamesAsc = [ "isoDay", "isoMonth", "isoYear" ], isoDateTimeFieldNamesAsc = [ ...isoTimeFieldNamesAsc, ...isoDateFieldNamesAsc ], isoDateFieldNamesAlpha = sortStrings(isoDateFieldNamesAsc), isoTimeFieldNamesAlpha = sortStrings(isoTimeFieldNamesAsc), isoDateTimeFieldNamesAlpha = sortStrings(isoDateTimeFieldNamesAsc), isoTimeFieldDefaults = mapPropNamesToConstant(isoTimeFieldNamesAlpha, 0), clearIsoFields = bindArgs(zeroOutProps, isoDateTimeFieldNamesAsc), maxMilli = 1e8 * milliInDay, epochNanoMax = [ 1e8, 0 ], epochNanoMin = [ -1e8, 0 ], isoYearMax = 275760, isoYearMin = -271821, RawDateTimeFormat = Intl.DateTimeFormat, isoEpochOriginYear = 1970, isoEpochFirstLeapYear = 1972, isoMonthsInYear = 12, primaryJapaneseEraMilli = isoArgsToEpochMilli(1868, 9, 8), queryJapaneseEraParts = memoize((isoFields => {
+    const epochMilli = isoToEpochMilli(isoFields);
+    if (epochMilli < primaryJapaneseEraMilli) {
+      const {isoYear: isoYear} = isoFields;
+      return isoYear < 1 ? [ "japanese-inverse", 1 - isoYear ] : [ "japanese", isoYear ];
+    }
+    const intlParts = hashIntlFormatParts(queryCalendarIntlFormat("japanese"), epochMilli), {era: era, eraYear: eraYear} = parseIntlYear(intlParts, "japanese");
+    return [ era, eraYear ];
+  }), WeakMap), utcTimeZoneId = "UTC", periodDur = 5184e3, minPossibleTransition = isoArgsToEpochSec(1847), maxPossibleTransition = isoArgsToEpochSec(new Date(0).getUTCFullYear() + 10), queryIntlCalendar = memoize((calendarId => {
+    function epochMilliToIntlFields(epochMilli) {
+      return ((intlParts, calendarIdBase) => ({
+        ...parseIntlYear(intlParts, calendarIdBase),
+        monthString: intlParts.month,
+        day: parseInt(intlParts.day)
+      }))(hashIntlFormatParts(intlFormat, epochMilli), calendarIdBase);
+    }
+    const intlFormat = queryCalendarIntlFormat(calendarId), calendarIdBase = computeCalendarIdBase(calendarId);
+    return {
+      id: calendarId,
+      queryFields: createIntlFieldCache(epochMilliToIntlFields),
+      queryYearData: createIntlYearDataCache(epochMilliToIntlFields)
+    };
+  })), queryCalendarIntlFormat = memoize((id => new RawDateTimeFormat("en-GB", {
+    calendar: id,
+    timeZone: utcTimeZoneId,
+    era: "short",
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  }))), monthCodeRegExp = /^M(\d{2})(L?)$/, smallestUnitStr = "smallestUnit", roundingIncName = "roundingIncrement", subsecDigitsName = "fractionalSecondDigits", overflowMap = {
+    constrain: 0,
+    reject: 1
+  }, overflowMapNames = Object.keys(overflowMap), directionMap = {
+    previous: -1,
+    next: 1
+  }, refineSmallestUnit = bindArgs(refineUnitOption, smallestUnitStr), refineLargestUnit = bindArgs(refineUnitOption, "largestUnit"), refineTotalUnit = bindArgs(refineUnitOption, "unit"), refineOverflow = bindArgs(refineChoiceOption, "overflow", overflowMap), refineEpochDisambig = bindArgs(refineChoiceOption, "disambiguation", {
+    compatible: 0,
+    reject: 1,
+    earlier: 2,
+    later: 3
+  }), refineOffsetDisambig = bindArgs(refineChoiceOption, "offset", {
+    reject: 0,
+    use: 1,
+    prefer: 2,
+    ignore: 3
+  }), refineCalendarDisplay = bindArgs(refineChoiceOption, "calendarName", {
+    auto: 0,
+    never: 1,
+    critical: 2,
+    always: 3
+  }), refineTimeZoneDisplay = bindArgs(refineChoiceOption, "timeZoneName", {
+    auto: 0,
+    never: 1,
+    critical: 2
+  }), refineOffsetDisplay = bindArgs(refineChoiceOption, "offset", {
+    auto: 0,
+    never: 1
+  }), refineRoundingMode = bindArgs(refineChoiceOption, "roundingMode", {
+    floor: 0,
+    halfFloor: 1,
+    ceil: 2,
+    halfCeil: 3,
+    trunc: 4,
+    halfTrunc: 5,
+    expand: 6,
+    halfExpand: 7,
+    halfEven: 8
+  }), PlainYearMonthBranding = "PlainYearMonth", PlainMonthDayBranding = "PlainMonthDay", PlainDateBranding = "PlainDate", PlainDateTimeBranding = "PlainDateTime", PlainTimeBranding = "PlainTime", ZonedDateTimeBranding = "ZonedDateTime", InstantBranding = "Instant", DurationBranding = "Duration", roundingModeFuncs = [ Math.floor, num => hasHalf(num) ? Math.floor(num) : Math.round(num), Math.ceil, num => hasHalf(num) ? Math.ceil(num) : Math.round(num), Math.trunc, num => hasHalf(num) ? Math.trunc(num) || 0 : Math.round(num), num => num < 0 ? Math.floor(num) : Math.ceil(num), num => Math.sign(num) * Math.round(Math.abs(num)) || 0, num => hasHalf(num) ? (num = Math.trunc(num) || 0) + num % 2 : Math.round(num) ], trailingZerosRE = /0+$/, zonedEpochSlotsToIso = memoize(((slots, getTimeZoneOps) => {
+    const {epochNanoseconds: epochNanoseconds} = slots, offsetNanoseconds = (getTimeZoneOps.getOffsetNanosecondsFor ? getTimeZoneOps : getTimeZoneOps(slots.timeZone)).getOffsetNanosecondsFor(epochNanoseconds), isoDateTimeFields = epochNanoToIso(epochNanoseconds, offsetNanoseconds);
+    return {
+      calendar: slots.calendar,
+      ...isoDateTimeFields,
+      offsetNanoseconds: offsetNanoseconds
+    };
+  }), WeakMap), maxCalendarUnit = 2 ** 32 - 1, queryNativeTimeZone = memoize((timeZoneId => {
+    const essence = getTimeZoneEssence(timeZoneId);
+    return "object" == typeof essence ? new IntlTimeZone(essence) : new FixedTimeZone(essence || 0);
+  }));
+  class FixedTimeZone {
+    constructor(offsetNano) {
+      this.offsetNano = offsetNano;
+    }
+    getOffsetNanosecondsFor() {
+      return this.offsetNano;
+    }
+    getPossibleInstantsFor(isoDateTimeFields) {
+      return (isoFields => {
+        const bigNano = isoToEpochNano({
+          ...isoFields,
+          ...isoTimeFieldDefaults
+        });
+        if (!bigNano || Math.abs(bigNano[0]) > 1e8) {
+          throw new RangeError(outOfBoundsDate);
+        }
+      })(isoDateTimeFields), [ isoToEpochNanoWithOffset(isoDateTimeFields, this.offsetNano) ];
+    }
+    getTransition() {}
+  }
+  class IntlTimeZone {
+    constructor(format) {
+      this.tzStore = (computeOffsetSec => {
+        function getOffsetSec(epochSec) {
+          const clampedEpochSec = clampNumber(epochSec, minTransition, maxTransition), [startEpochSec, endEpochSec] = computePeriod(clampedEpochSec), startOffsetSec = getSample(startEpochSec), endOffsetSec = getSample(endEpochSec);
+          return startOffsetSec === endOffsetSec ? startOffsetSec : pinch(getSplit(startEpochSec, endEpochSec), startOffsetSec, endOffsetSec, epochSec);
+        }
+        function pinch(split, startOffsetSec, endOffsetSec, forEpochSec) {
+          let offsetSec, splitDurSec;
+          for (;(void 0 === forEpochSec || void 0 === (offsetSec = forEpochSec < split[0] ? startOffsetSec : forEpochSec >= split[1] ? endOffsetSec : void 0)) && (splitDurSec = split[1] - split[0]); ) {
+            const middleEpochSec = split[0] + Math.floor(splitDurSec / 2);
+            computeOffsetSec(middleEpochSec) === endOffsetSec ? split[1] = middleEpochSec : split[0] = middleEpochSec + 1;
+          }
+          return offsetSec;
+        }
+        const getSample = memoize(computeOffsetSec), getSplit = memoize(createSplitTuple);
+        let minTransition = minPossibleTransition, maxTransition = maxPossibleTransition;
+        return {
+          getPossibleEpochSec(zonedEpochSec) {
+            const wideOffsetSec0 = getOffsetSec(zonedEpochSec - 86400), wideOffsetSec1 = getOffsetSec(zonedEpochSec + 86400), wideUtcEpochSec0 = zonedEpochSec - wideOffsetSec0, wideUtcEpochSec1 = zonedEpochSec - wideOffsetSec1;
+            if (wideOffsetSec0 === wideOffsetSec1) {
+              return [ wideUtcEpochSec0 ];
+            }
+            const narrowOffsetSec0 = getOffsetSec(wideUtcEpochSec0);
+            return narrowOffsetSec0 === getOffsetSec(wideUtcEpochSec1) ? [ zonedEpochSec - narrowOffsetSec0 ] : wideOffsetSec0 > wideOffsetSec1 ? [ wideUtcEpochSec0, wideUtcEpochSec1 ] : [];
+          },
+          getOffsetSec: getOffsetSec,
+          getTransition(epochSec, direction) {
+            const clampedEpochSec = clampNumber(epochSec, minTransition, maxTransition);
+            let [startEpochSec, endEpochSec] = computePeriod(clampedEpochSec);
+            const inc = periodDur * direction, inBounds = direction < 0 ? () => endEpochSec > minTransition || (minTransition = clampedEpochSec, 
+            0) : () => startEpochSec < maxTransition || (maxTransition = clampedEpochSec, 0);
+            for (;inBounds(); ) {
+              const startOffsetSec = getSample(startEpochSec), endOffsetSec = getSample(endEpochSec);
+              if (startOffsetSec !== endOffsetSec) {
+                const split = getSplit(startEpochSec, endEpochSec);
+                pinch(split, startOffsetSec, endOffsetSec);
+                const transitionEpochSec = split[0];
+                if ((compareNumbers(transitionEpochSec, epochSec) || 1) === direction) {
+                  return transitionEpochSec;
+                }
+              }
+              startEpochSec += inc, endEpochSec += inc;
+            }
+          }
+        };
+      })((format => epochSec => {
+        const intlParts = hashIntlFormatParts(format, epochSec * milliInSec);
+        return isoArgsToEpochSec(parseIntlPartsYear(intlParts), parseInt(intlParts.month), parseInt(intlParts.day), parseInt(intlParts.hour), parseInt(intlParts.minute), parseInt(intlParts.second)) - epochSec;
+      })(format));
+    }
+    getOffsetNanosecondsFor(epochNano) {
+      return this.tzStore.getOffsetSec((epochNano => epochNanoToSecMod(epochNano)[0])(epochNano)) * nanoInSec;
+    }
+    getPossibleInstantsFor(isoFields) {
+      const [zonedEpochSec, subsecNano] = [ isoArgsToEpochSec((isoDateTimeFields = isoFields).isoYear, isoDateTimeFields.isoMonth, isoDateTimeFields.isoDay, isoDateTimeFields.isoHour, isoDateTimeFields.isoMinute, isoDateTimeFields.isoSecond), isoDateTimeFields.isoMillisecond * nanoInMilli + isoDateTimeFields.isoMicrosecond * nanoInMicro + isoDateTimeFields.isoNanosecond ];
+      var isoDateTimeFields;
+      return this.tzStore.getPossibleEpochSec(zonedEpochSec).map((epochSec => checkEpochNanoInBounds(moveBigNano(numberToBigNano(epochSec, nanoInSec), subsecNano))));
+    }
+    getTransition(epochNano, direction) {
+      const [epochSec, subsecNano] = epochNanoToSecMod(epochNano), resEpochSec = this.tzStore.getTransition(epochSec + (direction > 0 || subsecNano ? 1 : 0), direction);
+      if (void 0 !== resEpochSec) {
+        return numberToBigNano(resEpochSec, nanoInSec);
+      }
+    }
+  }
+  const timeRegExpStr = "(\\d{2})(?::?(\\d{2})(?::?(\\d{2})(?:[.,](\\d{1,9}))?)?)?", offsetRegExpStr = "([+-])" + timeRegExpStr, dateTimeRegExpStr = "(?:(?:([+-])(\\d{6}))|(\\d{4}))-?(\\d{2})-?(\\d{2})(?:[T ]" + timeRegExpStr + "(Z|" + offsetRegExpStr + ")?)?", yearMonthRegExp = createRegExp("(?:(?:([+-])(\\d{6}))|(\\d{4}))-?(\\d{2})((?:\\[(!?)([^\\]]*)\\]){0,9})"), monthDayRegExp = createRegExp("(?:--)?(\\d{2})-?(\\d{2})((?:\\[(!?)([^\\]]*)\\]){0,9})"), dateTimeRegExp = createRegExp(dateTimeRegExpStr + "((?:\\[(!?)([^\\]]*)\\]){0,9})"), timeRegExp = createRegExp("T?" + timeRegExpStr + "(?:" + offsetRegExpStr + ")?((?:\\[(!?)([^\\]]*)\\]){0,9})"), offsetRegExp = createRegExp(offsetRegExpStr), annotationRegExp = new RegExp("\\[(!?)([^\\]]*)\\]", "g"), durationRegExp = createRegExp("([+-])?P(\\d+Y)?(\\d+M)?(\\d+W)?(\\d+D)?(?:T(?:(\\d+)(?:[.,](\\d{1,9}))?H)?(?:(\\d+)(?:[.,](\\d{1,9}))?M)?(?:(\\d+)(?:[.,](\\d{1,9}))?S)?)?"), queryTimeZoneIntlFormat = memoize((id => new RawDateTimeFormat("en-GB", {
+    timeZone: id,
+    era: "short",
+    year: "numeric",
+    month: "numeric",
+    day: "numeric",
+    hour: "numeric",
+    minute: "numeric",
+    second: "numeric"
+  }))), icuRegExp = /^(AC|AE|AG|AR|AS|BE|BS|CA|CN|CS|CT|EA|EC|IE|IS|JS|MI|NE|NS|PL|PN|PR|PS|SS|VS)T$/, badCharactersRegExp = /[^\w\/:+-]+/, nativeStandardBase = {
+    dateAdd(isoDateFields, durationFields, options) {
+      const overflow = refineOverflowOptions(options);
+      let epochMilli, {years: years, months: months, weeks: weeks, days: days} = durationFields;
+      if (days += durationFieldsToBigNano(durationFields, 5)[0], years || months) {
+        epochMilli = ((moveOps, isoDateFields, years, months, overflow) => {
+          let [year, month, day] = moveOps.dateParts(isoDateFields);
+          if (years) {
+            const [monthCodeNumber, isLeapMonth] = moveOps.monthCodeParts(year, month);
+            year += years, month = monthCodeNumberToMonth(monthCodeNumber, isLeapMonth, moveOps.leapMonth(year)), 
+            month = clampEntity("month", month, 1, moveOps.monthsInYearPart(year), overflow);
+          }
+          return months && ([year, month] = moveOps.monthAdd(year, month, months)), day = clampEntity("day", day, 1, moveOps.daysInMonthParts(year, month), overflow), 
+          moveOps.epochMilli(year, month, day);
+        })(this, isoDateFields, years, months, overflow);
+      } else {
+        if (!weeks && !days) {
+          return isoDateFields;
+        }
+        epochMilli = isoToEpochMilli(isoDateFields);
+      }
+      if (void 0 === epochMilli) {
+        throw new RangeError(outOfBoundsDate);
+      }
+      return epochMilli += (7 * weeks + days) * milliInDay, checkIsoDateInBounds(epochMilliToIso(epochMilli));
+    },
+    dateUntil(startIsoFields, endIsoFields, largestUnit) {
+      if (largestUnit <= 7) {
+        let weeks = 0, days = diffDays({
+          ...startIsoFields,
+          ...isoTimeFieldDefaults
+        }, {
+          ...endIsoFields,
+          ...isoTimeFieldDefaults
+        });
+        return 7 === largestUnit && ([weeks, days] = divModTrunc(days, 7)), {
+          ...durationFieldDefaults,
+          weeks: weeks,
+          days: days
+        };
+      }
+      const yearMonthDayStart = this.dateParts(startIsoFields), yearMonthDayEnd = this.dateParts(endIsoFields);
+      let [years, months, days] = ((calendarNative, year0, month0, day0, year1, month1, day1) => {
+        let yearDiff = year1 - year0, monthDiff = month1 - month0, dayDiff = day1 - day0;
+        if (yearDiff || monthDiff) {
+          const sign = Math.sign(yearDiff || monthDiff);
+          let daysInMonth1 = calendarNative.daysInMonthParts(year1, month1), dayCorrect = 0;
+          if (Math.sign(dayDiff) === -sign) {
+            const origDaysInMonth1 = daysInMonth1;
+            [year1, month1] = calendarNative.monthAdd(year1, month1, -sign), yearDiff = year1 - year0, 
+            monthDiff = month1 - month0, daysInMonth1 = calendarNative.daysInMonthParts(year1, month1), 
+            dayCorrect = sign < 0 ? -origDaysInMonth1 : daysInMonth1;
+          }
+          if (dayDiff = day1 - Math.min(day0, daysInMonth1) + dayCorrect, yearDiff) {
+            const [monthCodeNumber0, isLeapYear0] = calendarNative.monthCodeParts(year0, month0), [monthCodeNumber1, isLeapYear1] = calendarNative.monthCodeParts(year1, month1);
+            if (monthDiff = monthCodeNumber1 - monthCodeNumber0 || Number(isLeapYear1) - Number(isLeapYear0), 
+            Math.sign(monthDiff) === -sign) {
+              const monthCorrect = sign < 0 && -calendarNative.monthsInYearPart(year1);
+              yearDiff = (year1 -= sign) - year0, monthDiff = month1 - monthCodeNumberToMonth(monthCodeNumber0, isLeapYear0, calendarNative.leapMonth(year1)) + (monthCorrect || calendarNative.monthsInYearPart(year1));
+            }
+          }
+        }
+        return [ yearDiff, monthDiff, dayDiff ];
+      })(this, ...yearMonthDayStart, ...yearMonthDayEnd);
+      return 8 === largestUnit && (months += this.monthsInYearSpan(years, yearMonthDayStart[0]), 
+      years = 0), {
+        ...durationFieldDefaults,
+        years: years,
+        months: months,
+        days: days
+      };
+    },
+    dateFromFields(fields, options) {
+      const overflow = refineOverflowOptions(options), year = refineYear(this, fields), month = refineMonth(this, fields, year, overflow), day = refineDay(this, fields, month, year, overflow);
+      return createPlainDateSlots(checkIsoDateInBounds(this.isoFields(year, month, day)), this.id || isoCalendarId);
+    },
+    yearMonthFromFields(fields, options) {
+      const overflow = refineOverflowOptions(options), year = refineYear(this, fields), month = refineMonth(this, fields, year, overflow);
+      return createPlainYearMonthSlots(checkIsoYearMonthInBounds(this.isoFields(year, month, 1)), this.id || isoCalendarId);
+    },
+    monthDayFromFields(fields, options) {
+      const overflow = refineOverflowOptions(options);
+      let day, monthCodeNumber, isLeapMonth, yearMaybe = void 0 !== fields.eraYear || void 0 !== fields.year ? refineYear(this, fields) : void 0;
+      const isIso = !this.id;
+      if (void 0 === yearMaybe && isIso && (yearMaybe = isoEpochFirstLeapYear), void 0 !== yearMaybe) {
+        const month = refineMonth(this, fields, yearMaybe, overflow);
+        day = refineDay(this, fields, month, yearMaybe, overflow);
+        const leapMonth = this.leapMonth(yearMaybe);
+        monthCodeNumber = monthToMonthCodeNumber(month, leapMonth), isLeapMonth = month === leapMonth;
+      } else {
+        if (void 0 === fields.monthCode) {
+          throw new TypeError(missingMonth);
+        }
+        if ([monthCodeNumber, isLeapMonth] = parseMonthCode(fields.monthCode), this.id && this.id !== gregoryCalendarId && "japanese" !== this.id) {
+          if (this.id && "coptic" === computeCalendarIdBase(this.id) && 0 === overflow) {
+            const maxLengthOfMonthCodeInAnyYear = isLeapMonth || 13 !== monthCodeNumber ? 30 : 6;
+            day = fields.day, day = clampNumber(day, 1, maxLengthOfMonthCodeInAnyYear);
+          } else if (this.id && "chinese" === computeCalendarIdBase(this.id) && 0 === overflow) {
+            const maxLengthOfMonthCodeInAnyYear = !isLeapMonth || 1 !== monthCodeNumber && 9 !== monthCodeNumber && 10 !== monthCodeNumber && 11 !== monthCodeNumber && 12 !== monthCodeNumber ? 30 : 29;
+            day = fields.day, day = clampNumber(day, 1, maxLengthOfMonthCodeInAnyYear);
+          } else {
+            day = fields.day;
+          }
+        } else {
+          day = refineDay(this, fields, refineMonth(this, fields, isoEpochFirstLeapYear, overflow), isoEpochFirstLeapYear, overflow);
+        }
+      }
+      const res = this.yearMonthForMonthDay(monthCodeNumber, isLeapMonth, day);
+      if (!res) {
+        throw new RangeError("Cannot guess year");
+      }
+      const [finalYear, finalMonth] = res;
+      return createPlainMonthDaySlots(checkIsoDateInBounds(this.isoFields(finalYear, finalMonth, day)), this.id || isoCalendarId);
+    },
+    fields(fieldNames) {
+      return getCalendarEraOrigins(this) && fieldNames.includes("year") ? [ ...fieldNames, ...eraYearFieldNames ] : fieldNames;
+    },
+    mergeFields(baseFields, additionalFields) {
+      const merged = Object.assign(Object.create(null), baseFields);
+      return spliceFields(merged, additionalFields, monthFieldNames), getCalendarEraOrigins(this) && (spliceFields(merged, additionalFields, allYearFieldNames), 
+      "japanese" === this.id && spliceFields(merged, additionalFields, monthDayFieldNames, eraYearFieldNames)), 
+      merged;
+    },
+    inLeapYear(isoFields) {
+      const [year] = this.dateParts(isoFields);
+      return this.inLeapYearPart(year);
+    },
+    monthsInYear(isoFields) {
+      const [year] = this.dateParts(isoFields);
+      return this.monthsInYearPart(year);
+    },
+    daysInMonth(isoFields) {
+      const [year, month] = this.dateParts(isoFields);
+      return this.daysInMonthParts(year, month);
+    },
+    daysInYear(isoFields) {
+      const [year] = this.dateParts(isoFields);
+      return this.daysInYearPart(year);
+    },
+    dayOfYear: computeNativeDayOfYear,
+    era(isoFields) {
+      return this.eraParts(isoFields)[0];
+    },
+    eraYear(isoFields) {
+      return this.eraParts(isoFields)[1];
+    },
+    monthCode(isoFields) {
+      const [year, month] = this.dateParts(isoFields), [monthCodeNumber, isLeapMonth] = this.monthCodeParts(year, month);
+      return formatMonthCode(monthCodeNumber, isLeapMonth);
+    },
+    dayOfWeek: computeIsoDayOfWeek,
+    daysInWeek() {
+      return 7;
+    }
+  }, isoPartOps = {
+    dateParts: computeIsoDateParts,
+    eraParts: computeIsoEraParts,
+    monthCodeParts: computeIsoMonthCodeParts
+  }, isoWeekOps = {
+    dayOfYear: computeNativeDayOfYear,
+    dateParts: computeIsoDateParts,
+    epochMilli: isoArgsToEpochMilli,
+    weekOfYear: computeNativeWeekOfYear,
+    yearOfWeek: computeNativeYearOfWeek,
+    weekParts(isoDateFields) {
+      function computeWeekShift(yDayOfWeek) {
+        return (7 - yDayOfWeek < minDaysInWeek ? 7 : 0) - yDayOfWeek;
+      }
+      function computeWeeksInYear(delta) {
+        const daysInYear = computeIsoDaysInYear(yearOfWeek + delta), sign = delta || 1, y1WeekShift = computeWeekShift(modFloor(y0DayOfWeek + daysInYear * sign, 7));
+        return weeksInYear = (daysInYear + (y1WeekShift - y0WeekShift) * sign) / 7;
+      }
+      const minDaysInWeek = this.id ? 1 : 4, isoDayOfWeek = computeIsoDayOfWeek(isoDateFields), isoDayOfYear = this.dayOfYear(isoDateFields), dayOfWeek = modFloor(isoDayOfWeek - 1, 7), dayOfYear = isoDayOfYear - 1, y0DayOfWeek = modFloor(dayOfWeek - dayOfYear, 7), y0WeekShift = computeWeekShift(y0DayOfWeek);
+      let weeksInYear, weekOfYear = Math.floor((dayOfYear - y0WeekShift) / 7) + 1, yearOfWeek = isoDateFields.isoYear;
+      return weekOfYear ? weekOfYear > computeWeeksInYear(0) && (weekOfYear = 1, yearOfWeek++) : (weekOfYear = computeWeeksInYear(-1), 
+      yearOfWeek--), [ weekOfYear, yearOfWeek, weeksInYear ];
+    }
+  }, isoStandardOps = {
+    ...nativeStandardBase,
+    ...isoWeekOps,
+    dateParts: computeIsoDateParts,
+    eraParts: computeIsoEraParts,
+    monthCodeParts: computeIsoMonthCodeParts,
+    yearMonthForMonthDay(monthCodeNumber, isLeapMonth) {
+      if (!isLeapMonth) {
+        return [ isoEpochFirstLeapYear, monthCodeNumber ];
+      }
+    },
+    inLeapYearPart: computeIsoInLeapYear,
+    leapMonth() {},
+    monthsInYearPart: computeIsoMonthsInYear,
+    monthsInYearSpan: yearDelta => yearDelta * isoMonthsInYear,
+    daysInMonthParts: computeIsoDaysInMonth,
+    daysInYearPart: computeIsoDaysInYear,
+    isoFields(year, month, day) {
+      return {
+        isoYear: year,
+        isoMonth: month,
+        isoDay: day
+      };
+    },
+    epochMilli: isoArgsToEpochMilli,
+    monthAdd(year, month, monthDelta) {
+      return year += divTrunc(monthDelta, isoMonthsInYear), (month += modTrunc(monthDelta, isoMonthsInYear)) < 1 ? (year--, 
+      month += isoMonthsInYear) : month > isoMonthsInYear && (year++, month -= isoMonthsInYear), 
+      [ year, month ];
+    },
+    year(isoFields) {
+      return isoFields.isoYear;
+    },
+    month(isoFields) {
+      return isoFields.isoMonth;
+    },
+    day: isoFields => isoFields.isoDay
+  }, intlPartOps = {
+    dateParts: computeIntlDateParts,
+    eraParts: computeIntlEraParts,
+    monthCodeParts: computeIntlMonthCodeParts
+  }, intlWeekOps = {
+    dayOfYear: computeNativeDayOfYear,
+    dateParts: computeIntlDateParts,
+    epochMilli: computeIntlEpochMilli,
+    weekOfYear: computeNativeWeekOfYear,
+    yearOfWeek: computeNativeYearOfWeek,
+    weekParts() {
+      return [];
+    }
+  }, intlStandardOps = {
+    ...nativeStandardBase,
+    ...intlWeekOps,
+    dateParts: computeIntlDateParts,
+    eraParts: computeIntlEraParts,
+    monthCodeParts: computeIntlMonthCodeParts,
+    yearMonthForMonthDay(monthCodeNumber, isLeapMonth, day) {
+      const startIsoYear = this.id && "chinese" === computeCalendarIdBase(this.id) ? ((monthCodeNumber, isLeapMonth, day) => {
+        if (isLeapMonth) {
+          switch (monthCodeNumber) {
+           case 1:
+            return 1651;
+
+           case 2:
+            return day < 30 ? 1947 : 1765;
+
+           case 3:
+            return day < 30 ? 1966 : 1955;
+
+           case 4:
+            return day < 30 ? 1963 : 1944;
+
+           case 5:
+            return day < 30 ? 1971 : 1952;
+
+           case 6:
+            return day < 30 ? 1960 : 1941;
+
+           case 7:
+            return day < 30 ? 1968 : 1938;
+
+           case 8:
+            return day < 30 ? 1957 : 1718;
+
+           case 9:
+            return 1832;
+
+           case 10:
+            return 1870;
+
+           case 11:
+            return 1814;
+
+           case 12:
+            return 1890;
+          }
+        }
+        return 1972;
+      })(monthCodeNumber, isLeapMonth, day) : isoEpochFirstLeapYear;
+      let [startYear, startMonth, startDay] = computeIntlDateParts.call(this, {
+        isoYear: startIsoYear,
+        isoMonth: isoMonthsInYear,
+        isoDay: 31
+      });
+      const startYearLeapMonth = computeIntlLeapMonth.call(this, startYear), startMonthIsLeap = startMonth === startYearLeapMonth;
+      1 === (compareNumbers(monthCodeNumber, monthToMonthCodeNumber(startMonth, startYearLeapMonth)) || compareNumbers(Number(isLeapMonth), Number(startMonthIsLeap)) || compareNumbers(day, startDay)) && startYear--;
+      for (let yearMove = 0; yearMove < 100; yearMove++) {
+        const tryYear = startYear - yearMove, tryLeapMonth = computeIntlLeapMonth.call(this, tryYear), tryMonth = monthCodeNumberToMonth(monthCodeNumber, isLeapMonth, tryLeapMonth);
+        if (isLeapMonth === (tryMonth === tryLeapMonth) && day <= computeIntlDaysInMonth.call(this, tryYear, tryMonth)) {
+          return [ tryYear, tryMonth ];
+        }
+      }
+    },
+    inLeapYearPart(year) {
+      const days = computeIntlDaysInYear.call(this, year);
+      return days > computeIntlDaysInYear.call(this, year - 1) && days > computeIntlDaysInYear.call(this, year + 1);
+    },
+    leapMonth: computeIntlLeapMonth,
+    monthsInYearPart: computeIntlMonthsInYear,
+    monthsInYearSpan(yearDelta, yearStart) {
+      const yearEnd = yearStart + yearDelta, yearSign = Math.sign(yearDelta), yearCorrection = yearSign < 0 ? -1 : 0;
+      let months = 0;
+      for (let year = yearStart; year !== yearEnd; year += yearSign) {
+        months += computeIntlMonthsInYear.call(this, year + yearCorrection);
+      }
+      return months;
+    },
+    daysInMonthParts: computeIntlDaysInMonth,
+    daysInYearPart: computeIntlDaysInYear,
+    isoFields(year, month, day) {
+      return epochMilliToIso(computeIntlEpochMilli.call(this, year, month, day));
+    },
+    epochMilli: computeIntlEpochMilli,
+    monthAdd(year, month, monthDelta) {
+      if (monthDelta) {
+        if (month += monthDelta, !Number.isSafeInteger(month)) {
+          throw new RangeError(outOfBoundsDate);
+        }
+        if (monthDelta < 0) {
+          for (;month < 1; ) {
+            month += computeIntlMonthsInYear.call(this, --year);
+          }
+        } else {
+          let monthsInYear;
+          for (;month > (monthsInYear = computeIntlMonthsInYear.call(this, year)); ) {
+            month -= monthsInYear, year++;
+          }
+        }
+      }
+      return [ year, month ];
+    },
+    year(isoFields) {
+      return this.queryFields(isoFields).year;
+    },
+    month(isoFields) {
+      const {year: year, monthString: monthString} = this.queryFields(isoFields), {monthStringToIndex: monthStringToIndex} = this.queryYearData(year);
+      return monthStringToIndex[monthString] + 1;
+    },
+    day(isoFields) {
+      return this.queryFields(isoFields).day;
+    }
+  }, createNativePartOps = createNativeOpsCreator(isoPartOps, intlPartOps), createNativeStandardOps = createNativeOpsCreator(isoStandardOps, intlStandardOps), builtinRefiners = {
+    ...{
+      era: toStringViaPrimitive,
+      eraYear: toInteger,
+      year: toInteger,
+      month: toPositiveInteger,
+      monthCode(monthCode) {
+        const s = toStringViaPrimitive(monthCode);
+        return parseMonthCode(s), s;
+      },
+      day: toPositiveInteger
+    },
+    ...mapPropNamesToConstant(timeFieldNamesAsc, toInteger),
+    ...mapPropNamesToConstant(durationFieldNamesAsc, toStrictInteger),
+    offset(offsetString) {
+      const s = toStringViaPrimitive(offsetString);
+      return parseOffsetNano(s), s;
+    }
+  }, timeFieldsToIso = bindArgs(remapProps, timeFieldNamesAsc, isoTimeFieldNamesAsc), isoTimeFieldsToCal = bindArgs(remapProps, isoTimeFieldNamesAsc, timeFieldNamesAsc), slotsMap = new WeakMap, getSlots = slotsMap.get.bind(slotsMap), setSlots = slotsMap.set.bind(slotsMap), yearMonthOnlyRefiners = {
+    era(input) {
+      if (void 0 !== input) {
+        return requireString(input);
+      }
+    },
+    eraYear: requireIntegerOrUndefined,
+    year: requireInteger,
+    month: requirePositiveInteger,
+    daysInMonth: requirePositiveInteger,
+    daysInYear: requirePositiveInteger,
+    inLeapYear: requireBoolean,
+    monthsInYear: requirePositiveInteger
+  }, monthOnlyRefiners = {
+    monthCode: requireString
+  }, dayOnlyRefiners = {
+    day: requirePositiveInteger
+  }, dateOnlyRefiners = {
+    dayOfWeek: requirePositiveInteger,
+    dayOfYear: requirePositiveInteger,
+    weekOfYear(input) {
+      if (void 0 !== input) {
+        return requirePositiveInteger(input);
+      }
+    },
+    yearOfWeek: requireIntegerOrUndefined,
+    daysInWeek: requirePositiveInteger
+  }, dateGetters = createCalendarGetters({
+    ...yearMonthOnlyRefiners,
+    ...monthOnlyRefiners,
+    ...dayOnlyRefiners,
+    ...dateOnlyRefiners
+  }), yearMonthGetters = createCalendarGetters({
+    ...yearMonthOnlyRefiners,
+    ...monthOnlyRefiners
+  }), monthDayGetters = createCalendarGetters({
+    ...monthOnlyRefiners,
+    ...dayOnlyRefiners
+  }), calendarIdGetters = {
+    calendarId: slots => slots.calendar
+  }, durationGetters = mapPropNames((propName => slots => slots[propName]), durationFieldNamesAsc.concat("sign")), timeGetters = mapPropNames(((_name, i) => slots => slots[isoTimeFieldNamesAsc[i]]), timeFieldNamesAsc), epochGetters = {
+    epochMilliseconds: getEpochMilli,
+    epochNanoseconds(slots) {
+      return ((bigNano, divisorNano = 1) => {
+        const [days, timeNano] = bigNano, whole = Math.floor(timeNano / divisorNano), wholeInDay = nanoInUtcDay / divisorNano;
+        return BigInt(days) * BigInt(wholeInDay) + BigInt(whole);
+      })(slots.epochNanoseconds);
+    }
+  }, [Duration, createDuration, getDurationSlots] = createSlotClass(DurationBranding, ((years = 0, months = 0, weeks = 0, days = 0, hours = 0, minutes = 0, seconds = 0, milliseconds = 0, microseconds = 0, nanoseconds = 0) => createDurationSlots(checkDurationUnits(mapProps(toStrictInteger, zipProps(durationFieldNamesAsc, [ years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds ]))))), {
+    ...durationGetters,
+    blank(slots) {
+      return !slots.sign;
+    }
+  }, {
+    with: (slots, mod) => createDuration(((slots, fields) => {
+      return createDurationSlots((initialFields = slots, modFields = fields, checkDurationUnits({
+        ...initialFields,
+        ...refineFields(modFields, durationFieldNamesAlpha)
+      })));
+      var initialFields, modFields;
+    })(slots, mod)),
+    negated: slots => createDuration(negateDuration(slots)),
+    abs: slots => createDuration((slots => -1 === slots.sign ? negateDuration(slots) : slots)(slots)),
+    add: (slots, otherArg, options) => createDuration(addDurations(refinePublicRelativeTo, createNativeStandardOps, queryNativeTimeZone, 0, slots, toDurationSlots(otherArg), options)),
+    subtract: (slots, otherArg, options) => createDuration(addDurations(refinePublicRelativeTo, createNativeStandardOps, queryNativeTimeZone, 1, slots, toDurationSlots(otherArg), options)),
+    round: (slots, options) => createDuration(((refineRelativeTo, getCalendarOps, getTimeZoneOps, slots, options) => {
+      const durationLargestUnit = getMaxDurationUnit(slots), [largestUnit, smallestUnit, roundingInc, roundingMode, relativeToSlots] = ((options, defaultLargestUnit, refineRelativeTo) => {
+        options = normalizeOptionsOrString(options, smallestUnitStr);
+        let largestUnit = refineLargestUnit(options);
+        const relativeToInternals = refineRelativeTo(options.relativeTo);
+        let roundingInc = parseRoundingIncInteger(options);
+        const roundingMode = refineRoundingMode(options, 7);
+        let smallestUnit = refineSmallestUnit(options);
+        if (void 0 === largestUnit && void 0 === smallestUnit) {
+          throw new RangeError("Required smallestUnit or largestUnit");
+        }
+        if (null == smallestUnit && (smallestUnit = 0), null == largestUnit && (largestUnit = Math.max(smallestUnit, defaultLargestUnit)), 
+        checkLargestSmallestUnit(largestUnit, smallestUnit), roundingInc = refineRoundingInc(roundingInc, smallestUnit, 1), 
+        roundingInc > 1 && smallestUnit > 5 && largestUnit !== smallestUnit) {
+          throw new RangeError("For calendar units with roundingIncrement > 1, use largestUnit = smallestUnit");
+        }
+        return [ largestUnit, smallestUnit, roundingInc, roundingMode, relativeToInternals ];
+      })(options, durationLargestUnit, refineRelativeTo), maxUnit = Math.max(durationLargestUnit, largestUnit);
+      if (!relativeToSlots && maxUnit <= 6) {
+        return createDurationSlots(checkDurationUnits(((durationFields, largestUnit, smallestUnit, roundingInc, roundingMode) => {
+          const roundedBigNano = roundBigNano(durationFieldsToBigNano(durationFields), smallestUnit, roundingInc, roundingMode);
+          return {
+            ...durationFieldDefaults,
+            ...nanoToDurationDayTimeFields(roundedBigNano, largestUnit)
+          };
+        })(slots, largestUnit, smallestUnit, roundingInc, roundingMode)));
+      }
+      if (!isZonedEpochSlots(relativeToSlots) && !slots.sign) {
+        return slots;
+      }
+      if (!relativeToSlots) {
+        throw new RangeError("Missing relativeTo");
+      }
+      const [marker, calendarOps, timeZoneOps] = createMarkerSystem(getCalendarOps, getTimeZoneOps, relativeToSlots), markerToEpochNano = createMarkerToEpochNano(timeZoneOps), moveMarker = createMoveMarker(timeZoneOps), diffMarkers = createDiffMarkers(timeZoneOps), endMarker = moveMarker(calendarOps, marker, slots);
+      isZonedEpochSlots(relativeToSlots) || (checkIsoDateTimeInBounds(marker), checkIsoDateTimeInBounds(endMarker));
+      let balancedDuration = diffMarkers(calendarOps, marker, endMarker, largestUnit);
+      const origSign = slots.sign, balancedSign = computeDurationSign(balancedDuration);
+      if (origSign && balancedSign && origSign !== balancedSign) {
+        throw new RangeError(invalidProtocolResults);
+      }
+      return balancedDuration = roundRelativeDuration(balancedDuration, markerToEpochNano(endMarker), largestUnit, smallestUnit, roundingInc, roundingMode, calendarOps, marker, markerToEpochNano, moveMarker), 
+      createDurationSlots(balancedDuration);
+    })(refinePublicRelativeTo, createNativeStandardOps, queryNativeTimeZone, slots, options)),
+    total: (slots, options) => ((refineRelativeTo, getCalendarOps, getTimeZoneOps, slots, options) => {
+      const maxDurationUnit = getMaxDurationUnit(slots), [totalUnit, relativeToSlots] = ((options, refineRelativeTo) => {
+        const relativeToInternals = refineRelativeTo((options = normalizeOptionsOrString(options, "unit")).relativeTo);
+        let totalUnit = refineTotalUnit(options);
+        return totalUnit = requirePropDefined("unit", totalUnit), [ totalUnit, relativeToInternals ];
+      })(options, refineRelativeTo), maxUnit = Math.max(totalUnit, maxDurationUnit);
+      if (!relativeToSlots && isUniformUnit(maxUnit, relativeToSlots)) {
+        return totalDayTimeDuration(slots, totalUnit);
+      }
+      if (!relativeToSlots) {
+        throw new RangeError("Missing relativeTo");
+      }
+      if (!slots.sign) {
+        return 0;
+      }
+      const [marker, calendarOps, timeZoneOps] = createMarkerSystem(getCalendarOps, getTimeZoneOps, relativeToSlots), markerToEpochNano = createMarkerToEpochNano(timeZoneOps), moveMarker = createMoveMarker(timeZoneOps), diffMarkers = createDiffMarkers(timeZoneOps), endMarker = moveMarker(calendarOps, marker, slots);
+      isZonedEpochSlots(relativeToSlots) || (checkIsoDateTimeInBounds(marker), checkIsoDateTimeInBounds(endMarker));
+      const balancedDuration = diffMarkers(calendarOps, marker, endMarker, totalUnit);
+      return isUniformUnit(totalUnit, relativeToSlots) ? totalDayTimeDuration(balancedDuration, totalUnit) : ((durationFields, endEpochNano, totalUnit, calendarOps, marker, markerToEpochNano, moveMarker) => {
+        const sign = computeDurationSign(durationFields), [epochNano0, epochNano1] = clampRelativeDuration(calendarOps, clearDurationFields(totalUnit, durationFields), totalUnit, sign, marker, markerToEpochNano, moveMarker), frac = computeEpochNanoFrac(endEpochNano, epochNano0, epochNano1);
+        return durationFields[durationFieldNamesAsc[totalUnit]] + frac * sign;
+      })(balancedDuration, markerToEpochNano(endMarker), totalUnit, calendarOps, marker, markerToEpochNano, moveMarker);
+    })(refinePublicRelativeTo, createNativeStandardOps, queryNativeTimeZone, slots, options),
+    toLocaleString(slots, locales, options) {
+      return Intl.DurationFormat ? new Intl.DurationFormat(locales, options).format(this) : formatDurationIso(slots);
+    },
+    toString: formatDurationIso,
+    toJSON: slots => formatDurationIso(slots),
+    valueOf: neverValueOf
+  }, {
+    from: arg => createDuration(toDurationSlots(arg)),
+    compare: (durationArg0, durationArg1, options) => ((refineRelativeTo, getCalendarOps, getTimeZoneOps, durationSlots0, durationSlots1, options) => {
+      const relativeToSlots = refineRelativeTo(normalizeOptions(options).relativeTo), maxUnit = Math.max(getMaxDurationUnit(durationSlots0), getMaxDurationUnit(durationSlots1));
+      if (allPropsEqual(durationFieldNamesAsc, durationSlots0, durationSlots1)) {
+        return 0;
+      }
+      if (isUniformUnit(maxUnit, relativeToSlots)) {
+        return compareBigNanos(durationFieldsToBigNano(durationSlots0), durationFieldsToBigNano(durationSlots1));
+      }
+      if (!relativeToSlots) {
+        throw new RangeError("Missing relativeTo");
+      }
+      const [marker, calendarOps, timeZoneOps] = createMarkerSystem(getCalendarOps, getTimeZoneOps, relativeToSlots), markerToEpochNano = createMarkerToEpochNano(timeZoneOps), moveMarker = createMoveMarker(timeZoneOps);
+      return compareBigNanos(markerToEpochNano(moveMarker(calendarOps, marker, durationSlots0)), markerToEpochNano(moveMarker(calendarOps, marker, durationSlots1)));
+    })(refinePublicRelativeTo, createNativeStandardOps, queryNativeTimeZone, toDurationSlots(durationArg0), toDurationSlots(durationArg1), options)
+  }), timeZoneNameStrs = [ "timeZoneName" ], monthDayFallbacks = {
+    month: "numeric",
+    day: "numeric"
+  }, yearMonthFallbacks = {
+    year: "numeric",
+    month: "numeric"
+  }, dateFallbacks = {
+    ...yearMonthFallbacks,
+    day: "numeric"
+  }, timeFallbacks = {
+    hour: "numeric",
+    minute: "numeric",
+    second: "numeric"
+  }, dateTimeFallbacks = {
+    ...dateFallbacks,
+    ...timeFallbacks
+  }, zonedFallbacks = {
+    ...dateTimeFallbacks,
+    timeZoneName: "short"
+  }, yearMonthFallbackNames = Object.keys(yearMonthFallbacks), monthDayFallbackNames = Object.keys(monthDayFallbacks), dateFallbackNames = Object.keys(dateFallbacks), timeFallbackNames = Object.keys(timeFallbacks), dateStyleNames = [ "dateStyle" ], yearMonthStandardNames = [ ...yearMonthFallbackNames, ...dateStyleNames ], monthDayStandardNames = [ ...monthDayFallbackNames, ...dateStyleNames ], dateStandardNames = [ ...dateFallbackNames, ...dateStyleNames, "weekday" ], timeStandardNames = [ ...timeFallbackNames, "dayPeriod", "timeStyle", "fractionalSecondDigits" ], dateTimeStandardNames = [ ...dateStandardNames, ...timeStandardNames ], dateExclusions = [ ...timeZoneNameStrs, ...timeStandardNames ], timeExclusions = [ ...timeZoneNameStrs, ...dateStandardNames ], yearMonthExclusions = [ ...timeZoneNameStrs, "day", "weekday", ...timeStandardNames ], monthDayExclusions = [ ...timeZoneNameStrs, "year", "weekday", ...timeStandardNames ], transformInstantOptions = createOptionsTransformer(dateTimeStandardNames, dateTimeFallbacks), transformZonedOptions = createOptionsTransformer(dateTimeStandardNames, zonedFallbacks), transformDateTimeOptions = createOptionsTransformer(dateTimeStandardNames, dateTimeFallbacks, timeZoneNameStrs), transformDateOptions = createOptionsTransformer(dateStandardNames, dateFallbacks, dateExclusions), transformTimeOptions = createOptionsTransformer(timeStandardNames, timeFallbacks, timeExclusions), transformYearMonthOptions = createOptionsTransformer(yearMonthStandardNames, yearMonthFallbacks, yearMonthExclusions), transformMonthDayOptions = createOptionsTransformer(monthDayStandardNames, monthDayFallbacks, monthDayExclusions), emptyOptions = {}, nonBuggyIsoResolve = new RawDateTimeFormat(void 0, {
+    calendar: isoCalendarId
+  }).resolvedOptions().calendar === isoCalendarId, instantConfig = [ transformInstantOptions, getEpochMilli ], zonedConfig = [ transformZonedOptions, getEpochMilli, 0, (slots0, slots1) => {
+    const timeZoneId = slots0.timeZone;
+    if (slots1 && slots1.timeZone !== timeZoneId) {
+      throw new RangeError(mismatchingTimeZones);
+    }
+    return timeZoneId;
+  } ], dateTimeConfig = [ transformDateTimeOptions, isoToEpochMilli ], dateConfig = [ transformDateOptions, isoToEpochMilli ], timeConfig = [ transformTimeOptions, isoFields => isoTimeFieldsToNano(isoFields) / nanoInMilli ], yearMonthConfig = [ transformYearMonthOptions, isoToEpochMilli, nonBuggyIsoResolve ], monthDayConfig = [ transformMonthDayOptions, isoToEpochMilli, nonBuggyIsoResolve ], classFormatConfigs = {
+    Instant: instantConfig,
+    PlainDateTime: dateTimeConfig,
+    PlainDate: dateConfig,
+    PlainTime: timeConfig,
+    PlainYearMonth: yearMonthConfig,
+    PlainMonthDay: monthDayConfig
+  }, prepInstantFormat = createFormatPrepper(instantConfig), prepZonedDateTimeFormat = createFormatPrepper(zonedConfig), prepPlainDateTimeFormat = createFormatPrepper(dateTimeConfig), prepPlainDateFormat = createFormatPrepper(dateConfig), prepPlainTimeFormat = createFormatPrepper(timeConfig), prepPlainYearMonthFormat = createFormatPrepper(yearMonthConfig), prepPlainMonthDayFormat = createFormatPrepper(monthDayConfig), [PlainTime, createPlainTime] = createSlotClass(PlainTimeBranding, ((isoHour = 0, isoMinute = 0, isoSecond = 0, isoMillisecond = 0, isoMicrosecond = 0, isoNanosecond = 0) => createPlainTimeSlots(constrainIsoTimeFields(mapProps(toInteger, zipProps(isoTimeFieldNamesAsc, [ isoHour, isoMinute, isoSecond, isoMillisecond, isoMicrosecond, isoNanosecond ])), 1))), timeGetters, {
+    with(_slots, mod, options) {
+      return createPlainTime(((initialFields, mod, options) => createPlainTimeSlots(((initialFields, modFields, options) => refineTimeBag({
+        ...pluckProps(timeFieldNamesAlpha, initialFields),
+        ...refineFields(modFields, timeFieldNamesAlpha)
+      }, refineOverflowOptions(options)))(initialFields, mod, options)))(this, rejectInvalidBag(mod), options));
+    },
+    add: (slots, durationArg) => createPlainTime(movePlainTime(0, slots, toDurationSlots(durationArg))),
+    subtract: (slots, durationArg) => createPlainTime(movePlainTime(1, slots, toDurationSlots(durationArg))),
+    until: (slots, otherArg, options) => createDuration(diffPlainTimes(0, slots, toPlainTimeSlots(otherArg), options)),
+    since: (slots, otherArg, options) => createDuration(diffPlainTimes(1, slots, toPlainTimeSlots(otherArg), options)),
+    round: (slots, options) => createPlainTime(((slots, options) => {
+      const [a, b, c] = refineRoundingOptions(options, 5);
+      var roundingMode;
+      return createPlainTimeSlots((roundingMode = c, roundTimeToNano(slots, computeNanoInc(a, b), roundingMode)[0]));
+    })(slots, options)),
+    equals(slots, other) {
+      return !compareIsoTimeFields(slots, toPlainTimeSlots(other));
+    },
+    toLocaleString(slots, locales, options) {
+      const [format, epochMilli] = prepPlainTimeFormat(locales, options, slots);
+      return format.format(epochMilli);
+    },
+    toString: formatPlainTimeIso,
+    toJSON: slots => formatPlainTimeIso(slots),
+    valueOf: neverValueOf
+  }, {
+    from: (arg, options) => createPlainTime(toPlainTimeSlots(arg, options)),
+    compare: (arg0, arg1) => compareIsoTimeFields(toPlainTimeSlots(arg0), toPlainTimeSlots(arg1))
+  }), [PlainDateTime, createPlainDateTime] = createSlotClass(PlainDateTimeBranding, bindArgs(((refineCalendarArg, isoYear, isoMonth, isoDay, isoHour = 0, isoMinute = 0, isoSecond = 0, isoMillisecond = 0, isoMicrosecond = 0, isoNanosecond = 0, calendarArg = isoCalendarId) => createPlainDateTimeSlots(checkIsoDateTimeInBounds(checkIsoDateTimeFields(mapProps(toInteger, zipProps(isoDateTimeFieldNamesAsc, [ isoYear, isoMonth, isoDay, isoHour, isoMinute, isoSecond, isoMillisecond, isoMicrosecond, isoNanosecond ])))), refineCalendarArg(calendarArg))), refineCalendarId), {
+    ...calendarIdGetters,
+    ...dateGetters,
+    ...timeGetters
+  }, {
+    with: (slots, mod, options) => createPlainDateTime(((getCalendarOps, plainDateTimeSlots, modFields, options) => {
+      const calendarOps = getCalendarOps(plainDateTimeSlots.calendar), validFieldNames = [ ...calendarOps.fields(dateFieldNamesAlpha), ...timeFieldNamesAsc ].sort(), origFields = {
+        ...computeDateEssentials(slots = plainDateTimeSlots),
+        hour: slots.isoHour,
+        minute: slots.isoMinute,
+        second: slots.isoSecond,
+        millisecond: slots.isoMillisecond,
+        microsecond: slots.isoMicrosecond,
+        nanosecond: slots.isoNanosecond
+      };
+      var slots;
+      const partialFields = refineFields(modFields, validFieldNames), overflow = refineOverflowOptions(options), mergedCalendarFields = calendarOps.mergeFields(origFields, partialFields), mergedAllFields = {
+        ...origFields,
+        ...partialFields
+      };
+      return createPlainDateTimeSlots(checkIsoDateTimeInBounds({
+        ...calendarOps.dateFromFields(mergedCalendarFields, fabricateOverflowOptions(overflow)),
+        ...constrainIsoTimeFields(timeFieldsToIso(mergedAllFields), overflow)
+      }));
+    })(createNativeStandardOps, slots, rejectInvalidBag(mod), options)),
+    withCalendar: (slots, calendarArg) => createPlainDateTime(slotsWithCalendarId(slots, refineCalendarArg(calendarArg))),
+    withPlainTime: (slots, plainTimeArg) => createPlainDateTime(((plainDateTimeSlots, plainTimeSlots = isoTimeFieldDefaults) => createPlainDateTimeSlots(checkIsoDateTimeInBounds({
+      ...plainDateTimeSlots,
+      ...plainTimeSlots
+    })))(slots, optionalToPlainTimeFields(plainTimeArg))),
+    add: (slots, durationArg, options) => createPlainDateTime(movePlainDateTime(createNativeStandardOps, 0, slots, toDurationSlots(durationArg), options)),
+    subtract: (slots, durationArg, options) => createPlainDateTime(movePlainDateTime(createNativeStandardOps, 1, slots, toDurationSlots(durationArg), options)),
+    until: (slots, otherArg, options) => createDuration(diffPlainDateTimes(createNativeStandardOps, 0, slots, toPlainDateTimeSlots(otherArg), options)),
+    since: (slots, otherArg, options) => createDuration(diffPlainDateTimes(createNativeStandardOps, 1, slots, toPlainDateTimeSlots(otherArg), options)),
+    round: (slots, options) => createPlainDateTime(((slots, options) => createPlainDateTimeSlots(roundDateTime(slots, ...refineRoundingOptions(options)), slots.calendar))(slots, options)),
+    equals(slots, otherArg) {
+      return !compareIsoDateTimeFields(plainDateTimeSlots0 = slots, plainDateTimeSlots1 = toPlainDateTimeSlots(otherArg)) && plainDateTimeSlots0.calendar === plainDateTimeSlots1.calendar;
+      var plainDateTimeSlots0, plainDateTimeSlots1;
+    },
+    toZonedDateTime: (slots, timeZoneArg, options) => createZonedDateTime(((getTimeZoneOps, plainDateTimeSlots, timeZoneId, options) => {
+      const epochNano = ((getTimeZoneOps, timeZoneId, isoFields, options) => {
+        const epochDisambig = (options => refineEpochDisambig(normalizeOptions(options)))(options);
+        return getSingleInstantFor(getTimeZoneOps(timeZoneId), isoFields, epochDisambig);
+      })(getTimeZoneOps, timeZoneId, plainDateTimeSlots, options);
+      return createZonedDateTimeSlots(checkEpochNanoInBounds(epochNano), timeZoneId, plainDateTimeSlots.calendar);
+    })(queryNativeTimeZone, slots, refineTimeZoneArg(timeZoneArg), options)),
+    toPlainDate: slots => createPlainDate(createPlainDateSlots(slots)),
+    toPlainTime: slots => createPlainTime(createPlainTimeSlots(slots)),
+    toLocaleString(slots, locales, options) {
+      const [format, epochMilli] = prepPlainDateTimeFormat(locales, options, slots);
+      return format.format(epochMilli);
+    },
+    toString: formatPlainDateTimeIso,
+    toJSON: slots => formatPlainDateTimeIso(slots),
+    valueOf: neverValueOf
+  }, {
+    from: (arg, options) => createPlainDateTime(toPlainDateTimeSlots(arg, options)),
+    compare: (arg0, arg1) => compareIsoDateTimeFields(toPlainDateTimeSlots(arg0), toPlainDateTimeSlots(arg1))
+  }), [PlainMonthDay, createPlainMonthDay, getPlainMonthDaySlots] = createSlotClass(PlainMonthDayBranding, bindArgs(((refineCalendarArg, isoMonth, isoDay, calendarArg = isoCalendarId, referenceIsoYear = isoEpochFirstLeapYear) => {
+    const isoMonthInt = toInteger(isoMonth), isoDayInt = toInteger(isoDay), calendarId = refineCalendarArg(calendarArg);
+    return createPlainMonthDaySlots(checkIsoDateInBounds(checkIsoDateFields({
+      isoYear: toInteger(referenceIsoYear),
+      isoMonth: isoMonthInt,
+      isoDay: isoDayInt
+    })), calendarId);
+  }), refineCalendarId), {
+    ...calendarIdGetters,
+    ...monthDayGetters
+  }, {
+    with: (slots, mod, options) => createPlainMonthDay(((getCalendarOps, plainMonthDaySlots, modFields, options) => {
+      const calendarOps = getCalendarOps(plainMonthDaySlots.calendar), validFieldNames = calendarOps.fields(dateFieldNamesAlpha).sort(), origFields = (slots => {
+        const calendarOps = createNativePartOps(slots.calendar), [year, month, day] = calendarOps.dateParts(slots), [monthCodeNumber, isLeapMonth] = calendarOps.monthCodeParts(year, month);
+        return {
+          monthCode: formatMonthCode(monthCodeNumber, isLeapMonth),
+          day: day
+        };
+      })(plainMonthDaySlots), partialFields = refineFields(modFields, validFieldNames), mergedFields = calendarOps.mergeFields(origFields, partialFields);
+      return calendarOps.monthDayFromFields(mergedFields, options);
+    })(createNativeStandardOps, slots, rejectInvalidBag(mod), options)),
+    equals(slots, otherArg) {
+      return !compareIsoDateFields(plainMonthDaySlots0 = slots, plainMonthDaySlots1 = toPlainMonthDaySlots(otherArg)) && plainMonthDaySlots0.calendar === plainMonthDaySlots1.calendar;
+      var plainMonthDaySlots0, plainMonthDaySlots1;
+    },
+    toPlainDate(slots, bag) {
+      return createPlainDate(((getCalendarOps, plainMonthDaySlots, plainMonthDayFields, bag) => ((calendarOps, input, bag) => convertToIso(calendarOps, input, monthCodeDayFieldNames, requireObjectLike(bag), yearFieldNames))(getCalendarOps(plainMonthDaySlots.calendar), plainMonthDayFields, bag))(createNativeStandardOps, slots, this, bag));
+    },
+    toLocaleString(slots, locales, options) {
+      const [format, epochMilli] = prepPlainMonthDayFormat(locales, options, slots);
+      return format.format(epochMilli);
+    },
+    toString: formatPlainMonthDayIso,
+    toJSON: slots => formatPlainMonthDayIso(slots),
+    valueOf: neverValueOf
+  }, {
+    from: (arg, options) => createPlainMonthDay(toPlainMonthDaySlots(arg, options))
+  }), [PlainYearMonth, createPlainYearMonth, getPlainYearMonthSlots] = createSlotClass(PlainYearMonthBranding, bindArgs(((refineCalendarArg, isoYear, isoMonth, calendarArg = isoCalendarId, referenceIsoDay = 1) => {
+    const isoYearInt = toInteger(isoYear), isoMonthInt = toInteger(isoMonth), calendarId = refineCalendarArg(calendarArg);
+    return createPlainYearMonthSlots(checkIsoYearMonthInBounds(checkIsoDateFields({
+      isoYear: isoYearInt,
+      isoMonth: isoMonthInt,
+      isoDay: toInteger(referenceIsoDay)
+    })), calendarId);
+  }), refineCalendarId), {
+    ...calendarIdGetters,
+    ...yearMonthGetters
+  }, {
+    with: (slots, mod, options) => createPlainYearMonth(((getCalendarOps, plainYearMonthSlots, modFields, options) => {
+      const calendarOps = getCalendarOps(plainYearMonthSlots.calendar), validFieldNames = calendarOps.fields(yearMonthFieldNames).sort(), origFields = (slots => {
+        const calendarOps = createNativePartOps(slots.calendar), [year, month] = calendarOps.dateParts(slots), [monthCodeNumber, isLeapMonth] = calendarOps.monthCodeParts(year, month);
+        return {
+          year: year,
+          monthCode: formatMonthCode(monthCodeNumber, isLeapMonth)
+        };
+      })(plainYearMonthSlots), partialFields = refineFields(modFields, validFieldNames), mergedFields = calendarOps.mergeFields(origFields, partialFields);
+      return calendarOps.yearMonthFromFields(mergedFields, options);
+    })(createNativeStandardOps, slots, rejectInvalidBag(mod), options)),
+    add: (slots, durationArg, options) => createPlainYearMonth(movePlainYearMonth(createNativeStandardOps, 0, slots, toDurationSlots(durationArg), options)),
+    subtract: (slots, durationArg, options) => createPlainYearMonth(movePlainYearMonth(createNativeStandardOps, 1, slots, toDurationSlots(durationArg), options)),
+    until: (slots, otherArg, options) => createDuration(diffPlainYearMonth(createNativeStandardOps, 0, slots, toPlainYearMonthSlots(otherArg), options)),
+    since: (slots, otherArg, options) => createDuration(diffPlainYearMonth(createNativeStandardOps, 1, slots, toPlainYearMonthSlots(otherArg), options)),
+    equals(slots, otherArg) {
+      return !compareIsoDateFields(plainYearMonthSlots0 = slots, plainYearMonthSlots1 = toPlainYearMonthSlots(otherArg)) && plainYearMonthSlots0.calendar === plainYearMonthSlots1.calendar;
+      var plainYearMonthSlots0, plainYearMonthSlots1;
+    },
+    toPlainDate(slots, bag) {
+      return createPlainDate(((getCalendarOps, plainYearMonthSlots, plainYearMonthFields, bag) => ((calendarOps, input, bag) => convertToIso(calendarOps, input, yearMonthCodeFieldNames, requireObjectLike(bag), dayFieldNames))(getCalendarOps(plainYearMonthSlots.calendar), plainYearMonthFields, bag))(createNativeStandardOps, slots, this, bag));
+    },
+    toLocaleString(slots, locales, options) {
+      const [format, epochMilli] = prepPlainYearMonthFormat(locales, options, slots);
+      return format.format(epochMilli);
+    },
+    toString: formatPlainYearMonthIso,
+    toJSON: slots => formatPlainYearMonthIso(slots),
+    valueOf: neverValueOf
+  }, {
+    from: (arg, options) => createPlainYearMonth(toPlainYearMonthSlots(arg, options)),
+    compare: (arg0, arg1) => compareIsoDateFields(toPlainYearMonthSlots(arg0), toPlainYearMonthSlots(arg1))
+  }), [PlainDate, createPlainDate, getPlainDateSlots] = createSlotClass(PlainDateBranding, bindArgs(((refineCalendarArg, isoYear, isoMonth, isoDay, calendarArg = isoCalendarId) => createPlainDateSlots(checkIsoDateInBounds(checkIsoDateFields(mapProps(toInteger, {
+    isoYear: isoYear,
+    isoMonth: isoMonth,
+    isoDay: isoDay
+  }))), refineCalendarArg(calendarArg))), refineCalendarId), {
+    ...calendarIdGetters,
+    ...dateGetters
+  }, {
+    with: (slots, mod, options) => createPlainDate(((getCalendarOps, plainDateSlots, modFields, options) => {
+      const calendarOps = getCalendarOps(plainDateSlots.calendar), validFieldNames = calendarOps.fields(dateFieldNamesAlpha).sort(), origFields = computeDateEssentials(plainDateSlots), partialFields = refineFields(modFields, validFieldNames), mergedFields = calendarOps.mergeFields(origFields, partialFields);
+      return calendarOps.dateFromFields(mergedFields, options);
+    })(createNativeStandardOps, slots, rejectInvalidBag(mod), options)),
+    withCalendar: (slots, calendarArg) => createPlainDate(slotsWithCalendarId(slots, refineCalendarArg(calendarArg))),
+    add: (slots, durationArg, options) => createPlainDate(movePlainDate(createNativeStandardOps, 0, slots, toDurationSlots(durationArg), options)),
+    subtract: (slots, durationArg, options) => createPlainDate(movePlainDate(createNativeStandardOps, 1, slots, toDurationSlots(durationArg), options)),
+    until: (slots, otherArg, options) => createDuration(diffPlainDates(createNativeStandardOps, 0, slots, toPlainDateSlots(otherArg), options)),
+    since: (slots, otherArg, options) => createDuration(diffPlainDates(createNativeStandardOps, 1, slots, toPlainDateSlots(otherArg), options)),
+    equals(slots, otherArg) {
+      return !compareIsoDateFields(plainDateSlots0 = slots, plainDateSlots1 = toPlainDateSlots(otherArg)) && plainDateSlots0.calendar === plainDateSlots1.calendar;
+      var plainDateSlots0, plainDateSlots1;
+    },
+    toZonedDateTime(slots, options) {
+      const optionsObj = isObjectLike(options) ? options : {
+        timeZone: options
+      };
+      return createZonedDateTime(((refineTimeZoneString, refinePlainTimeArg, getTimeZoneOps, plainDateSlots, options) => {
+        const timeZoneId = refineTimeZoneString(options.timeZone), plainTimeArg = options.plainTime, isoTimeFields = void 0 !== plainTimeArg ? refinePlainTimeArg(plainTimeArg) : void 0, timeZoneOps = getTimeZoneOps(timeZoneId);
+        let epochNano;
+        return epochNano = isoTimeFields ? getSingleInstantFor(timeZoneOps, {
+          ...plainDateSlots,
+          ...isoTimeFields
+        }) : getStartOfDayInstantFor(timeZoneOps, {
+          ...plainDateSlots,
+          ...isoTimeFieldDefaults
+        }), createZonedDateTimeSlots(epochNano, timeZoneId, plainDateSlots.calendar);
+      })(refineTimeZoneArg, toPlainTimeSlots, queryNativeTimeZone, slots, optionsObj));
+    },
+    toPlainDateTime: (slots, plainTimeArg) => createPlainDateTime(((plainDateSlots, plainTimeFields = isoTimeFieldDefaults) => createPlainDateTimeSlots(checkIsoDateTimeInBounds({
+      ...plainDateSlots,
+      ...plainTimeFields
+    })))(slots, optionalToPlainTimeFields(plainTimeArg))),
+    toPlainYearMonth(slots) {
+      return createPlainYearMonth((this, ((calendarOps, input) => {
+        const fields = refineCalendarFields(calendarOps, input, yearMonthCodeFieldNames);
+        return calendarOps.yearMonthFromFields(fields, void 0);
+      })(createNativeStandardOps(slots.calendar), this)));
+    },
+    toPlainMonthDay(slots) {
+      return createPlainMonthDay((this, ((calendarOps, input) => {
+        const fields = refineCalendarFields(calendarOps, input, monthCodeDayFieldNames);
+        return calendarOps.monthDayFromFields(fields);
+      })(createNativeStandardOps(slots.calendar), this)));
+    },
+    toLocaleString(slots, locales, options) {
+      const [format, epochMilli] = prepPlainDateFormat(locales, options, slots);
+      return format.format(epochMilli);
+    },
+    toString: formatPlainDateIso,
+    toJSON: slots => formatPlainDateIso(slots),
+    valueOf: neverValueOf
+  }, {
+    from: (arg, options) => createPlainDate(toPlainDateSlots(arg, options)),
+    compare: (arg0, arg1) => compareIsoDateFields(toPlainDateSlots(arg0), toPlainDateSlots(arg1))
+  }), [ZonedDateTime, createZonedDateTime] = createSlotClass(ZonedDateTimeBranding, bindArgs(((refineCalendarArg, refineTimeZoneArg, epochNano, timeZoneArg, calendarArg = isoCalendarId) => createZonedDateTimeSlots(checkEpochNanoInBounds(bigIntToBigNano(toBigInt(epochNano))), refineTimeZoneArg(timeZoneArg), refineCalendarArg(calendarArg))), refineCalendarId, (id => resolveTimeZoneId(requireString(id)))), {
+    ...epochGetters,
+    ...calendarIdGetters,
+    ...adaptDateMethods(dateGetters),
+    ...adaptDateMethods(timeGetters),
+    offset: slots => formatOffsetNano(slotsToIso(slots).offsetNanoseconds),
+    offsetNanoseconds: slots => slotsToIso(slots).offsetNanoseconds,
+    timeZoneId: slots => slots.timeZone,
+    hoursInDay: slots => ((getTimeZoneOps, slots) => {
+      const timeZoneOps = getTimeZoneOps(slots.timeZone), isoFields = zonedEpochSlotsToIso(slots, timeZoneOps), [isoFields0, isoFields1] = computeDayInterval(isoFields), hoursExact = bigNanoToNumber(diffBigNanos(getStartOfDayInstantFor(timeZoneOps, isoFields0), getStartOfDayInstantFor(timeZoneOps, isoFields1)), nanoInHour, 1);
+      if (hoursExact <= 0) {
+        throw new RangeError(invalidProtocolResults);
+      }
+      return hoursExact;
+    })(queryNativeTimeZone, slots)
+  }, {
+    with: (slots, mod, options) => createZonedDateTime(((getCalendarOps, getTimeZoneOps, zonedDateTimeSlots, modFields, options) => {
+      const {calendar: calendar, timeZone: timeZone} = zonedDateTimeSlots, calendarOps = getCalendarOps(calendar), timeZoneOps = getTimeZoneOps(timeZone), validFieldNames = [ ...calendarOps.fields(dateFieldNamesAlpha), ...timeAndOffsetFieldNames ].sort(), origFields = (slots => {
+        const isoFields = zonedEpochSlotsToIso(slots, queryNativeTimeZone), offsetString = formatOffsetNano(isoFields.offsetNanoseconds), calendarOps = createNativePartOps(slots.calendar), [year, month, day] = calendarOps.dateParts(isoFields), [monthCodeNumber, isLeapMonth] = calendarOps.monthCodeParts(year, month), monthCode = formatMonthCode(monthCodeNumber, isLeapMonth);
+        return {
+          ...isoTimeFieldsToCal(isoFields),
+          year: year,
+          monthCode: monthCode,
+          day: day,
+          offset: offsetString
+        };
+      })(zonedDateTimeSlots), partialFields = refineFields(modFields, validFieldNames), mergedCalendarFields = calendarOps.mergeFields(origFields, partialFields), mergedAllFields = {
+        ...origFields,
+        ...partialFields
+      }, [overflow, offsetDisambig, epochDisambig] = refineZonedFieldOptions(options, 2);
+      return createZonedDateTimeSlots(getMatchingInstantFor(timeZoneOps, {
+        ...calendarOps.dateFromFields(mergedCalendarFields, fabricateOverflowOptions(overflow)),
+        ...constrainIsoTimeFields(timeFieldsToIso(mergedAllFields), overflow)
+      }, parseOffsetNano(mergedAllFields.offset), offsetDisambig, epochDisambig), timeZone, calendar);
+    })(createNativeStandardOps, queryNativeTimeZone, slots, rejectInvalidBag(mod), options)),
+    withCalendar: (slots, calendarArg) => createZonedDateTime(slotsWithCalendarId(slots, refineCalendarArg(calendarArg))),
+    withTimeZone: (slots, timeZoneArg) => createZonedDateTime(((slots, timeZoneId) => ({
+      ...slots,
+      timeZone: timeZoneId
+    }))(slots, refineTimeZoneArg(timeZoneArg))),
+    withPlainTime: (slots, plainTimeArg) => createZonedDateTime(((getTimeZoneOps, zonedDateTimeSlots, plainTimeSlots) => {
+      const timeZoneId = zonedDateTimeSlots.timeZone, timeZoneOps = getTimeZoneOps(timeZoneId), isoFields = {
+        ...zonedEpochSlotsToIso(zonedDateTimeSlots, timeZoneOps),
+        ...plainTimeSlots || isoTimeFieldDefaults
+      };
+      let epochNano;
+      return epochNano = plainTimeSlots ? getMatchingInstantFor(timeZoneOps, isoFields, isoFields.offsetNanoseconds, 2) : getStartOfDayInstantFor(timeZoneOps, isoFields), 
+      createZonedDateTimeSlots(epochNano, timeZoneId, zonedDateTimeSlots.calendar);
+    })(queryNativeTimeZone, slots, optionalToPlainTimeFields(plainTimeArg))),
+    add: (slots, durationArg, options) => createZonedDateTime(moveZonedDateTime(createNativeStandardOps, queryNativeTimeZone, 0, slots, toDurationSlots(durationArg), options)),
+    subtract: (slots, durationArg, options) => createZonedDateTime(moveZonedDateTime(createNativeStandardOps, queryNativeTimeZone, 1, slots, toDurationSlots(durationArg), options)),
+    until: (slots, otherArg, options) => createDuration(createDurationSlots(diffZonedDateTimes(createNativeStandardOps, queryNativeTimeZone, 0, slots, toZonedDateTimeSlots(otherArg), options))),
+    since: (slots, otherArg, options) => createDuration(createDurationSlots(diffZonedDateTimes(createNativeStandardOps, queryNativeTimeZone, 1, slots, toZonedDateTimeSlots(otherArg), options))),
+    round: (slots, options) => createZonedDateTime(((getTimeZoneOps, slots, options) => {
+      let {epochNanoseconds: epochNanoseconds, timeZone: timeZone, calendar: calendar} = slots;
+      const [smallestUnit, roundingInc, roundingMode] = refineRoundingOptions(options);
+      if (0 === smallestUnit && 1 === roundingInc) {
+        return slots;
+      }
+      const timeZoneOps = getTimeZoneOps(timeZone);
+      if (6 === smallestUnit) {
+        epochNanoseconds = ((computeInterval, timeZoneOps, slots, roundingMode) => {
+          const isoSlots = zonedEpochSlotsToIso(slots, timeZoneOps), [isoFields0, isoFields1] = computeInterval(isoSlots), epochNano = slots.epochNanoseconds, epochNano0 = getStartOfDayInstantFor(timeZoneOps, isoFields0), epochNano1 = getStartOfDayInstantFor(timeZoneOps, isoFields1);
+          if (bigNanoOutside(epochNano, epochNano0, epochNano1)) {
+            throw new RangeError(invalidProtocolResults);
+          }
+          return roundWithMode(computeEpochNanoFrac(epochNano, epochNano0, epochNano1), roundingMode) ? epochNano1 : epochNano0;
+        })(computeDayInterval, timeZoneOps, slots, roundingMode);
+      } else {
+        const offsetNano = timeZoneOps.getOffsetNanosecondsFor(epochNanoseconds);
+        epochNanoseconds = getMatchingInstantFor(timeZoneOps, roundDateTime(epochNanoToIso(epochNanoseconds, offsetNano), smallestUnit, roundingInc, roundingMode), offsetNano, 2, 0, 1);
+      }
+      return createZonedDateTimeSlots(epochNanoseconds, timeZone, calendar);
+    })(queryNativeTimeZone, slots, options)),
+    startOfDay: slots => createZonedDateTime(((getTimeZoneOps, slots) => {
+      const {timeZone: timeZone, calendar: calendar} = slots, epochNano1 = ((computeAlignment, timeZoneOps, slots) => getStartOfDayInstantFor(timeZoneOps, computeAlignment(zonedEpochSlotsToIso(slots, timeZoneOps))))(computeDayFloor, getTimeZoneOps(timeZone), slots);
+      return createZonedDateTimeSlots(epochNano1, timeZone, calendar);
+    })(queryNativeTimeZone, slots)),
+    equals(slots, otherArg) {
+      return !compareZonedDateTimes(zonedDateTimeSlots0 = slots, zonedDateTimeSlots1 = toZonedDateTimeSlots(otherArg)) && !!isTimeZoneIdsEqual(zonedDateTimeSlots0.timeZone, zonedDateTimeSlots1.timeZone) && zonedDateTimeSlots0.calendar === zonedDateTimeSlots1.calendar;
+      var zonedDateTimeSlots0, zonedDateTimeSlots1;
+    },
+    toInstant: slots => createInstant(createInstantSlots(slots.epochNanoseconds)),
+    toPlainDateTime: slots => createPlainDateTime(zonedDateTimeToPlainDateTime(queryNativeTimeZone, slots)),
+    toPlainDate: slots => createPlainDate(zonedDateTimeToPlainDate(queryNativeTimeZone, slots)),
+    toPlainTime: slots => createPlainTime(zonedDateTimeToPlainTime(queryNativeTimeZone, slots)),
+    toLocaleString(slots, locales, options = {}) {
+      const [format, epochMilli] = prepZonedDateTimeFormat(locales, options, slots);
+      return format.format(epochMilli);
+    },
+    toString: (slots, options) => formatZonedDateTimeIso(queryNativeTimeZone, slots, options),
+    toJSON: slots => formatZonedDateTimeIso(queryNativeTimeZone, slots),
+    valueOf: neverValueOf,
+    getTimeZoneTransition(slots, options) {
+      const {timeZone: timeZoneId, epochNanoseconds: epochNano} = slots, direction = (options => {
+        const normalizedOptions = normalizeOptionsOrString(options, "direction"), res = refineChoiceOption("direction", directionMap, normalizedOptions, 0);
+        if (!res) {
+          throw new RangeError(invalidEntity("direction", res));
+        }
+        return res;
+      })(options), newEpochNano = queryNativeTimeZone(timeZoneId).getTransition(epochNano, direction);
+      return newEpochNano ? createZonedDateTime({
+        ...slots,
+        epochNanoseconds: newEpochNano
+      }) : null;
+    }
+  }, {
+    from: (arg, options) => createZonedDateTime(toZonedDateTimeSlots(arg, options)),
+    compare: (arg0, arg1) => compareZonedDateTimes(toZonedDateTimeSlots(arg0), toZonedDateTimeSlots(arg1))
+  }), [Instant, createInstant, getInstantSlots] = createSlotClass(InstantBranding, (epochNano => createInstantSlots(checkEpochNanoInBounds(bigIntToBigNano(toBigInt(epochNano))))), epochGetters, {
+    add: (slots, durationArg) => createInstant(moveInstant(0, slots, toDurationSlots(durationArg))),
+    subtract: (slots, durationArg) => createInstant(moveInstant(1, slots, toDurationSlots(durationArg))),
+    until: (slots, otherArg, options) => createDuration(diffInstants(0, slots, toInstantSlots(otherArg), options)),
+    since: (slots, otherArg, options) => createDuration(diffInstants(1, slots, toInstantSlots(otherArg), options)),
+    round: (slots, options) => createInstant(((instantSlots, options) => {
+      const [smallestUnit, roundingInc, roundingMode] = refineRoundingOptions(options, 5, 1);
+      return createInstantSlots(roundBigNano(instantSlots.epochNanoseconds, smallestUnit, roundingInc, roundingMode, 1));
+    })(slots, options)),
+    equals(slots, otherArg) {
+      return !compareInstants(slots, toInstantSlots(otherArg));
+    },
+    toZonedDateTimeISO: (slots, timeZoneArg) => createZonedDateTime(((instantSlots, timeZoneId, calendarId = isoCalendarId) => createZonedDateTimeSlots(instantSlots.epochNanoseconds, timeZoneId, calendarId))(slots, refineTimeZoneArg(timeZoneArg))),
+    toLocaleString(slots, locales, options) {
+      const [format, epochMilli] = prepInstantFormat(locales, options, slots);
+      return format.format(epochMilli);
+    },
+    toString: (slots, options) => formatInstantIso(refineTimeZoneArg, queryNativeTimeZone, slots, options),
+    toJSON: slots => formatInstantIso(refineTimeZoneArg, queryNativeTimeZone, slots),
+    valueOf: neverValueOf
+  }, {
+    from: arg => createInstant(toInstantSlots(arg)),
+    fromEpochMilliseconds: epochMilli => createInstant((epochMilli => createInstantSlots(checkEpochNanoInBounds(numberToBigNano(toStrictInteger(epochMilli), nanoInMilli))))(epochMilli)),
+    fromEpochNanoseconds: epochNano => createInstant((epochNano => createInstantSlots(checkEpochNanoInBounds(bigIntToBigNano(toBigInt(epochNano)))))(epochNano)),
+    compare: (a, b) => compareInstants(toInstantSlots(a), toInstantSlots(b))
+  }), DateTimeFormat = function() {
+    function DateTimeFormatFunc(locales, options) {
+      return new DateTimeFormatNew(locales, options);
+    }
+    function DateTimeFormatNew(locales, options = Object.create(null)) {
+      internalsMap.set(this, ((locales, options) => {
+        const rawFormat = new RawDateTimeFormat(locales, options), resolveOptions = rawFormat.resolvedOptions(), resolvedLocale = resolveOptions.locale, copiedOptions = pluckProps(Object.keys(options), resolveOptions), queryFormatPrepperForBranding = memoize(createFormatPrepperForBranding), prepFormat = (isRange, ...formattables) => {
+          if (isRange) {
+            if (2 !== formattables.length) {
+              throw new TypeError("Mismatching types for formatting");
+            }
+            for (const formattable of formattables) {
+              if (void 0 === formattable) {
+                throw new TypeError("Mismatching types for formatting");
+              }
+            }
+          }
+          isRange || void 0 !== formattables[0] || (formattables = []);
+          const formattableEssences = formattables.map((formattable => getSlots(formattable) || Number(formattable)));
+          let overallBranding, i = 0;
+          for (const formattableEssence of formattableEssences) {
+            const slotsBranding = "object" == typeof formattableEssence ? formattableEssence.branding : void 0;
+            if (i++ && slotsBranding !== overallBranding) {
+              throw new TypeError("Mismatching types for formatting");
+            }
+            overallBranding = slotsBranding;
+          }
+          return overallBranding ? queryFormatPrepperForBranding(overallBranding)(resolvedLocale, copiedOptions, ...formattableEssences) : [ rawFormat, ...formattableEssences ];
+        };
+        return prepFormat.rawFormat = rawFormat, prepFormat;
+      })(locales, options));
+    }
+    const members = RawDateTimeFormat.prototype, memberDescriptors = Object.getOwnPropertyDescriptors(members), classDescriptors = Object.getOwnPropertyDescriptors(RawDateTimeFormat);
+    for (const memberName in memberDescriptors) {
+      const memberDescriptor = memberDescriptors[memberName], formatLikeMethod = memberName.startsWith("format") && createFormatMethod(memberName);
+      "function" == typeof memberDescriptor.value ? memberDescriptor.value = "constructor" === memberName ? DateTimeFormatFunc : formatLikeMethod || createProxiedMethod(memberName) : formatLikeMethod && (memberDescriptor.get = function() {
+        if (!internalsMap.has(this)) {
+          throw new TypeError("Invalid calling context");
+        }
+        return (...args) => formatLikeMethod.apply(this, args);
+      }, Object.defineProperties(memberDescriptor.get, createNameDescriptors(`get ${memberName}`)));
+    }
+    return classDescriptors.prototype.value = DateTimeFormatNew.prototype = Object.create({}, memberDescriptors), 
+    Object.defineProperties(DateTimeFormatFunc, classDescriptors), DateTimeFormatFunc;
+  }(), internalsMap = new WeakMap;
+  let currentTimeZoneId;
+  const Now = Object.defineProperties({}, {
+    ...createStringTagDescriptors("Temporal.Now"),
+    ...createPropDescriptors({
+      timeZoneId: () => getCurrentTimeZoneId(),
+      instant: () => createInstant(createInstantSlots(getCurrentEpochNano())),
+      zonedDateTimeISO: (timeZoneArg = getCurrentTimeZoneId()) => createZonedDateTime(createZonedDateTimeSlots(getCurrentEpochNano(), refineTimeZoneArg(timeZoneArg), isoCalendarId)),
+      plainDateTimeISO: (timeZoneArg = getCurrentTimeZoneId()) => createPlainDateTime(createPlainDateTimeSlots(getCurrentIsoDateTime(queryNativeTimeZone(refineTimeZoneArg(timeZoneArg))), isoCalendarId)),
+      plainDateISO: (timeZoneArg = getCurrentTimeZoneId()) => createPlainDate(createPlainDateSlots(getCurrentIsoDateTime(queryNativeTimeZone(refineTimeZoneArg(timeZoneArg))), isoCalendarId)),
+      plainTimeISO: (timeZoneArg = getCurrentTimeZoneId()) => createPlainTime(createPlainTimeSlots(getCurrentIsoDateTime(queryNativeTimeZone(refineTimeZoneArg(timeZoneArg)))))
+    })
+  }), Temporal = Object.defineProperties({}, {
+    ...createStringTagDescriptors("Temporal"),
+    ...createPropDescriptors({
+      PlainYearMonth: PlainYearMonth,
+      PlainMonthDay: PlainMonthDay,
+      PlainDate: PlainDate,
+      PlainTime: PlainTime,
+      PlainDateTime: PlainDateTime,
+      ZonedDateTime: ZonedDateTime,
+      Instant: Instant,
+      Duration: Duration,
+      Now: Now
+    })
+  });
+  Object.defineProperties(globalThis, createPropDescriptors({
+    Temporal: Temporal
+  })), Object.defineProperties(Intl, createPropDescriptors({
+    DateTimeFormat: DateTimeFormat
+  })), Object.defineProperties(Date.prototype, createPropDescriptors({
+    toTemporalInstant() {
+      const epochMilli = Date.prototype.valueOf.call(this);
+      return createInstant(createInstantSlots(numberToBigNano(requireNumberIsInteger(epochMilli), nanoInMilli)));
+    }
+  }));
+}();