@hebcal/core 6.14.1 → 6.14.3

package/dist/bundle.js

@@ -1,9 +1,9 @@
-/*! @hebcal/core v6.14.1, distributed under GPLv2 or later https://www.gnu.org/licenses/gpl-2.0.txt */
+/*! @hebcal/core v6.14.3, distributed under GPLv2 or later https://www.gnu.org/licenses/gpl-2.0.txt */
 var hebcal = (function (exports) {
 'use strict';
 
 /** DO NOT EDIT THIS AUTO-GENERATED FILE! */
-const version = '6.14.1';
+const version = '6.14.3';
 
 /*! @hebcal/hdate v0.23.1, distributed under GPLv2 or later https://www.gnu.org/licenses/gpl-2.0.txt */
 /**
@@ -2961,259 +2961,6 @@ function requireObjectLike(arg) {
     return arg;
 }
 
-function normalizeOptionsOrString(options, optionName) {
-  return "string" == typeof options ? ((optionName, optionVal) => {
-    const res = Object.create(null);
-    return res[optionName] = optionVal, res;
-  })(optionName, options) : requireObjectLike(options);
-}
-
-const smallestUnitStr = "smallestUnit";
-
-const overflowMap = {
-  constrain: 0,
-  reject: 1
-};
-
-const epochDisambigMap = {
-  compatible: 0,
-  reject: 1,
-  earlier: 2,
-  later: 3
-};
-
-const offsetDisambigMap = {
-  reject: 0,
-  use: 1,
-  prefer: 2,
-  ignore: 3
-};
-
-const calendarDisplayMap = {
-  auto: 0,
-  never: 1,
-  critical: 2,
-  always: 3
-};
-
-const timeZoneDisplayMap = {
-  auto: 0,
-  never: 1,
-  critical: 2
-};
-
-const offsetDisplayMap = {
-  auto: 0,
-  never: 1
-};
-
-const roundingModeMap = {
-  floor: 0,
-  halfFloor: 1,
-  ceil: 2,
-  halfCeil: 3,
-  trunc: 4,
-  halfTrunc: 5,
-  expand: 6,
-  halfExpand: 7,
-  halfEven: 8
-};
-
-const roundingModeFuncs = [ Math.floor, roundHalfFloor, Math.ceil, roundHalfCeil, Math.trunc, roundHalfTrunc, roundExpand, roundHalfExpand, roundHalfEven ];
-
-const directionMap = {
-  previous: -1,
-  next: 1
-};
-
-function coerceRoundingIncInteger(options) {
-  const roundingInc = options.roundingIncrement;
-  return void 0 === roundingInc ? 1 : toIntegerWithTrunc(roundingInc, "roundingIncrement");
-}
-
-function coerceFractionalSecondDigits(options) {
-  let subsecDigits = options.fractionalSecondDigits;
-  if (void 0 !== subsecDigits) {
-    if ("number" != typeof subsecDigits) {
-      if ("auto" === toString(subsecDigits)) {
-        return;
-      }
-      throwRangeError(invalidEntity("fractionalSecondDigits", subsecDigits));
-    }
-    subsecDigits = clampEntity("fractionalSecondDigits", Math.floor(subsecDigits), 0, 9, 1);
-  }
-  return subsecDigits;
-}
-
-function coerceUnitOption(optionName, options, minUnit = 0, ensureDefined) {
-  let unitStr = options[optionName];
-  if (void 0 === unitStr) {
-    return ensureDefined ? minUnit : void 0;
-  }
-  if (unitStr = toString(unitStr), "auto" === unitStr) {
-    return ensureDefined ? minUnit : null;
-  }
-  let unit = unitNameMap[unitStr];
-  return void 0 === unit && (unit = durationFieldNamesAsc.indexOf(unitStr)), unit < 0 && throwRangeError(invalidChoice(optionName, unitStr, unitNameMap)), 
-  unit;
-}
-
-function coerceChoiceOption(optionName, enumNameMap, options, defaultChoice = 0) {
-  const enumArg = options[optionName];
-  if (void 0 === enumArg) {
-    return defaultChoice;
-  }
-  const enumStr = toString(enumArg);
-  const enumNum = enumNameMap[enumStr];
-  return void 0 === enumNum && throwRangeError(invalidChoice(optionName, enumStr, enumNameMap)), 
-  enumNum;
-}
-
-const coerceSmallestUnit = /*@__PURE__*/ bindArgs(coerceUnitOption, smallestUnitStr);
-
-const coerceLargestUnit = /*@__PURE__*/ bindArgs(coerceUnitOption, "largestUnit");
-
-const coerceTotalUnit = /*@__PURE__*/ bindArgs(coerceUnitOption, "unit");
-
-const coerceOverflow = /*@__PURE__*/ bindArgs(coerceChoiceOption, "overflow", overflowMap);
-
-const coerceEpochDisambig = /*@__PURE__*/ bindArgs(coerceChoiceOption, "disambiguation", epochDisambigMap);
-
-const coerceOffsetDisambig = /*@__PURE__*/ bindArgs(coerceChoiceOption, "offset", offsetDisambigMap);
-
-const coerceCalendarDisplay = /*@__PURE__*/ bindArgs(coerceChoiceOption, "calendarName", calendarDisplayMap);
-
-const coerceTimeZoneDisplay = /*@__PURE__*/ bindArgs(coerceChoiceOption, "timeZoneName", timeZoneDisplayMap);
-
-const coerceOffsetDisplay = /*@__PURE__*/ bindArgs(coerceChoiceOption, "offset", offsetDisplayMap);
-
-const coerceRoundingMode = /*@__PURE__*/ bindArgs(coerceChoiceOption, "roundingMode", roundingModeMap);
-
-const coerceDirection = /*@__PURE__*/ bindArgs(coerceChoiceOption, "direction", directionMap);
-
-function validateRoundingInc(roundingInc, smallestUnit, allowManyLargeUnits, solarMode) {
-  const upUnitNano = solarMode ? nanoInUtcDay : unitNanoMap[smallestUnit + 1];
-  if (upUnitNano) {
-    const unitNano = unitNanoMap[smallestUnit];
-    upUnitNano % ((roundingInc = clampEntity("roundingIncrement", roundingInc, 1, upUnitNano / unitNano - (solarMode ? 0 : 1), 1)) * unitNano) && throwRangeError(invalidEntity("roundingIncrement", roundingInc));
-  } else {
-    roundingInc = clampEntity("roundingIncrement", roundingInc, 1, allowManyLargeUnits ? 10 ** 9 : 1, 1);
-  }
-  return roundingInc;
-}
-
-function validateUnitRange(optionName, unit, minUnit, maxUnit) {
-  return null != unit && clampEntity(optionName, unit, minUnit, maxUnit, 1, unitNamesAsc), 
-  unit;
-}
-
-function checkLargestSmallestUnit(largestUnit, smallestUnit) {
-  smallestUnit > largestUnit && throwRangeError(flippedSmallestLargestUnit);
-}
-
-function refineDiffOptions(roundingModeInvert, options, defaultLargestUnit, maxUnit = 9, minUnit = 0, defaultRoundingMode = 4) {
-  options = normalizeOptions(options);
-  let largestUnit = coerceLargestUnit(options, minUnit);
-  let roundingInc = coerceRoundingIncInteger(options);
-  let roundingMode = coerceRoundingMode(options, defaultRoundingMode);
-  let smallestUnit = coerceSmallestUnit(options, minUnit, 1);
-  return largestUnit = validateUnitRange("largestUnit", largestUnit, minUnit, maxUnit), 
-  smallestUnit = validateUnitRange(smallestUnitStr, smallestUnit, minUnit, maxUnit), 
-  null == largestUnit ? largestUnit = Math.max(defaultLargestUnit, smallestUnit) : checkLargestSmallestUnit(largestUnit, smallestUnit), 
-  roundingInc = validateRoundingInc(roundingInc, smallestUnit, 1), roundingModeInvert && (roundingMode = (roundingMode => roundingMode < 4 ? (roundingMode + 2) % 4 : roundingMode)(roundingMode)), 
-  [ largestUnit, smallestUnit, roundingInc, roundingMode ];
-}
-
-function refineDurationRoundOptions(options, defaultLargestUnit, refineRelativeTo) {
-  options = normalizeOptionsOrString(options, smallestUnitStr);
-  let largestUnit = coerceLargestUnit(options);
-  const relativeToInternals = refineRelativeTo(options.relativeTo);
-  let roundingInc = coerceRoundingIncInteger(options);
-  const roundingMode = coerceRoundingMode(options, 7);
-  let smallestUnit = coerceSmallestUnit(options);
-  return void 0 === largestUnit && void 0 === smallestUnit && throwRangeError(missingSmallestLargestUnit), 
-  null == smallestUnit && (smallestUnit = 0), null == largestUnit && (largestUnit = Math.max(smallestUnit, defaultLargestUnit)), 
-  checkLargestSmallestUnit(largestUnit, smallestUnit), roundingInc = validateRoundingInc(roundingInc, smallestUnit, 1), 
-  roundingInc > 1 && smallestUnit > 5 && largestUnit !== smallestUnit && throwRangeError("For calendar units with roundingIncrement > 1, use largestUnit = smallestUnit"), 
-  [ largestUnit, smallestUnit, roundingInc, roundingMode, relativeToInternals ];
-}
-
-function refineRoundingOptions(options, maxUnit = 6, solarMode) {
-  let roundingInc = coerceRoundingIncInteger(options = normalizeOptionsOrString(options, smallestUnitStr));
-  const roundingMode = coerceRoundingMode(options, 7);
-  let smallestUnit = coerceSmallestUnit(options);
-  return smallestUnit = requirePropDefined(smallestUnitStr, smallestUnit), smallestUnit = validateUnitRange(smallestUnitStr, smallestUnit, 0, maxUnit), 
-  roundingInc = validateRoundingInc(roundingInc, smallestUnit, void 0, solarMode), 
-  [ smallestUnit, roundingInc, roundingMode ];
-}
-
-function refineTotalOptions(options, refineRelativeTo) {
-  const relativeToInternals = refineRelativeTo((options = normalizeOptionsOrString(options, "unit")).relativeTo);
-  let totalUnit = coerceTotalUnit(options);
-  return totalUnit = requirePropDefined("unit", totalUnit), [ totalUnit, relativeToInternals ];
-}
-
-function refineOverflowOptions(options) {
-  return void 0 === options ? 0 : coerceOverflow(requireObjectLike(options));
-}
-
-function refineZonedFieldOptions(options, defaultOffsetDisambig = 0) {
-  options = normalizeOptions(options);
-  const epochDisambig = coerceEpochDisambig(options);
-  const offsetDisambig = coerceOffsetDisambig(options, defaultOffsetDisambig);
-  return [ coerceOverflow(options), offsetDisambig, epochDisambig ];
-}
-
-function refineEpochDisambigOptions(options) {
-  return coerceEpochDisambig(normalizeOptions(options));
-}
-
-function refineTimeDisplayTuple(options, maxSmallestUnit = 4) {
-  const subsecDigits = coerceFractionalSecondDigits(options);
-  const roundingMode = coerceRoundingMode(options, 4);
-  const smallestUnit = coerceSmallestUnit(options);
-  return [ roundingMode, ...resolveSmallestUnitAndSubsecDigits(validateUnitRange(smallestUnitStr, smallestUnit, 0, maxSmallestUnit), subsecDigits) ];
-}
-
-function refineDateTimeDisplayOptions(options) {
-  return options = normalizeOptions(options), [ coerceCalendarDisplay(options), ...refineTimeDisplayTuple(options) ];
-}
-
-function refineDateDisplayOptions(options) {
-  return coerceCalendarDisplay(normalizeOptions(options));
-}
-
-function refineTimeDisplayOptions(options, maxSmallestUnit) {
-  return refineTimeDisplayTuple(normalizeOptions(options), maxSmallestUnit);
-}
-
-function refineZonedDateTimeDisplayOptions(options) {
-  options = normalizeOptions(options);
-  const calendarDisplay = coerceCalendarDisplay(options);
-  const subsecDigits = coerceFractionalSecondDigits(options);
-  const offsetDisplay = coerceOffsetDisplay(options);
-  const roundingMode = coerceRoundingMode(options, 4);
-  const smallestUnit = coerceSmallestUnit(options);
-  return [ calendarDisplay, coerceTimeZoneDisplay(options), offsetDisplay, roundingMode, ...resolveSmallestUnitAndSubsecDigits(validateUnitRange(smallestUnitStr, smallestUnit, 0, 4), subsecDigits) ];
-}
-
-function refineInstantDisplayOptions(options) {
-  const subsecDigits = coerceFractionalSecondDigits(options = normalizeOptions(options));
-  const roundingMode = coerceRoundingMode(options, 4);
-  const smallestUnit = coerceSmallestUnit(options);
-  return [ options.timeZone, roundingMode, ...resolveSmallestUnitAndSubsecDigits(validateUnitRange(smallestUnitStr, smallestUnit, 0, 4), subsecDigits) ];
-}
-
-function resolveSmallestUnitAndSubsecDigits(smallestUnit, subsecDigits) {
-  return null != smallestUnit ? [ unitNanoMap[smallestUnit], smallestUnit < 4 ? 9 - 3 * smallestUnit : -1 ] : [ void 0 === subsecDigits ? 1 : 10 ** (9 - subsecDigits), subsecDigits ];
-}
-
-function refineDirectionOptions(options) {
-  const normalizedOptions = normalizeOptionsOrString(options, "direction");
-  const res = coerceDirection(normalizedOptions, 0);
-  return res || throwRangeError(invalidEntity("direction", res)), res;
-}
-
 const invalidEntity = invalidEntity$1;
 
 const missingField = fieldName => `Missing ${fieldName}`;
@@ -3240,10 +2987,6 @@ const invalidTimeZone = calendarId => invalidEntity$1("TimeZone", calendarId);
 
 const outOfBoundsDate = "Out-of-bounds date";
 
-const missingSmallestLargestUnit = "Required smallestUnit or largestUnit";
-
-const flippedSmallestLargestUnit = "smallestUnit > largestUnit";
-
 const failedParse = s => `Cannot parse: ${s}`;
 
 const invalidSubstring = substring => `Invalid substring: ${substring}`;
@@ -3429,34 +3172,10 @@ function modTrunc(num, divisor) {
   return num % divisor || 0;
 }
 
-function roundExpand(num) {
-  return num < 0 ? Math.floor(num) : Math.ceil(num);
-}
-
 function fabricateNearHalfFraction(halfCompare, sign = 1) {
   return sign * (.5 + halfCompare / 5);
 }
 
-function roundHalfExpand(num) {
-  return Math.sign(num) * Math.round(Math.abs(num)) || 0;
-}
-
-function roundHalfFloor(num) {
-  return hasHalf(num) ? Math.floor(num) : Math.round(num);
-}
-
-function roundHalfCeil(num) {
-  return hasHalf(num) ? Math.ceil(num) : Math.round(num);
-}
-
-function roundHalfTrunc(num) {
-  return hasHalf(num) ? Math.trunc(num) || 0 : Math.round(num);
-}
-
-function roundHalfEven(num) {
-  return hasHalf(num) ? (num = Math.trunc(num) || 0) + num % 2 : Math.round(num);
-}
-
 function hasHalf(num) {
   return .5 === Math.abs(num % 1);
 }
@@ -3868,97 +3587,269 @@ function computeCalendarInLeapYear(calendar, isoDate) {
   return calendar ? calendar.q(year) : computeIsoInLeapYear(year);
 }
 
-function computeCalendarMonthsInYear(calendar, isoDate) {
-  const {year: year} = computeCalendarDateFields(calendar, isoDate);
-  return computeCalendarMonthsInYearForYear(calendar, year);
-}
+function computeCalendarMonthsInYear(calendar, isoDate) {
+  const {year: year} = computeCalendarDateFields(calendar, isoDate);
+  return computeCalendarMonthsInYearForYear(calendar, year);
+}
+
+function computeCalendarDaysInMonth(calendar, isoDate) {
+  const {year: year, month: month} = computeCalendarDateFields(calendar, isoDate);
+  return computeCalendarDaysInMonthForYearMonth(calendar, year, month);
+}
+
+function computeCalendarDaysInYear(calendar, isoDate) {
+  const {year: year} = computeCalendarDateFields(calendar, isoDate);
+  return calendar ? calendar.i(year) : computeIsoDaysInYear(year);
+}
+
+function computeCalendarDayOfYear(calendar, isoDate) {
+  if (!calendar) {
+    return computeIsoDayOfYear(isoDate);
+  }
+  const {year: year} = computeCalendarDateFields(calendar, isoDate);
+  const yearStartIsoDate = computeCalendarIsoFieldsFromParts(calendar, year, 1, 1);
+  return isoDateToEpochDays(isoDate) - isoDateToEpochDays(yearStartIsoDate) + 1;
+}
+
+function computeCalendarWeekOfYear(calendar, isoDate) {
+  return calendar === isoCalendarImpl ? computeIsoWeekFields(isoDate).weekOfYear : void 0;
+}
+
+function computeCalendarYearOfWeek(calendar, isoDate) {
+  return calendar === isoCalendarImpl ? computeIsoWeekFields(isoDate).yearOfWeek : void 0;
+}
+
+const durationFieldNamesAsc = /*@__PURE__*/ unitNamesAsc.map(unitName => unitName + "s");
+
+const durationGetters = /*@__PURE__*/ createPropGetters(durationFieldNamesAsc);
+
+const durationFieldNamesAlpha = /*@__PURE__*/ sortStrings(durationFieldNamesAsc);
+
+const durationTimeFieldNamesAsc = /*@__PURE__*/ durationFieldNamesAsc.slice(0, 6);
+
+const durationDateFieldNamesAsc = /*@__PURE__*/ durationFieldNamesAsc.slice(6);
+
+const durationCalendarFieldNamesAsc = /*@__PURE__*/ durationDateFieldNamesAsc.slice(1);
+
+const durationFieldDefaults = /*@__PURE__*/ zipPropsConst(durationFieldNamesAsc, 0);
+
+const durationTimeFieldDefaults = /*@__PURE__*/ zipPropsConst(durationTimeFieldNamesAsc, 0);
+
+const clearDurationFields = /*@__PURE__*/ bindArgs(zeroOutProps, durationFieldNamesAsc);
+
+function requirePropDefined(optionName, optionVal) {
+  return null == optionVal && throwRangeError(missingField(optionName)), optionVal;
+}
+
+const requireString = /*@__PURE__*/ bindArgs(requireType, "string");
+
+function requireType(typeName, arg, entityName = typeName) {
+  return typeof arg !== typeName && throwTypeError(invalidEntity(entityName, arg)), 
+  arg;
+}
+
+function requireNumberIsInteger(num, entityName = "number") {
+  return Number.isInteger(num) || throwRangeError(((entityName, num) => `Non-integer ${entityName}: ${num}`)(entityName, num)), 
+  num || 0;
+}
+
+function toString(arg) {
+  return "symbol" == typeof arg && throwTypeError("Cannot convert Symbol to string"), 
+  String(arg);
+}
+
+function toPrimitiveWithStringHint(arg) {
+  if (!isObjectLike$1(arg)) {
+    return arg;
+  }
+  const exoticToPrimitive = arg[Symbol.toPrimitive];
+  if (null != exoticToPrimitive) {
+    "function" != typeof exoticToPrimitive && throwTypeError();
+    const primitive = Reflect.apply(exoticToPrimitive, arg, [ "string" ]);
+    return isObjectLike$1(primitive) && throwTypeError(), primitive;
+  }
+  return Date.prototype[Symbol.toPrimitive].call(arg, "string");
+}
+
+function toBigInt(bi) {
+  return "boolean" == typeof bi ? BigInt(bi ? 1 : 0) : "string" == typeof bi ? BigInt(bi) : ("bigint" != typeof bi && throwTypeError(`Invalid bigint: ${bi}`), 
+  bi);
+}
+
+function toStrictInteger(arg, entityName) {
+  return requireNumberIsInteger(toFiniteNumber(arg, entityName), entityName);
+}
+
+const smallestUnitStr = "smallestUnit";
+
+const overflowMap = {
+  constrain: 0,
+  reject: 1
+};
+
+const epochDisambigMap = {
+  compatible: 0,
+  reject: 1,
+  earlier: 2,
+  later: 3
+};
+
+const offsetDisambigMap = {
+  reject: 0,
+  use: 1,
+  prefer: 2,
+  ignore: 3
+};
+
+const calendarDisplayMap = {
+  auto: 0,
+  never: 1,
+  critical: 2,
+  always: 3
+};
+
+const timeZoneDisplayMap = {
+  auto: 0,
+  never: 1,
+  critical: 2
+};
+
+const offsetDisplayMap = {
+  auto: 0,
+  never: 1
+};
+
+const roundingModeMap = {
+  floor: 0,
+  halfFloor: 1,
+  ceil: 2,
+  halfCeil: 3,
+  trunc: 4,
+  halfTrunc: 5,
+  expand: 6,
+  halfExpand: 7,
+  halfEven: 8
+};
+
+const roundingModeFuncs = [ Math.floor, num => hasHalf(num) ? Math.floor(num) : Math.round(num), Math.ceil, num => hasHalf(num) ? Math.ceil(num) : Math.round(num), Math.trunc, num => hasHalf(num) ? Math.trunc(num) || 0 : Math.round(num), num => num < 0 ? Math.floor(num) : Math.ceil(num), num => Math.sign(num) * Math.round(Math.abs(num)) || 0, num => hasHalf(num) ? (num = Math.trunc(num) || 0) + num % 2 : Math.round(num) ];
 
-function computeCalendarDaysInMonth(calendar, isoDate) {
-  const {year: year, month: month} = computeCalendarDateFields(calendar, isoDate);
-  return computeCalendarDaysInMonthForYearMonth(calendar, year, month);
-}
+const directionMap = {
+  previous: -1,
+  next: 1
+};
 
-function computeCalendarDaysInYear(calendar, isoDate) {
-  const {year: year} = computeCalendarDateFields(calendar, isoDate);
-  return calendar ? calendar.i(year) : computeIsoDaysInYear(year);
+function coerceRoundingIncInteger(options) {
+  const roundingInc = options.roundingIncrement;
+  return void 0 === roundingInc ? 1 : toIntegerWithTrunc(roundingInc, "roundingIncrement");
 }
 
-function computeCalendarDayOfYear(calendar, isoDate) {
-  if (!calendar) {
-    return computeIsoDayOfYear(isoDate);
+function coerceFractionalSecondDigits(options) {
+  let subsecDigits = options.fractionalSecondDigits;
+  if (void 0 !== subsecDigits) {
+    if ("number" != typeof subsecDigits) {
+      if ("auto" === toString(subsecDigits)) {
+        return;
+      }
+      throwRangeError(invalidEntity("fractionalSecondDigits", subsecDigits));
+    }
+    subsecDigits = clampEntity("fractionalSecondDigits", Math.floor(subsecDigits), 0, 9, 1);
   }
-  const {year: year} = computeCalendarDateFields(calendar, isoDate);
-  const yearStartIsoDate = computeCalendarIsoFieldsFromParts(calendar, year, 1, 1);
-  return isoDateToEpochDays(isoDate) - isoDateToEpochDays(yearStartIsoDate) + 1;
+  return subsecDigits;
 }
 
-function computeCalendarWeekOfYear(calendar, isoDate) {
-  return calendar === isoCalendarImpl ? computeIsoWeekFields(isoDate).weekOfYear : void 0;
+function coerceUnitOption(optionName, options, minUnit = 0, ensureDefined) {
+  let unitStr = options[optionName];
+  if (void 0 === unitStr) {
+    return ensureDefined ? minUnit : void 0;
+  }
+  if (unitStr = toString(unitStr), "auto" === unitStr) {
+    return ensureDefined ? minUnit : null;
+  }
+  let unit = unitNameMap[unitStr];
+  return void 0 === unit && (unit = durationFieldNamesAsc.indexOf(unitStr)), unit < 0 && throwRangeError(invalidChoice(optionName, unitStr, unitNameMap)), 
+  unit;
 }
 
-function computeCalendarYearOfWeek(calendar, isoDate) {
-  return calendar === isoCalendarImpl ? computeIsoWeekFields(isoDate).yearOfWeek : void 0;
+function coerceChoiceOption(optionName, enumNameMap, options, defaultChoice = 0) {
+  const enumArg = options[optionName];
+  if (void 0 === enumArg) {
+    return defaultChoice;
+  }
+  const enumStr = toString(enumArg);
+  const enumNum = enumNameMap[enumStr];
+  return void 0 === enumNum && throwRangeError(invalidChoice(optionName, enumStr, enumNameMap)), 
+  enumNum;
 }
 
-const durationFieldNamesAsc = /*@__PURE__*/ unitNamesAsc.map(unitName => unitName + "s");
+const coerceSmallestUnit = /*@__PURE__*/ bindArgs(coerceUnitOption, smallestUnitStr);
 
-const durationGetters = /*@__PURE__*/ createPropGetters(durationFieldNamesAsc);
+const coerceLargestUnit = /*@__PURE__*/ bindArgs(coerceUnitOption, "largestUnit");
 
-const durationFieldNamesAlpha = /*@__PURE__*/ sortStrings(durationFieldNamesAsc);
+const coerceTotalUnit = /*@__PURE__*/ bindArgs(coerceUnitOption, "unit");
 
-const durationTimeFieldNamesAsc = /*@__PURE__*/ durationFieldNamesAsc.slice(0, 6);
+const coerceOverflow = /*@__PURE__*/ bindArgs(coerceChoiceOption, "overflow", overflowMap);
 
-const durationDateFieldNamesAsc = /*@__PURE__*/ durationFieldNamesAsc.slice(6);
+const coerceEpochDisambig = /*@__PURE__*/ bindArgs(coerceChoiceOption, "disambiguation", epochDisambigMap);
 
-const durationCalendarFieldNamesAsc = /*@__PURE__*/ durationDateFieldNamesAsc.slice(1);
+const coerceOffsetDisambig = /*@__PURE__*/ bindArgs(coerceChoiceOption, "offset", offsetDisambigMap);
 
-const durationFieldDefaults = /*@__PURE__*/ zipPropsConst(durationFieldNamesAsc, 0);
+const coerceCalendarDisplay = /*@__PURE__*/ bindArgs(coerceChoiceOption, "calendarName", calendarDisplayMap);
 
-const durationTimeFieldDefaults = /*@__PURE__*/ zipPropsConst(durationTimeFieldNamesAsc, 0);
+const coerceTimeZoneDisplay = /*@__PURE__*/ bindArgs(coerceChoiceOption, "timeZoneName", timeZoneDisplayMap);
 
-const clearDurationFields = /*@__PURE__*/ bindArgs(zeroOutProps, durationFieldNamesAsc);
+const coerceOffsetDisplay = /*@__PURE__*/ bindArgs(coerceChoiceOption, "offset", offsetDisplayMap);
 
-function requirePropDefined(optionName, optionVal) {
-  return null == optionVal && throwRangeError(missingField(optionName)), optionVal;
-}
+const coerceRoundingMode = /*@__PURE__*/ bindArgs(coerceChoiceOption, "roundingMode", roundingModeMap);
 
-const requireString = /*@__PURE__*/ bindArgs(requireType, "string");
+const coerceDirection = /*@__PURE__*/ bindArgs(coerceChoiceOption, "direction", directionMap);
 
-function requireType(typeName, arg, entityName = typeName) {
-  return typeof arg !== typeName && throwTypeError(invalidEntity(entityName, arg)), 
-  arg;
+function normalizeOptionsOrString(options, optionName) {
+  return "string" == typeof options ? ((optionName, optionVal) => {
+    const res = Object.create(null);
+    return res[optionName] = optionVal, res;
+  })(optionName, options) : requireObjectLike(options);
 }
 
-function requireNumberIsInteger(num, entityName = "number") {
-  return Number.isInteger(num) || throwRangeError(((entityName, num) => `Non-integer ${entityName}: ${num}`)(entityName, num)), 
-  num || 0;
+function validateRoundingInc(roundingInc, smallestUnit, allowManyLargeUnits, solarMode) {
+  const upUnitNano = solarMode ? nanoInUtcDay : unitNanoMap[smallestUnit + 1];
+  if (upUnitNano) {
+    const unitNano = unitNanoMap[smallestUnit];
+    upUnitNano % ((roundingInc = clampEntity("roundingIncrement", roundingInc, 1, upUnitNano / unitNano - (solarMode ? 0 : 1), 1)) * unitNano) && throwRangeError(invalidEntity("roundingIncrement", roundingInc));
+  } else {
+    roundingInc = clampEntity("roundingIncrement", roundingInc, 1, allowManyLargeUnits ? 10 ** 9 : 1, 1);
+  }
+  return roundingInc;
 }
 
-function toString(arg) {
-  return "symbol" == typeof arg && throwTypeError("Cannot convert Symbol to string"), 
-  String(arg);
+function validateUnitRange(optionName, unit, minUnit, maxUnit) {
+  return null != unit && clampEntity(optionName, unit, minUnit, maxUnit, 1, unitNamesAsc), 
+  unit;
 }
 
-function toPrimitiveWithStringHint(arg) {
-  if (!isObjectLike$1(arg)) {
-    return arg;
-  }
-  const exoticToPrimitive = arg[Symbol.toPrimitive];
-  if (null != exoticToPrimitive) {
-    "function" != typeof exoticToPrimitive && throwTypeError();
-    const primitive = Reflect.apply(exoticToPrimitive, arg, [ "string" ]);
-    return isObjectLike$1(primitive) && throwTypeError(), primitive;
-  }
-  return Date.prototype[Symbol.toPrimitive].call(arg, "string");
+function checkLargestSmallestUnit(largestUnit, smallestUnit) {
+  smallestUnit > largestUnit && throwRangeError("smallestUnit > largestUnit");
 }
 
-function toBigInt(bi) {
-  return "boolean" == typeof bi ? BigInt(bi ? 1 : 0) : "string" == typeof bi ? BigInt(bi) : ("bigint" != typeof bi && throwTypeError(`Invalid bigint: ${bi}`), 
-  bi);
+function refineDiffOptions(roundingModeInvert, options, defaultLargestUnit, maxUnit = 9, minUnit = 0, defaultRoundingMode = 4) {
+  options = normalizeOptions(options);
+  let largestUnit = coerceLargestUnit(options, minUnit);
+  let roundingInc = coerceRoundingIncInteger(options);
+  let roundingMode = coerceRoundingMode(options, defaultRoundingMode);
+  let smallestUnit = coerceSmallestUnit(options, minUnit, 1);
+  return largestUnit = validateUnitRange("largestUnit", largestUnit, minUnit, maxUnit), 
+  smallestUnit = validateUnitRange(smallestUnitStr, smallestUnit, minUnit, maxUnit), 
+  null == largestUnit ? largestUnit = Math.max(defaultLargestUnit, smallestUnit) : checkLargestSmallestUnit(largestUnit, smallestUnit), 
+  roundingInc = validateRoundingInc(roundingInc, smallestUnit, 1), roundingModeInvert && (roundingMode = (roundingMode => roundingMode < 4 ? (roundingMode + 2) % 4 : roundingMode)(roundingMode)), 
+  [ largestUnit, smallestUnit, roundingInc, roundingMode ];
 }
 
-function toStrictInteger(arg, entityName) {
-  return requireNumberIsInteger(toFiniteNumber(arg, entityName), entityName);
+function refineRoundingOptions(options, maxUnit = 6, solarMode) {
+  let roundingInc = coerceRoundingIncInteger(options = normalizeOptionsOrString(options, smallestUnitStr));
+  const roundingMode = coerceRoundingMode(options, 7);
+  let smallestUnit = coerceSmallestUnit(options);
+  return smallestUnit = requirePropDefined(smallestUnitStr, smallestUnit), smallestUnit = validateUnitRange(smallestUnitStr, smallestUnit, 0, maxUnit), 
+  roundingInc = validateRoundingInc(roundingInc, smallestUnit, void 0, solarMode), 
+  [ smallestUnit, roundingInc, roundingMode ];
 }
 
 function combineDateAndTime(isoDate, time) {
@@ -4308,7 +4199,7 @@ function getStartOfDayInstantFor(timeZone, isoDateTime) {
 }
 
 function moveYearMonth(calendar, isoDate, durationSlots, overflow = 0) {
-  computeDurationSign(durationSlots) && getMaxDurationUnit(durationSlots) < 8 && throwRangeError("Cannot use small units");
+  computeDurationSign(durationSlots) && clampEntity("unit", getMaxDurationUnit(durationSlots), 8, 9, 1, durationFieldNamesAsc);
   const first = checkIsoDateInBounds(moveToStartOfMonth(calendar, isoDate));
   return moveToStartOfMonth(calendar, moveDate(calendar, first, durationSlots, overflow));
 }
@@ -4346,7 +4237,7 @@ function moveTime(timeFields, durationFields) {
 }
 
 function moveEpochNano(epochNano, durationFields) {
-  return moveEpochNanoByNano(epochNano, (durationHasDateParts(fields = durationFields) && throwRangeError("Cannot use large units"), 
+  return moveEpochNanoByNano(epochNano, (clampEntity("unit", getMaxDurationUnit(fields = durationFields), 0, 5, 1, durationFieldNamesAsc), 
   durationTimeToBigNano(fields)));
   var fields;
 }
@@ -4692,7 +4583,7 @@ const maxDurationSeconds = 2 ** 53;
 
 function addDurationsWithoutRelativeTo(doSubtract, slots, otherSlots) {
   const maxUnit = Math.max(getMaxDurationUnit(slots), getMaxDurationUnit(otherSlots));
-  return maxUnit > 6 && throwRangeError("Cannot use large units"), ((doSubtract, slots, otherSlots, maxUnit) => createDurationSlots(validateDurationFields(((a, b, largestUnit, doSubtract) => {
+  return clampEntity("unit", maxUnit, 0, 6, 1, durationFieldNamesAsc), ((doSubtract, slots, otherSlots, maxUnit) => createDurationSlots(validateDurationFields(((a, b, largestUnit, doSubtract) => {
     const combined = durationDayTimeToBigNano(a) + durationDayTimeToBigNano(b) * BigInt(doSubtract ? -1 : 1);
     return Number.isFinite(Number(combined / bigNanoInUtcDay)) || throwRangeError(outOfBoundsDate), 
     {
@@ -4704,7 +4595,19 @@ function addDurationsWithoutRelativeTo(doSubtract, slots, otherSlots) {
 
 function roundDuration(refineRelativeTo, slots, options) {
   const durationLargestUnit = getMaxDurationUnit(slots);
-  const [largestUnit, smallestUnit, roundingInc, roundingMode, relativeToSlots] = refineDurationRoundOptions(options, durationLargestUnit, refineRelativeTo);
+  const [largestUnit, smallestUnit, roundingInc, roundingMode, relativeToSlots] = ((options, defaultLargestUnit, refineRelativeTo) => {
+    options = normalizeOptionsOrString(options, smallestUnitStr);
+    let largestUnit = coerceLargestUnit(options);
+    const relativeToInternals = refineRelativeTo(options.relativeTo);
+    let roundingInc = coerceRoundingIncInteger(options);
+    const roundingMode = coerceRoundingMode(options, 7);
+    let smallestUnit = coerceSmallestUnit(options);
+    return void 0 === largestUnit && void 0 === smallestUnit && throwRangeError("Required smallestUnit or largestUnit"), 
+    null == smallestUnit && (smallestUnit = 0), null == largestUnit && (largestUnit = Math.max(smallestUnit, defaultLargestUnit)), 
+    checkLargestSmallestUnit(largestUnit, smallestUnit), roundingInc = validateRoundingInc(roundingInc, smallestUnit, 1), 
+    roundingInc > 1 && smallestUnit > 5 && largestUnit !== smallestUnit && throwRangeError("For calendar units with roundingIncrement > 1, use largestUnit = smallestUnit"), 
+    [ largestUnit, smallestUnit, roundingInc, roundingMode, relativeToInternals ];
+  })(options, durationLargestUnit, refineRelativeTo);
   if (!relativeToSlots && Math.max(durationLargestUnit, largestUnit) <= 6) {
     return createDurationSlots(validateDurationFields(((durationFields, largestUnit, smallestUnit, roundingInc, roundingMode) => {
       const roundedBigNano = roundBigNanoToInc(durationDayTimeToBigNano(durationFields), computeBigNanoInc(smallestUnit, roundingInc), roundingMode);
@@ -4984,6 +4887,21 @@ function readAndRefineBagFields(bag, validFieldNames, fieldRefiners, requiredFie
   res;
 }
 
+function refineOverflowOptions(options) {
+  return void 0 === options ? 0 : coerceOverflow(requireObjectLike(options));
+}
+
+function refineZonedFieldOptions(options, defaultOffsetDisambig = 0) {
+  options = normalizeOptions(options);
+  const epochDisambig = coerceEpochDisambig(options);
+  const offsetDisambig = coerceOffsetDisambig(options, defaultOffsetDisambig);
+  return [ coerceOverflow(options), offsetDisambig, epochDisambig ];
+}
+
+function refineEpochDisambigOptions(options) {
+  return coerceEpochDisambig(normalizeOptions(options));
+}
+
 function refineCalendarDateFields(fields, calendar, allowMissingDay) {
   const eraOrigins = getCalendarEraOrigins(calendar);
   void 0 !== fields.year || void 0 !== fields.era && void 0 !== fields.eraYear || throwTypeError(missingYear(eraOrigins)), 
@@ -5093,8 +5011,32 @@ const timeZonePeriodDaysByName = {
 
 const minPossibleTransitionSec = -388152e4;
 
+function refineTimeDisplayTuple(options, maxSmallestUnit = 4) {
+  const subsecDigits = coerceFractionalSecondDigits(options);
+  const roundingMode = coerceRoundingMode(options, 4);
+  const smallestUnit = coerceSmallestUnit(options);
+  return [ roundingMode, ...resolveSmallestUnitAndSubsecDigits(validateUnitRange(smallestUnitStr, smallestUnit, 0, maxSmallestUnit), subsecDigits) ];
+}
+
+function refineDateDisplayOptions(options) {
+  return coerceCalendarDisplay(normalizeOptions(options));
+}
+
+function refineTimeDisplayOptions(options, maxSmallestUnit) {
+  return refineTimeDisplayTuple(normalizeOptions(options), maxSmallestUnit);
+}
+
+function resolveSmallestUnitAndSubsecDigits(smallestUnit, subsecDigits) {
+  return null != smallestUnit ? [ unitNanoMap[smallestUnit], smallestUnit < 4 ? 9 - 3 * smallestUnit : -1 ] : [ void 0 === subsecDigits ? 1 : 10 ** (9 - subsecDigits), subsecDigits ];
+}
+
 function formatInstantIso(refineTimeZoneString, instantSlots, options) {
-  const [timeZoneArg, roundingMode, nanoInc, subsecDigits] = refineInstantDisplayOptions(options);
+  const [timeZoneArg, roundingMode, nanoInc, subsecDigits] = (options => {
+    const subsecDigits = coerceFractionalSecondDigits(options = normalizeOptions(options));
+    const roundingMode = coerceRoundingMode(options, 4);
+    const smallestUnit = coerceSmallestUnit(options);
+    return [ options.timeZone, roundingMode, ...resolveSmallestUnitAndSubsecDigits(validateUnitRange(smallestUnitStr, smallestUnit, 0, 4), subsecDigits) ];
+  })(options);
   const providedTimeZone = void 0 !== timeZoneArg;
   return ((providedTimeZone, timeZone, epochNano, roundingMode, nanoInc, subsecDigits) => {
     epochNano = roundBigNanoToDayOriginInc(epochNano, BigInt(nanoInc), roundingMode);
@@ -5104,7 +5046,15 @@ function formatInstantIso(refineTimeZoneString, instantSlots, options) {
 }
 
 function formatZonedDateTimeIso(zonedDateTimeSlots0, options) {
-  const displayOptions = refineZonedDateTimeDisplayOptions(options);
+  const displayOptions = (options => {
+    options = normalizeOptions(options);
+    const calendarDisplay = coerceCalendarDisplay(options);
+    const subsecDigits = coerceFractionalSecondDigits(options);
+    const offsetDisplay = coerceOffsetDisplay(options);
+    const roundingMode = coerceRoundingMode(options, 4);
+    const smallestUnit = coerceSmallestUnit(options);
+    return [ calendarDisplay, coerceTimeZoneDisplay(options), offsetDisplay, roundingMode, ...resolveSmallestUnitAndSubsecDigits(validateUnitRange(smallestUnitStr, smallestUnit, 0, 4), subsecDigits) ];
+  })(options);
   return ((calendar, timeZoneId, timeZone, epochNano, calendarDisplay, timeZoneDisplay, offsetDisplay, roundingMode, nanoInc, subsecDigits) => {
     epochNano = roundBigNanoToDayOriginInc(epochNano, BigInt(nanoInc), roundingMode);
     const offsetNano = timeZone.B(epochNano);
@@ -5113,7 +5063,7 @@ function formatZonedDateTimeIso(zonedDateTimeSlots0, options) {
 }
 
 function formatPlainDateTimeIso(plainDateTimeSlots0, options) {
-  const displayOptions = refineDateTimeDisplayOptions(options);
+  const displayOptions = (options => (options = normalizeOptions(options), [ coerceCalendarDisplay(options), ...refineTimeDisplayTuple(options) ]))(options);
   return ((calendar, isoDateTime, calendarDisplay, roundingMode, nanoInc, subsecDigits) => formatIsoDateTimeFields(roundDateTimeToInc(isoDateTime, nanoInc, roundingMode), subsecDigits) + formatCalendar(calendar, calendarDisplay))(plainDateTimeSlots0.calendar, plainDateTimeSlots0, ...displayOptions);
 }
 
@@ -5918,7 +5868,11 @@ function computeMonthCode(calendar, year, month) {
 }
 
 function totalDuration(refineRelativeTo, slots, options) {
-  const [totalUnit, relativeToSlots] = refineTotalOptions(options, refineRelativeTo);
+  const [totalUnit, relativeToSlots] = ((options, refineRelativeTo) => {
+    const relativeToInternals = refineRelativeTo((options = normalizeOptionsOrString(options, "unit")).relativeTo);
+    let totalUnit = coerceTotalUnit(options);
+    return totalUnit = requirePropDefined("unit", totalUnit), [ totalUnit, relativeToInternals ];
+  })(options, refineRelativeTo);
   const maxDurationUnit = getMaxDurationUnit(slots);
   const maxUnit = Math.max(totalUnit, maxDurationUnit);
   const isZoned = relativeToSlots && isZonedEpochSlots(relativeToSlots);
@@ -6146,6 +6100,12 @@ function zonedDateTimeWithPlainTime(zonedDateTimeSlots, plainTimeFields) {
   createZonedEpochNanoSlots(epochNano, timeZone, zonedDateTimeSlots.calendar);
 }
 
+function refineDirectionOptions(options) {
+  const normalizedOptions = normalizeOptionsOrString(options, "direction");
+  const res = coerceDirection(normalizedOptions, 0);
+  return res || throwRangeError(invalidEntity("direction", res)), res;
+}
+
 function getCurrentIsoDateTime(timeZone) {
   const epochNano = getCurrentEpochNano();
   const offsetNano = timeZone.B(epochNano);
@@ -7704,6 +7664,60 @@ class GeoLocation {
         }
         this.timeZoneId = timeZoneId;
     }
+    /**
+     * A method that will return the location's local mean time offset in milliseconds from local
+     * [standard time](https://en.wikipedia.org/wiki/Standard_time). The globe is split into 360&deg;, with
+     * 15&deg; per hour of the day. For a local that is at a longitude that is evenly divisible by 15
+     * (longitude % 15 == 0), at solar noon (with adjustment for the
+     * [equation of time](https://en.wikipedia.org/wiki/Equation_of_time)) the sun should be directly overhead,
+     * so a user who is 1&deg; west of this will have noon at 4 minutes after standard time noon, and conversely,
+     * a user who is 1&deg; east of the 15&deg; longitude will have noon at 11:56 AM.
+     * @param instant the instant at which to read the time zone offset (DST is taken into account)
+     * @return the offset in milliseconds not accounting for Daylight saving time. A positive value will be returned
+     *         East of the 15&deg; timezone line, and a negative value West of it.
+     */
+    getLocalMeanTimeOffset(instant) {
+        const timezoneOffsetMillis = instant.toZonedDateTimeISO(this.timeZoneId).offsetNanoseconds / 1e6;
+        return this.longitude * 4 * 60 * 1000 - timezoneOffsetMillis;
+    }
+    /**
+     * Adjust the date for [antimeridian](https://en.wikipedia.org/wiki/180th_meridian) crossover. This is
+     * needed to deal with edge cases such as Samoa that use a different calendar date than expected based on their
+     * geographic location.
+     *
+     * The actual Time Zone offset may deviate from the expected offset based on the longitude. Since the 'absolute time'
+     * calculations are always based on longitudinal offset from UTC for a given date, the date is presumed to only
+     * increase East of the Prime Meridian, and to only decrease West of it. For Time Zones that cross the antimeridian,
+     * the date will be artificially adjusted before calculation to conform with this presumption.
+     *
+     * For example, Apia, Samoa with a longitude of -171.75 uses a local offset of +14:00. When calculating sunrise for
+     * 2018-02-03, the calculator should operate using 2018-02-02 since the expected zone is -11. After determining the
+     * UTC time, the local DST offset of [UTC+14:00](https://en.wikipedia.org/wiki/UTC%2B14:00) should be applied
+     * to bring the date back to 2018-02-03.
+     * @param date the date, at the start of which (in this location's time zone) the offset is read
+     * @return the number of days to adjust the date This will typically be 0 unless the date crosses the antimeridian
+     */
+    getAntimeridianAdjustment(date) {
+        // Time zone offsets range from -12:00 to +14:00, so an offset of 20 hours
+        // or more needs a longitude of at least 120 degrees east or 90 degrees
+        // west. Skip resolving the time zone for the rest of the world.
+        if (this.longitude > -90 && this.longitude < 120) {
+            return 0;
+        }
+        const midnight = date.toZonedDateTime(this.timeZoneId).toInstant();
+        const localHoursOffset = this.getLocalMeanTimeOffset(midnight) / 3600000;
+        if (localHoursOffset >= 20) {
+            // a location far east using a time zone from across the antimeridian to
+            // the west (none are known today, but better safe than sorry)
+            return 1; // roll the date forward a day
+        }
+        else if (localHoursOffset <= -20) {
+            // a location far west using a time zone from across the antimeridian to
+            // the east, such as Samoa or Kiritimati
+            return -1; // roll the date back a day
+        }
+        return 0; // 99.999% of the world will have no adjustment
+    }
 }
 /**
  * The commonly used average solar refraction. Calendrical Calculations lists a more accurate global average of
@@ -8056,8 +8070,15 @@ class NOAACalculator {
      * @return the adjusted Calendar
      */
     getAdjustedDate() {
-        return this.date;
+        if (this.adjustedDate === undefined) {
+            const offset = this.geoLocation.getAntimeridianAdjustment(this.date);
+            this.adjustedDate =
+                offset === 0 ? this.date : this.date.add({ days: offset });
+        }
+        return this.adjustedDate;
     }
+    /** Memoized result of {@link getAdjustedDate} */
+    adjustedDate;
     /**
      * Method to return the adjustment to the zenith required to account for the elevation. Since a person at a higher
      * elevation can see farther below the horizon, the calculation for sunrise / sunset is calculated below the horizon
@@ -8337,8 +8358,11 @@ class NOAACalculator {
             year -= 1;
             month += 12;
         }
+        // Integer division, as in the Java original: truncating `2 - a + a / 4`
+        // as a whole is off by one day whenever `a` is not a multiple of 4
+        // (e.g. every year from 1900 through 1999).
         const a = Math.trunc(year / 100);
-        const b = Math.trunc(2 - a + a / 4);
+        const b = 2 - a + Math.trunc(a / 4);
         return (Math.floor(365.25 * (year + 4716)) +
             Math.floor(30.6001 * (month + 1)) +
             day +
@@ -12500,7 +12524,7 @@ function getHolidaysOnDate(date, il) {
     }
     return events.filter(ev => ev.observedIn(il));
 }
-const { CHAG, LIGHT_CANDLES_TZEIS: LIGHT_CANDLES_TZEIS$2, CHANUKAH_CANDLES: CHANUKAH_CANDLES$1, BEHAB: BEHAB$1, MINOR_FAST: MINOR_FAST$1, SPECIAL_SHABBAT: SPECIAL_SHABBAT$1, MAJOR_FAST: MAJOR_FAST$1, MINOR_HOLIDAY: MINOR_HOLIDAY$1, EREV: EREV$1, } = flags;
+const { CHAG, LIGHT_CANDLES_TZEIS: LIGHT_CANDLES_TZEIS$2, CHANUKAH_CANDLES: CHANUKAH_CANDLES$1, BEHAB: BEHAB$1, MINOR_FAST: MINOR_FAST$1, SPECIAL_SHABBAT: SPECIAL_SHABBAT$1, MAJOR_FAST: MAJOR_FAST$1, MINOR_HOLIDAY: MINOR_HOLIDAY$1, EREV: EREV$1, SHABBAT_MEVARCHIM: SHABBAT_MEVARCHIM$1, } = flags;
 const SUN = 0;
 const TUE = 2;
 const THU = 4;
@@ -12513,18 +12537,44 @@ function addToMap(map, ...events) {
         const key = ev.date.toString();
         const arr = map.get(key);
         if (arr !== undefined) {
-            if (arr[0].hasFlag('EREV')) {
-                arr.unshift(ev);
-            }
-            else {
-                arr.push(ev);
-            }
+            arr.push(ev);
         }
         else {
             map.set(key, [ev]);
         }
     }
 }
+/** @internal */
+const TIME_OF_DAY_MORNING = 0;
+/** @internal */
+const TIME_OF_DAY_MEVARCHIM = 1;
+/** @internal */
+const TIME_OF_DAY_DAY = 2;
+/** @internal */
+const TIME_OF_DAY_EVENING = 3;
+/**
+ * Approximate time of day of an event, used to order events on the same date.
+ * - Morning: special Shabbatot (tied to the Torah or Haftarah reading), minor
+ *   fasts (which begin at dawn) and Birkat Hachamah (recited at sunrise)
+ * - Shabbat Mevarchim, announced in synagogue after the Torah reading
+ * - Day: everything else
+ * - Evening: Erev holidays, Chanukah candle-lighting and Leil Selichot
+ * @internal
+ */
+function timeOfDay(ev) {
+    const mask = ev.getFlags();
+    const desc = ev.getDesc();
+    if (mask & (EREV$1 | CHANUKAH_CANDLES$1) || desc === holidayDesc.LEIL_SELICHOT) {
+        return TIME_OF_DAY_EVENING;
+    }
+    if (mask & (SPECIAL_SHABBAT$1 | MINOR_FAST$1) || desc === holidayDesc.BIRKAT_HACHAMAH) {
+        return TIME_OF_DAY_MORNING;
+    }
+    if (mask & SHABBAT_MEVARCHIM$1) {
+        return TIME_OF_DAY_MEVARCHIM;
+    }
+    return TIME_OF_DAY_DAY;
+}
 function addStaticHolidays(map, year) {
     for (const h of staticHolidays) {
         const hd = new HDate(h.dd, h.mm, year);
@@ -12693,6 +12743,9 @@ function getHolidaysForYear_(year) {
         const hd = new HDate(birkatHaChama);
         addToMap(map, new HolidayEvent(hd, holidayDesc.BIRKAT_HACHAMAH, MINOR_HOLIDAY$1, { emoji: '☀️' }));
     }
+    for (const arr of map.values()) {
+        arr.sort((a, b) => timeOfDay(a) - timeOfDay(b));
+    }
     yearCache.set(year, map);
     return map;
 }
@@ -14548,9 +14601,26 @@ function calendar(options = {}) {
         let candlesEv;
         const holidays0 = holidaysYear.get(hd.toString()) || [];
         const holidays = holidays0.filter(ev => ev.observedIn(il));
+        // On Shabbat, events tied to the morning Torah reading and announcements
+        // in synagogue come first: the parsha, special Shabbatot such as
+        // Shabbat Shekalim, then the Molad and Shabbat Mevarchim
+        if (options.sedrot && isSaturday) {
+            const parsha0 = sedra.lookup(abs);
+            if (!parsha0.chag) {
+                evts.push(new ParshaEvent(parsha0));
+            }
+        }
+        let mevarchim = isSaturday && (options.molad || options.shabbatMevarchim)
+            ? makeMoladAndMevarchimChodesh(hd, options)
+            : [];
         for (const ev of holidays) {
+            if (mevarchim.length && timeOfDay(ev) > TIME_OF_DAY_MEVARCHIM) {
+                evts.push(...mevarchim);
+                mevarchim = [];
+            }
             candlesEv = appendHolidayAndRelated(candlesEv, evts, ev, options, isFriday, isSaturday, hasUserMask);
         }
+        evts.push(...mevarchim);
         const mm = hd.getMonth();
         const dd = hd.getDate();
         // When Erev Pesach falls on Shabbat, burning chametz is moved to Friday.
@@ -14560,12 +14630,6 @@ function calendar(options = {}) {
                 evts.push(biurEv);
             }
         }
-        if (options.sedrot && isSaturday) {
-            const parsha0 = sedra.lookup(abs);
-            if (!parsha0.chag) {
-                evts.push(new ParshaEvent(parsha0));
-            }
-        }
         if (options.yizkor) {
             if ((mm === months.TISHREI && (dd === 10 || dd === 22)) ||
                 (mm === NISAN && dd === (il ? 21 : 22)) ||
@@ -14592,22 +14656,6 @@ function calendar(options = {}) {
             const omerEv = makeOmerEvent(hd, omer, options);
             evts.push(omerEv);
         }
-        if (isSaturday && (options.molad || options.shabbatMevarchim)) {
-            const events = makeMoladAndMevarchimChodesh(hd, options);
-            evts.push(...events);
-        }
-        if (options.kiddushLevanaMaharil && dd >= 9 && dd <= 17) {
-            // The event usually falls between the 11th and the 16th, but may be
-            // moved back to candle-lighting before a Shabbat or Yom Tov
-            const monthKey = hyear * 100 + mm;
-            if (monthKey !== kiddushLevanaMonth) {
-                kiddushLevanaMonth = monthKey;
-                kiddushLevanaEv = makeKiddushLevanaEvent(hyear, mm, options);
-            }
-            if (kiddushLevanaEv?.getDate().abs() === abs) {
-                evts.push(kiddushLevanaEv);
-            }
-        }
         if (!candlesEv && options.candlelighting && (isFriday || isSaturday)) {
             candlesEv = makeCandleEvent(undefined, hd, options, isFriday, isSaturday);
             if (isFriday && candlesEv && sedra) {
@@ -14629,6 +14677,18 @@ function calendar(options = {}) {
         if (candlesEv) {
             evts.push(candlesEv);
         }
+        if (options.kiddushLevanaMaharil && dd >= 9 && dd <= 17) {
+            // The event usually falls between the 11th and the 16th, but may be
+            // moved back to candle-lighting before a Shabbat or Yom Tov
+            const monthKey = hyear * 100 + mm;
+            if (monthKey !== kiddushLevanaMonth) {
+                kiddushLevanaMonth = monthKey;
+                kiddushLevanaEv = makeKiddushLevanaEvent(hyear, mm, options);
+            }
+            if (kiddushLevanaEv?.getDate().abs() === abs) {
+                insertTimedEvent(evts, prevEventsLength, kiddushLevanaEv);
+            }
+        }
         if (options.addHebrewDates ||
             (options.addHebrewDatesForEvents &&
                 prevEventsLength !== evts.length - numDailyLearning)) {
@@ -14934,6 +14994,23 @@ function setOptionsFromMask(options) {
         options.kiddushLevanaMaharil = true;
     return m;
 }
+/**
+ * Inserts `ev` into today's events (those at index `start` and beyond)
+ * just before the first `TimedEvent` that occurs later, or appends it.
+ * Unlike other timed events, Latest Kiddush Levana may fall at dawn,
+ * at candle-lighting or late at night, so its position can't be fixed.
+ */
+function insertTimedEvent(events, start, ev) {
+    const time = ev.eventTime.getTime();
+    for (let i = start; i < events.length; i++) {
+        const other = events[i];
+        if (other instanceof TimedEvent && other.eventTime.getTime() > time) {
+            events.splice(i, 0, ev);
+            return;
+        }
+    }
+    events.push(ev);
+}
 /**
  * Appends the Event `ev` to the `events` array. Also may add related
  * timed events like candle-lighting or fast start/end