@hebcal/core 6.14.2 → 6.14.4

package/dist/bundle.js

@@ -1,9 +1,9 @@
-/*! @hebcal/core v6.14.2, distributed under GPLv2 or later https://www.gnu.org/licenses/gpl-2.0.txt */
+/*! @hebcal/core v6.14.4, 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.2';
+const version = '6.14.4';
 
 /*! @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);
 }
@@ -3892,73 +3611,245 @@ function computeCalendarDayOfYear(calendar, isoDate) {
   return isoDateToEpochDays(isoDate) - isoDateToEpochDays(yearStartIsoDate) + 1;
 }
 
-function computeCalendarWeekOfYear(calendar, isoDate) {
-  return calendar === isoCalendarImpl ? computeIsoWeekFields(isoDate).weekOfYear : void 0;
+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) ];
+
+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 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);
@@ -12459,27 +12419,152 @@ types['1311'] = types['1221'];
 types['1721'] = types['170'];
 const sedraCache = new QuickLRU({ maxSize: 120 });
 /**
- * Convenience function to create an instance of {@link Sedra} or reuse a
- * previously created and cached instance for the same year and schedule.
+ * Convenience function to create an instance of {@link Sedra} or reuse a
+ * previously created and cached instance for the same year and schedule.
+ *
+ * Prefer this over `new Sedra(...)` when calling repeatedly — an internal
+ * LRU cache (~120 entries) avoids recomputing the keviyah-specific schedule.
+ * @example
+ * import {getSedra, HDate, months} from '@hebcal/core';
+ * const sedra = getSedra(5784, false);
+ * const {parsha} = sedra.lookup(new HDate(15, months.CHESHVAN, 5784));
+ * console.log(parsha); // ['Vayera']
+ * @param hyear Hebrew year
+ * @param il Use Israel sedra schedule (`false` for Diaspora)
+ */
+function getSedra(hyear, il) {
+    const cacheKey = `${hyear}-${il ? 1 : 0}`;
+    let sedra = sedraCache.get(cacheKey);
+    if (!sedra) {
+        sedra = new Sedra(hyear, il);
+        sedraCache.set(cacheKey, sedra);
+    }
+    return sedra;
+}
+
+const { HAVDALAH, CANDLE_LIGHTING } = holidayDesc;
+/**
+ * Base class for events that have an associated wall-clock time and
+ * geographic location — for example, candle lighting, havdalah, and
+ * fast begin/end times.
+ *
+ * Stores both a `Date` (`eventTime`) and pre-formatted 24-hour
+ * (`eventTimeStr`) and locale-aware (`fmtTime`) strings. May reference a
+ * "linked" event such as the holiday whose candle-lighting time this
+ * represents.
+ */
+class TimedEvent extends Event {
+    /**
+     * Normally created by {@link calendar} rather than directly.
+     * @param date Hebrew date the event occurs
+     * @param desc Description (not translated)
+     * @param mask optional holiday flags
+     * @param eventTime the exact moment of the event
+     * @param location geographic location used to format the time
+     * @param linkedEvent optional event this time is associated with
+     * @param options optional; `locale` and `hour12` affect {@link fmtTime}
+     */
+    constructor(date, desc, mask, eventTime, location, linkedEvent, options) {
+        super(date, desc, mask);
+        this.eventTime = Zmanim.roundTime(eventTime);
+        this.location = location;
+        const timeFormat = location.getTimeFormatter();
+        this.eventTimeStr = Zmanim.formatTime(this.eventTime, timeFormat);
+        const opts = { ...options, location };
+        this.fmtTime = reformatTimeStr(this.eventTimeStr, 'pm', opts);
+        if (linkedEvent !== undefined) {
+            this.linkedEvent = linkedEvent;
+        }
+    }
+    /**
+     * @param [locale] Optional locale name (defaults to empty locale)
+     */
+    render(locale) {
+        return `${Locale.gettext(this.getDesc(), locale)}: ${this.fmtTime}`;
+    }
+    /**
+     * Returns translation of "Candle lighting" without the time.
+     * @param [locale] Optional locale name (defaults to empty locale)
+     */
+    renderBrief(locale) {
+        return Locale.gettext(this.getDesc(), locale);
+    }
+    getCategories() {
+        const desc = this.getDesc();
+        switch (desc) {
+            // LIGHT_CANDLES or LIGHT_CANDLES_TZEIS
+            case CANDLE_LIGHTING:
+                return ['candles'];
+            // YOM_TOV_ENDS
+            case HAVDALAH:
+                return ['havdalah'];
+            // flags.MINOR_FAST or flags.MAJOR_FAST
+            case holidayDesc.FAST_BEGINS:
+            case holidayDesc.FAST_ENDS:
+                return ['zmanim', 'fast'];
+            case holidayDesc.SOF_ZMAN_ACHILAT_CHAMETZ:
+                return ['zmanim', 'achilasChametz'];
+            case holidayDesc.BIUR_CHAMETZ:
+                return ['zmanim', 'biurChametz'];
+        }
+        /* NOTREACHED */
+        return ['unknown'];
+    }
+}
+/**
+ * Candle-lighting event for the eve of Shabbat or a Yom Tov.
+ *
+ * Generated by {@link calendar} when `options.candlelighting`
+ * is `true` and `options.location` is provided. By default candle lighting
+ * occurs 18 minutes before sundown in the Diaspora and 20 minutes before
+ * sundown in Israel (40 minutes in Jerusalem; 30 minutes in Haifa and
+ * Zikhron Ya'akov), configurable via `options.candleLightingMins`.
+ */
+class CandleLightingEvent extends TimedEvent {
+    constructor(date, mask, eventTime, location, linkedEvent, options) {
+        super(date, CANDLE_LIGHTING, mask, eventTime, location, linkedEvent, options);
+    }
+    getEmoji() {
+        return '🕯️';
+    }
+}
+/**
+ * Havdalah event marking the end of Shabbat or a Yom Tov.
  *
- * Prefer this over `new Sedra(...)` when calling repeatedly — an internal
- * LRU cache (~120 entries) avoids recomputing the keviyah-specific schedule.
- * @example
- * import {getSedra, HDate, months} from '@hebcal/core';
- * const sedra = getSedra(5784, false);
- * const {parsha} = sedra.lookup(new HDate(15, months.CHESHVAN, 5784));
- * console.log(parsha); // ['Vayera']
- * @param hyear Hebrew year
- * @param il Use Israel sedra schedule (`false` for Diaspora)
+ * Generated by {@link calendar} when `options.candlelighting`
+ * is `true` and `options.location` is provided. By default Havdalah is
+ * calculated by *tzeit hakochavim* (8.5° solar depression); pass
+ * `options.havdalahMins` to use a fixed minute offset instead, or
+ * `options.havdalahDeg` to use a different degree.
  */
-function getSedra(hyear, il) {
-    const cacheKey = `${hyear}-${il ? 1 : 0}`;
-    let sedra = sedraCache.get(cacheKey);
-    if (!sedra) {
-        sedra = new Sedra(hyear, il);
-        sedraCache.set(cacheKey, sedra);
+class HavdalahEvent extends TimedEvent {
+    constructor(date, mask, eventTime, location, havdalahMins, linkedEvent, options) {
+        super(date, HAVDALAH, mask, eventTime, location, linkedEvent, options);
+        if (havdalahMins) {
+            this.havdalahMins = havdalahMins;
+        }
+    }
+    /**
+     * @param [locale] Optional locale name (defaults to empty locale)
+     */
+    render(locale) {
+        return `${this.renderBrief(locale)}: ${this.fmtTime}`;
+    }
+    /**
+     * Returns translation of "Havdalah" without the time.
+     * @param [locale] Optional locale name (defaults to empty locale)
+     */
+    renderBrief(locale) {
+        let str = Locale.gettext(this.getDesc(), locale);
+        if (this.havdalahMins) {
+            const min = Locale.gettext('min', locale);
+            str += ` (${this.havdalahMins} ${min})`;
+        }
+        return str;
+    }
+    getEmoji() {
+        return '✨';
     }
-    return sedra;
 }
 
 const ykk = 'Yom Kippur Katan';
@@ -12577,18 +12662,82 @@ 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_DAWN = 0;
+/** @internal */
+const TIME_OF_DAY_MORNING = 1;
+/** @internal */
+const TIME_OF_DAY_MEVARCHIM = 2;
+/** @internal */
+const TIME_OF_DAY_DAY = 3;
+/** @internal */
+const TIME_OF_DAY_MIDDAY = 4;
+/** @internal */
+const TIME_OF_DAY_LEARNING = 5;
+/** @internal */
+const TIME_OF_DAY_EVENING = 6;
+/** @internal */
+const TIME_OF_DAY_NIGHT = 7;
+/**
+ * Approximate time of day of an event, used to order events on the same date.
+ * Events of equal rank keep the order in which they were created, and timed
+ * events of equal rank are ordered by their time.
+ * - Dawn: Fast begins for a minor fast, and a Latest Kiddush Levana before
+ *   noon (which is never later than _alot hashachar_)
+ * - Morning: the parsha, special Shabbatot (tied to the Torah or Haftarah
+ *   reading), minor fasts (which begin at dawn) and Birkat Hachamah
+ *   (recited at sunrise)
+ * - Molad and Shabbat Mevarchim, announced in synagogue after the Torah
+ *   reading
+ * - Day: everything else, including Yizkor and the Omer count
+ * - Midday: the deadlines for eating and burning chametz
+ * - Daily learning
+ * - Evening: Erev holidays, Chanukah candle-lighting and Leil Selichot
+ * - Night: other timed events such as candle-lighting, Havdalah,
+ *   Fast ends, and a Latest Kiddush Levana after noon
+ * @internal
+ */
+function timeOfDay(ev) {
+    if (ev instanceof TimedEvent) {
+        return timedEventTimeOfDay(ev);
+    }
+    const desc = ev.getDesc();
+    if (ev.hasAnyFlag('EREV', 'CHANUKAH_CANDLES') || desc === holidayDesc.LEIL_SELICHOT) {
+        return TIME_OF_DAY_EVENING;
+    }
+    if (ev.hasAnyFlag('PARSHA_HASHAVUA', 'SPECIAL_SHABBAT', 'MINOR_FAST') ||
+        desc === holidayDesc.BIRKAT_HACHAMAH) {
+        return TIME_OF_DAY_MORNING;
+    }
+    if (ev.hasAnyFlag('SHABBAT_MEVARCHIM', 'MOLAD')) {
+        return TIME_OF_DAY_MEVARCHIM;
+    }
+    if (ev.hasAnyFlag('DAILY_LEARNING', 'DAF_YOMI', 'MISHNA_YOMI', 'NACH_YOMI', 'YERUSHALMI_YOMI')) {
+        return TIME_OF_DAY_LEARNING;
+    }
+    return TIME_OF_DAY_DAY;
+}
+function timedEventTimeOfDay(ev) {
+    const desc = ev.getDesc();
+    if (desc === holidayDesc.SOF_ZMAN_ACHILAT_CHAMETZ || desc === holidayDesc.BIUR_CHAMETZ) {
+        return TIME_OF_DAY_MIDDAY;
+    }
+    // A minor fast begins at dawn, but Tish'a B'Av at sunset the day before.
+    // Latest Kiddush Levana is either before dawn or after nightfall.
+    if (desc === holidayDesc.FAST_BEGINS || ev.hasFlag('KIDDUSH_LEVANA')) {
+        // `eventTimeStr` is 24-hour local time; some engines format midnight as 24:00
+        const hour = Number.parseInt(ev.eventTimeStr, 10) % 24;
+        return hour < 12 ? TIME_OF_DAY_DAWN : TIME_OF_DAY_NIGHT;
+    }
+    return TIME_OF_DAY_NIGHT;
+}
 function addStaticHolidays(map, year) {
     for (const h of staticHolidays) {
         const hd = new HDate(h.dd, h.mm, year);
@@ -12757,6 +12906,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;
 }
@@ -12961,131 +13113,6 @@ function isFastDay(date, il) {
     return events.some(ev => ev.hasAnyFlag('MAJOR_FAST', 'MINOR_FAST') && !ev.hasFlag('EREV'));
 }
 
-const { HAVDALAH, CANDLE_LIGHTING } = holidayDesc;
-/**
- * Base class for events that have an associated wall-clock time and
- * geographic location — for example, candle lighting, havdalah, and
- * fast begin/end times.
- *
- * Stores both a `Date` (`eventTime`) and pre-formatted 24-hour
- * (`eventTimeStr`) and locale-aware (`fmtTime`) strings. May reference a
- * "linked" event such as the holiday whose candle-lighting time this
- * represents.
- */
-class TimedEvent extends Event {
-    /**
-     * Normally created by {@link calendar} rather than directly.
-     * @param date Hebrew date the event occurs
-     * @param desc Description (not translated)
-     * @param mask optional holiday flags
-     * @param eventTime the exact moment of the event
-     * @param location geographic location used to format the time
-     * @param linkedEvent optional event this time is associated with
-     * @param options optional; `locale` and `hour12` affect {@link fmtTime}
-     */
-    constructor(date, desc, mask, eventTime, location, linkedEvent, options) {
-        super(date, desc, mask);
-        this.eventTime = Zmanim.roundTime(eventTime);
-        this.location = location;
-        const timeFormat = location.getTimeFormatter();
-        this.eventTimeStr = Zmanim.formatTime(this.eventTime, timeFormat);
-        const opts = { ...options, location };
-        this.fmtTime = reformatTimeStr(this.eventTimeStr, 'pm', opts);
-        if (linkedEvent !== undefined) {
-            this.linkedEvent = linkedEvent;
-        }
-    }
-    /**
-     * @param [locale] Optional locale name (defaults to empty locale)
-     */
-    render(locale) {
-        return `${Locale.gettext(this.getDesc(), locale)}: ${this.fmtTime}`;
-    }
-    /**
-     * Returns translation of "Candle lighting" without the time.
-     * @param [locale] Optional locale name (defaults to empty locale)
-     */
-    renderBrief(locale) {
-        return Locale.gettext(this.getDesc(), locale);
-    }
-    getCategories() {
-        const desc = this.getDesc();
-        switch (desc) {
-            // LIGHT_CANDLES or LIGHT_CANDLES_TZEIS
-            case CANDLE_LIGHTING:
-                return ['candles'];
-            // YOM_TOV_ENDS
-            case HAVDALAH:
-                return ['havdalah'];
-            // flags.MINOR_FAST or flags.MAJOR_FAST
-            case holidayDesc.FAST_BEGINS:
-            case holidayDesc.FAST_ENDS:
-                return ['zmanim', 'fast'];
-            case holidayDesc.SOF_ZMAN_ACHILAT_CHAMETZ:
-                return ['zmanim', 'achilasChametz'];
-            case holidayDesc.BIUR_CHAMETZ:
-                return ['zmanim', 'biurChametz'];
-        }
-        /* NOTREACHED */
-        return ['unknown'];
-    }
-}
-/**
- * Candle-lighting event for the eve of Shabbat or a Yom Tov.
- *
- * Generated by {@link calendar} when `options.candlelighting`
- * is `true` and `options.location` is provided. By default candle lighting
- * occurs 18 minutes before sundown in the Diaspora and 20 minutes before
- * sundown in Israel (40 minutes in Jerusalem; 30 minutes in Haifa and
- * Zikhron Ya'akov), configurable via `options.candleLightingMins`.
- */
-class CandleLightingEvent extends TimedEvent {
-    constructor(date, mask, eventTime, location, linkedEvent, options) {
-        super(date, CANDLE_LIGHTING, mask, eventTime, location, linkedEvent, options);
-    }
-    getEmoji() {
-        return '🕯️';
-    }
-}
-/**
- * Havdalah event marking the end of Shabbat or a Yom Tov.
- *
- * Generated by {@link calendar} when `options.candlelighting`
- * is `true` and `options.location` is provided. By default Havdalah is
- * calculated by *tzeit hakochavim* (8.5° solar depression); pass
- * `options.havdalahMins` to use a fixed minute offset instead, or
- * `options.havdalahDeg` to use a different degree.
- */
-class HavdalahEvent extends TimedEvent {
-    constructor(date, mask, eventTime, location, havdalahMins, linkedEvent, options) {
-        super(date, HAVDALAH, mask, eventTime, location, linkedEvent, options);
-        if (havdalahMins) {
-            this.havdalahMins = havdalahMins;
-        }
-    }
-    /**
-     * @param [locale] Optional locale name (defaults to empty locale)
-     */
-    render(locale) {
-        return `${this.renderBrief(locale)}: ${this.fmtTime}`;
-    }
-    /**
-     * Returns translation of "Havdalah" without the time.
-     * @param [locale] Optional locale name (defaults to empty locale)
-     */
-    renderBrief(locale) {
-        let str = Locale.gettext(this.getDesc(), locale);
-        if (this.havdalahMins) {
-            const min = Locale.gettext('min', locale);
-            str += ` (${this.havdalahMins} ${min})`;
-        }
-        return str;
-    }
-    getEmoji() {
-        return '✨';
-    }
-}
-
 const { LIGHT_CANDLES: LIGHT_CANDLES$1, LIGHT_CANDLES_TZEIS: LIGHT_CANDLES_TZEIS$1 } = flags;
 const { FAST_BEGINS, FAST_ENDS } = holidayDesc;
 /** @internal */
@@ -14522,6 +14549,16 @@ class MevarchimChodeshEvent extends Event {
  * * `options.addHebrewDates` - print the Hebrew date for the entire date range
  * * `options.addHebrewDatesForEvents` - print the Hebrew date for dates with some events
  *
+ * Events are returned in date order. Events on the same date are ordered by
+ * approximate time of day: timed events before dawn (Fast begins, an early
+ * Latest Kiddush Levana), then the parsha, special Shabbatot and minor fasts,
+ * then the Molad and Shabbat Mevarchim, then other holidays, Yizkor and the
+ * Omer, then the chametz deadlines on Erev Pesach, then daily learning, then
+ * evening holidays (Erev holidays, Chanukah), and finally the remaining timed
+ * events (candle-lighting, Havdalah, Fast ends) in order of time. When
+ * `options.addHebrewDates` or `options.addHebrewDatesForEvents` adds a Hebrew
+ * date event, it comes first.
+ *
  * Lastly, translation and transliteration of event titles is controlled by
  * `options.locale` and the {@link Locale} API.
  * `@hebcal/core` supports three locales by default:
@@ -14612,6 +14649,15 @@ function calendar(options = {}) {
         let candlesEv;
         const holidays0 = holidaysYear.get(hd.toString()) || [];
         const holidays = holidays0.filter(ev => ev.observedIn(il));
+        if (options.sedrot && isSaturday) {
+            const parsha0 = sedra.lookup(abs);
+            if (!parsha0.chag) {
+                evts.push(new ParshaEvent(parsha0));
+            }
+        }
+        if (isSaturday && (options.molad || options.shabbatMevarchim)) {
+            evts.push(...makeMoladAndMevarchimChodesh(hd, options));
+        }
         for (const ev of holidays) {
             candlesEv = appendHolidayAndRelated(candlesEv, evts, ev, options, isFriday, isSaturday, hasUserMask);
         }
@@ -14624,12 +14670,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)) ||
@@ -14656,22 +14696,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) {
@@ -14693,6 +14717,19 @@ 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) {
+                evts.push(kiddushLevanaEv);
+            }
+        }
+        sortByTimeOfDay(evts, prevEventsLength);
         if (options.addHebrewDates ||
             (options.addHebrewDatesForEvents &&
                 prevEventsLength !== evts.length - numDailyLearning)) {
@@ -14998,6 +15035,29 @@ function setOptionsFromMask(options) {
         options.kiddushLevanaMaharil = true;
     return m;
 }
+function compareTimeOfDay(a, b) {
+    const diff = timeOfDay(a) - timeOfDay(b);
+    if (diff !== 0) {
+        return diff;
+    }
+    if (a instanceof TimedEvent && b instanceof TimedEvent) {
+        return a.eventTime.getTime() - b.eventTime.getTime();
+    }
+    return 0;
+}
+/**
+ * Sorts today's events (those at index `start` and beyond) in place by
+ * {@link timeOfDay}. The sort is stable, so events of equal rank keep the
+ * order in which they were added, e.g. Yizkor after its holiday.
+ */
+function sortByTimeOfDay(events, start) {
+    if (events.length - start < 2) {
+        return;
+    }
+    const today = events.splice(start);
+    today.sort(compareTimeOfDay);
+    events.push(...today);
+}
 /**
  * Appends the Event `ev` to the `events` array. Also may add related
  * timed events like candle-lighting or fast start/end