@hebcal/core 6.8.2 → 6.9.1

package/dist/bundle.js

@@ -1,11 +1,11 @@
-/*! @hebcal/core v6.8.2, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+/*! @hebcal/core v6.9.1, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
 var hebcal = (function (exports) {
 'use strict';
 
 /** DO NOT EDIT THIS AUTO-GENERATED FILE! */
-const version = '6.8.2';
+const version = '6.9.1';
 
-/*! @hebcal/hdate v0.22.5, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+/*! @hebcal/hdate v0.22.7, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
 /** @private */
 const lengths = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
 /** @private */
@@ -47,8 +47,13 @@ const ABS_2SEP1752 = 639785;
  * Formerly in namespace, now top-level
  */
 /**
- * Returns true if the Gregorian year is a leap year
+ * Returns true if the Gregorian year is a leap year.
+ *
+ * Uses the proleptic Gregorian rule (divisible by 4, except centuries
+ * that are not divisible by 400) for **all** years, including those
+ * before the Gregorian calendar was adopted in 1582.
  * @param year Gregorian year
+ * @returns `true` if February has 29 days in `year`
  * @example
  * isGregLeapYear(2000); // true
  * isGregLeapYear(2020); // true
@@ -62,6 +67,7 @@ function isGregLeapYear(year) {
  * Number of days in the Gregorian month for given year
  * @param month Gregorian month (1=January, 12=December)
  * @param year Gregorian year
+ * @returns an integer 28-31
  * @example
  * daysInGregMonth(2, 2024); // 29 (February in a leap year)
  * daysInGregMonth(2, 2023); // 28
@@ -72,7 +78,10 @@ function daysInGregMonth(month, year) {
     return monthLengths[+isGregLeapYear(year)][month];
 }
 /**
- * Returns true if the object is a Javascript Date
+ * Returns true if the object is a Javascript `Date`.
+ *
+ * Note that this only tests the type: an invalid date such as
+ * `new Date('foo')` is still a `Date` and returns `true`.
  * @example
  * isDate(new Date()); // true
  * isDate('2024-01-01'); // false
@@ -99,8 +108,20 @@ function toFixed(year, month, day) {
         day);
 }
 /**
- * Converts Gregorian date to absolute R.D. (Rata Die) days
+ * Converts Gregorian date to absolute R.D. (Rata Die) days.
+ * R.D. 1 is the imaginary date Monday, January 1, 1 (Gregorian).
+ *
+ * Only the local-time year, month and day of `date` are used; hours,
+ * minutes, seconds and milliseconds are ignored.
+ *
+ * Dates are interpreted on the **proleptic** Gregorian calendar, which
+ * applies the Gregorian rules uniformly to every year without the
+ * ten-day discontinuity of the Gregorian Reformation of 1582.
  * @param date Gregorian date
+ * @returns R.D. number of days
+ * @throws {TypeError} if `date` is not a `Date`
+ * @throws {RangeError} if `date` is an Invalid Date
+ * @see {@link abs2greg}
  * @example
  * greg2abs(new Date(2008, 10, 13)); // 733359 (13 November 2008)
  * greg2abs(new Date(2005, 3, 2)); // 732038 (2 April 2005)
@@ -131,7 +152,14 @@ function greg2abs(date) {
  * For example, the 15th of Cheshvan 5769 began at sundown on
  * 12 November 2008 and continues through 13 November 2008. This
  * function would return only the date 13 November 2008.
+ *
+ * The returned `Date` is in the local (i.e. host system) time zone with
+ * hours, minutes, seconds and milliseconds all set to zero, and is on the
+ * **proleptic** Gregorian calendar (see {@link greg2abs}).
  * @param abs - R.D. number of days
+ * @returns Gregorian date at local midnight
+ * @throws {TypeError} if `abs` is not a number
+ * @see {@link greg2abs}
  * @example
  * const abs = hebrew2abs(5769, months.CHESHVAN, 15);
  * const date = abs2greg(abs); // 13 November 2008
@@ -161,11 +189,26 @@ function abs2greg(abs) {
     return dt;
 }
 
-/*! @hebcal/hdate v0.22.5, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
-
+/*! @hebcal/hdate v0.22.7, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
 /* eslint-disable @typescript-eslint/no-namespace */
 /**
- * Gregorian date helper functions
+ * Gregorian date helper functions.
+ *
+ * These are aliases retained for backwards compatibility. Each member
+ * simply forwards to the identically-behaving top-level function, which
+ * is the preferred form in new code because it tree-shakes cleanly:
+ *
+ * | Namespace | Top-level equivalent |
+ * | --- | --- |
+ * | `greg.abs2greg` | {@link abs2greg} |
+ * | `greg.daysInMonth` | {@link daysInGregMonth} |
+ * | `greg.greg2abs` | {@link greg2abs} |
+ * | `greg.isDate` | {@link isDate} |
+ * | `greg.isLeapYear` | {@link isGregLeapYear} |
+ * @example
+ * import {greg} from '@hebcal/hdate';
+ * greg.greg2abs(new Date(2008, 10, 13)); // 733359
+ * greg.isLeapYear(2024);                 // true
  */
 exports.greg = void 0;
 (function (greg) {
@@ -176,7 +219,7 @@ exports.greg.greg2abs = greg2abs;
 exports.greg.isDate = isDate;
 exports.greg.isLeapYear = isGregLeapYear;
 
-/*! @hebcal/hdate v0.22.5, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+/*! @hebcal/hdate v0.22.7, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
 /**
  * Removes niqqud from Hebrew string
  * @example
@@ -192,8 +235,7 @@ function hebrewStripNikkud(str) {
     return a.replace(/[\u0590-\u05bd]/g, '').replace(/[\u05bf-\u05c7]/g, '');
 }
 
-/*! @hebcal/hdate v0.22.5, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
-
+/*! @hebcal/hdate v0.22.7, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
 /*
  * More minimal HDate
  */
@@ -211,9 +253,21 @@ const SHVAT$1 = 11;
 const ADAR_I$2 = 12;
 const ADAR_II$2 = 13;
 /**
- * Hebrew months of the year (NISAN=1, TISHREI=7)
+ * Hebrew months of the year (NISAN=1, TISHREI=7).
+ *
+ * Months are numbered from Nisan, the first month of the ecclesiastical
+ * year, even though the civil year begins with Tishrei on Rosh Hashanah
+ * (see {@link HDate.getTishreiMonth} for Tishrei-based numbering).
+ *
+ * In a common year month 12 is Adar; in a leap year month 12 is Adar I
+ * and month 13 is Adar II.
  * @readonly
  * @enum {number}
+ * @example
+ * import {months, getMonthName} from '@hebcal/hdate';
+ * months.TISHREI;                     // 7
+ * getMonthName(months.ADAR_I, 5784);  // 'Adar I' (5784 is a leap year)
+ * getMonthName(months.ADAR_I, 5783);  // 'Adar'
  */
 const months = {
     /** Nissan / ניסן */
@@ -289,11 +343,19 @@ function assertNumber(n, name) {
 }
 /**
  * Converts Hebrew date to R.D. (Rata Die) fixed days.
- * R.D. 1 is the imaginary date Monday, January 1, 1 on the Gregorian
- * Calendar.
+ * R.D. 1 is the imaginary date Monday, January 1, 1 on the (proleptic)
+ * Gregorian Calendar.
+ *
+ * R.D. is the common currency between the two calendars: convert a
+ * Hebrew date to R.D. with this function, then to a Gregorian `Date`
+ * with {@link abs2greg}.
  * @param year Hebrew year
- * @param month Hebrew month
+ * @param month Hebrew month (1=NISAN, 7=TISHREI)
  * @param day Hebrew date (1-30)
+ * @returns R.D. number of days
+ * @throws {TypeError} if any argument is not a number
+ * @throws {RangeError} if `year` is less than 1
+ * @see {@link abs2hebrew}
  * @example
  * import {hebrew2abs, months} from '@hebcal/hdate';
  * hebrew2abs(5769, months.CHESHVAN, 15); // 733359
@@ -331,6 +393,10 @@ function newYear(year) {
 /**
  * Converts absolute R.D. days to Hebrew date
  * @param abs absolute R.D. days
+ * @returns the Hebrew date as a plain `{yy, mm, dd}` object
+ * @throws {TypeError} if `abs` is not a number
+ * @throws {RangeError} if `abs` precedes the Hebrew epoch
+ * @see {@link hebrew2abs}
  * @example
  * abs2hebrew(733359); // {yy: 5769, mm: 8, dd: 15} (15 Cheshvan 5769)
  */
@@ -354,8 +420,13 @@ function abs2hebrew(abs) {
     return { yy: year, mm: month, dd: day };
 }
 /**
- * Returns true if Hebrew year is a leap year
+ * Returns true if Hebrew year is a leap year.
+ *
+ * The Hebrew calendar is lunisolar: 7 years out of every 19-year
+ * (Metonic) cycle are leap years, in which a 13th month (Adar I) is
+ * inserted before Adar so that Nisan stays in the spring.
  * @param year Hebrew year
+ * @returns `true` if `year` has 13 months
  * @example
  * isLeapYear(5783); // false
  * isLeapYear(5784); // true
@@ -364,8 +435,13 @@ function isLeapYear(year) {
     return (1 + year * 7) % 19 < 7;
 }
 /**
- * Number of months in this Hebrew year (either 12 or 13 depending on leap year)
+ * Number of months in this Hebrew year (either 12 or 13 depending on leap year).
+ *
+ * Because Adar II is the last month of a leap year and Adar the last
+ * month of a common year, this doubles as "the number of the final
+ * month", which is how the anniversary rules identify Adar.
  * @param year Hebrew year
+ * @returns 12 or 13
  * @example
  * monthsInYear(5783); // 12
  * monthsInYear(5784); // 13
@@ -379,9 +455,15 @@ const STATIC_DAYS_IN_MONTH = [
     0, 30, 29, 30, 29, 30, 29, 30, 0, 0, 29, 30, 0, 29,
 ];
 /**
- * Number of days in Hebrew month in a given year (29 or 30)
+ * Number of days in Hebrew month in a given year (29 or 30).
+ *
+ * Most months have a fixed length. Cheshvan and Kislev vary to absorb
+ * the 353/354/355-day variation of the Hebrew year (see
+ * {@link longCheshvan} and {@link shortKislev}), and Adar I has 30 days
+ * in a leap year but 29 in a common year.
  * @param month Hebrew month (e.g. months.TISHREI)
  * @param year Hebrew year
+ * @returns an integer 29-30
  * @example
  * import {daysInMonth, months} from '@hebcal/hdate';
  * daysInMonth(months.CHESHVAN, 5769); // 29
@@ -400,8 +482,14 @@ function daysInMonth(month, year) {
 /**
  * Returns a transliterated string name of Hebrew month in year,
  * for example 'Elul' or 'Cheshvan'.
+ *
+ * The year matters only for the 12th month, which is named `'Adar'` in a
+ * common year and `'Adar I'` in a leap year. To translate the result into
+ * another locale, pass it to {@link Locale.gettext}.
  * @param month Hebrew month (e.g. months.TISHREI)
  * @param year Hebrew year
+ * @returns transliterated month name
+ * @throws {TypeError} if `month` is out of range 1-14
  * @example
  * import {getMonthName, months} from '@hebcal/hdate';
  * getMonthName(months.CHESHVAN, 5769); // 'Cheshvan'
@@ -418,8 +506,15 @@ function getMonthName(month, year) {
 }
 /**
  * Days from sunday prior to start of Hebrew calendar to mean
- * conjunction of Tishrei in Hebrew YEAR
+ * conjunction of Tishrei in Hebrew YEAR, after applying the four
+ * postponement rules (dechiyot) that fix Rosh Hashanah.
+ *
+ * This is an implementation detail of the calendar arithmetic rather
+ * than a supported entry point; prefer {@link hebrew2abs} or
+ * {@link daysInYear}. Results for years 5000-6999 are cached.
+ * @internal
  * @param year Hebrew year
+ * @returns days elapsed since the epoch
  */
 function elapsedDays(year) {
     if (year >= ED_CACHE_MIN && year <= ED_CACHE_MAX) {
@@ -468,7 +563,12 @@ function elapsedDays0(year) {
  * Number of days in the hebrew YEAR.
  * A common Hebrew calendar year can have a length of 353, 354 or 355 days
  * A leap Hebrew calendar year can have a length of 383, 384 or 385 days
+ *
+ * The three lengths within each group are deficient, regular and
+ * complete years respectively; see {@link shortKislev} and
+ * {@link longCheshvan} for which month absorbs the difference.
  * @param year Hebrew year
+ * @returns 353-355 in a common year, 383-385 in a leap year
  * @example
  * daysInYear(5783); // 355
  * daysInYear(5784); // 383 (leap year)
@@ -477,8 +577,13 @@ function daysInYear(year) {
     return elapsedDays(year + 1) - elapsedDays(year);
 }
 /**
- * true if Cheshvan is long in Hebrew year
+ * true if Cheshvan is long in Hebrew year.
+ *
+ * Cheshvan normally has 29 days, but gains a 30th in a "complete"
+ * (שלמה) year, one of the two ways the calendar stretches a year to
+ * keep Rosh Hashanah off a forbidden weekday.
  * @param year Hebrew year
+ * @returns `true` if Cheshvan has 30 days
  * @example
  * longCheshvan(5783); // true
  * longCheshvan(5784); // false
@@ -487,8 +592,13 @@ function longCheshvan(year) {
     return daysInYear(year) % 10 === 5;
 }
 /**
- * true if Kislev is short in Hebrew year
+ * true if Kislev is short in Hebrew year.
+ *
+ * Kislev normally has 30 days, but drops to 29 in a "deficient" (חסרה)
+ * year, the counterpart to {@link longCheshvan} that shortens a year by
+ * a day.
  * @param year Hebrew year
+ * @returns `true` if Kislev has 29 days
  * @example
  * shortKislev(5783); // false
  * shortKislev(5784); // true
@@ -497,8 +607,18 @@ function shortKislev(year) {
     return daysInYear(year) % 10 === 3;
 }
 /**
- * Converts Hebrew month string name to numeric
+ * Converts Hebrew month string name to numeric.
+ *
+ * Accepts transliterated names (`'Cheshvan'`, `'Sh'vat'`), Hebrew-script
+ * names with or without nikud (`'חשון'`, `'תִּשְׁרֵי'`), an optional bet
+ * prefix (`'בתמוז'`), and passes numbers through unchanged. Matching is
+ * case-insensitive and only needs enough of the name to be unambiguous.
+ * `'Adar'` resolves to Adar I; `'Adar II'` (and `'אדר ב׳'`) to Adar II.
  * @param monthName monthName
+ * @returns Hebrew month number (1=NISAN, 7=TISHREI)
+ * @throws {TypeError} if `monthName` is neither a string nor a number
+ * @throws {RangeError} if the name is not recognized, or a numeric month
+ *   is outside 1-14
  * @example
  * monthFromName('Cheshvan'); // 8
  * monthFromName('חשון');     // 8
@@ -623,8 +743,7 @@ function monthFromName(monthName) {
     throw new RangeError(`bad monthName: ${monthName}`);
 }
 
-/*! @hebcal/hdate v0.22.5, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
-
+/*! @hebcal/hdate v0.22.7, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
 const NISAN$4 = months.NISAN;
 const CHESHVAN$1 = months.CHESHVAN;
 const KISLEV$1 = months.KISLEV;
@@ -645,11 +764,19 @@ function isSimpleHebrewDate$1(obj0) {
         typeof obj.dd === 'number');
 }
 /**
+ * Normalizes any accepted form of an event date into a `SimpleHebrewDate`.
+ *
+ * When the caller passes an object (a `SimpleHebrewDate` or anything
+ * structurally compatible with it, such as an `HDate`), this returns a
+ * copy rather than the object itself: callers keep their original event
+ * date around and reuse it across years, and the anniversary functions
+ * are free to modify the value they get back from here.
  * @private
  */
 function toSimpleHebrewDate(obj) {
     if (isSimpleHebrewDate$1(obj)) {
-        return obj;
+        const hd = obj;
+        return { yy: hd.yy, mm: hd.mm, dd: hd.dd };
     }
     else if (isDate(obj)) {
         const abs = greg2abs(obj);
@@ -661,14 +788,52 @@ function toSimpleHebrewDate(obj) {
     }
 }
 /**
- * Same calculation as `getYahrzeit`, but returns the result as a
- * `SimpleHebrewDate` (`{yy, mm, dd}`) rather than converting to a
- * Gregorian `Date`. Useful when the caller needs the Hebrew date
- * directly (e.g. for rendering with `gematriya` or further Hebrew-calendar
- * arithmetic) and wants to avoid an extra R.D. → Gregorian round-trip.
+ * Calculates yahrzeit, the anniversary of a death, and returns it as a
+ * `SimpleHebrewDate` (`{yy, mm, dd}`).
+ * `hyear` must be after original `date` of death.
+ * Returns `undefined` when requested year preceeds or is same as original year.
  *
- * See `getYahrzeit` for the full description of the algorithm and
- * edge cases (Marcheshvan 30, Kislev 30, Adar I / Adar II).
+ * Hebcal uses the algorithm defined in "Calendrical Calculations"
+ * by Edward M. Reingold and Nachum Dershowitz.
+ *
+ * **This is not the same calculation as a birthday.** When the original
+ * date does not exist in the target year, a yahrzeit falls *earlier* —
+ * on the last day of the preceding month — because the anniversary
+ * should not be observed later than the day itself. A birthday in the
+ * same situation is *postponed* to the first of the following month.
+ * See {@link getBirthdayHD} for the contrast.
+ *
+ * The two also differ in whether the original year is a legal `hyear`.
+ * A yahrzeit is by definition an *anniversary* of a death, so the
+ * earliest one that exists is the first: the day of the death itself is
+ * not a yahrzeit, and a "zeroth" yahrzeit has no meaning to return.
+ * `hyear` must therefore be strictly after the year of death, and this
+ * function returns `undefined` otherwise. A birth date, by contrast, is
+ * a real and meaningful day in its own right, so
+ * {@link getBirthdayHD} accepts the year of birth and hands back the
+ * original date.
+ *
+ * The customary anniversary date of a death is more complicated and depends
+ * also on the character of the year in which the first anniversary occurs.
+ * There are several cases:
+ *
+ * * If the date of death is Marcheshvan 30, the anniversary in general depends
+ *   on the first anniversary; if that first anniversary was not Marcheshvan 30,
+ *   use the day before Kislev 1.
+ * * If the date of death is Kislev 30, the anniversary in general again depends
+ *   on the first anniversary — if that was not Kislev 30, use the day before
+ *   Tevet 1.
+ * * If the date of death is Adar II, the anniversary is the same day in the
+ *   last month of the Hebrew year (Adar or Adar II).
+ * * If the date of death is Adar I 30, the anniversary in a Hebrew year that
+ *   is not a leap year (in which Adar only has 29 days) is the last day in
+ *   Shevat.
+ * * In all other cases, use the normal (that is, same month number) anniversary
+ *   of the date of death. [Calendrical Calculations p. 113]
+ *
+ * The `date` argument is never modified, so a single original date can be
+ * reused to generate a run of years.
+ * @see {@link yahrzeit} for the same result as an `HDate` instance
  * @example
  * import {getYahrzeitHD} from '@hebcal/hdate';
  * const dt = new Date(2014, 2, 2); // 30 Adar I 5774
@@ -722,16 +887,40 @@ function getYahrzeitHD(hyear, date) {
     return hDeath;
 }
 /**
- * Same calculation as `getBirthdayOrAnniversary`, but returns the
- * result as a `SimpleHebrewDate` (`{yy, mm, dd}`) rather than
- * converting to a Gregorian `Date`. Useful when the caller needs the
- * Hebrew date directly (e.g. for rendering with `gematriya` or further
- * Hebrew-calendar arithmetic) and wants to avoid an extra R.D. →
- * Gregorian round-trip.
+ * Calculates a birthday or anniversary (non-yahrzeit) and returns it as
+ * a `SimpleHebrewDate` (`{yy, mm, dd}`).
+ * `hyear` must be on or after original `date` of anniversary.
+ * Returns `undefined` when requested year preceeds the original year.
  *
- * See `getBirthdayOrAnniversary` for the full description of the
- * algorithm and edge cases (Adar / Adar II, and the 30th of
- * Marcheshvan, Kislev, or Adar I).
+ * Hebcal uses the algorithm defined in "Calendrical Calculations"
+ * by Edward M. Reingold and Nachum Dershowitz.
+ *
+ * **This is not the same calculation as a yahrzeit.** When the original
+ * date is missing from the target year, a birthday is *postponed* to the
+ * first of the following month, whereas a yahrzeit moves *earlier* to
+ * the last day of the preceding month. Passing the same original date to
+ * both functions can therefore return dates almost a month apart.
+ *
+ * Unlike {@link getYahrzeitHD}, `hyear` may equal the original year, in
+ * which case the original date is returned unchanged. A birth date is a
+ * meaningful day in its own right — it is the day the person was born,
+ * not merely the zeroth anniversary of it. A death has no comparable
+ * day: a yahrzeit only begins to exist on the first anniversary, which
+ * is why {@link getYahrzeitHD} rejects the year of death.
+ *
+ * The birthday of someone born in Adar of an ordinary year or Adar II of
+ * a leap year is also always in the last month of the year, be that Adar
+ * or Adar II. The birthday in an ordinary year of someone born during the
+ * first 29 days of Adar I in a leap year is on the corresponding day of Adar;
+ * in a leap year, the birthday occurs in Adar I, as expected.
+ *
+ * Someone born on the thirtieth day of Marcheshvan, Kislev, or Adar I
+ * has his birthday postponed until the first of the following month in
+ * years where that day does not occur. [Calendrical Calculations p. 111]
+ *
+ * The `date` argument is never modified, so a single original date can be
+ * reused to generate a run of years.
+ * @see {@link birthdayOrAnniversary} for the same result as an `HDate` instance
  * @example
  * import {getBirthdayHD} from '@hebcal/hdate';
  * const dt = new Date(2014, 2, 2); // 30 Adar I 5774
@@ -775,7 +964,7 @@ function getBirthdayHD(hyear, date) {
     return { yy: hyear, mm: month, dd: day };
 }
 
-/*! @hebcal/hdate v0.22.5, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+/*! @hebcal/hdate v0.22.7, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
 const GERESH = '׳';
 const GERSHAYIM = '״';
 const heb2num = {
@@ -894,7 +1083,7 @@ function gematriyaStrToNum(str) {
     return num;
 }
 
-/*! @hebcal/hdate v0.22.5, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+/*! @hebcal/hdate v0.22.7, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
 /**
  * Formats a number with leading zeros so the resulting string is 4 digits long.
  * Similar to `string.padStart(4, '0')` but will also format
@@ -934,8 +1123,7 @@ function pad2(num) {
     return String(num);
 }
 
-/*! @hebcal/hdate v0.22.5, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
-
+/*! @hebcal/hdate v0.22.7, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
 const _formatters = new Map();
 /**
  * @private
@@ -1016,14 +1204,13 @@ function isoDateString(dt) {
         pad2(dt.getDate()));
 }
 
-/*! @hebcal/hdate v0.22.5, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+/*! @hebcal/hdate v0.22.7, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
 var poAshkenazi$1 = { "headers": { "plural-forms": "nplurals=2; plural=(n > 1);", "language": "und-x-ashkenaz" }, "contexts": { "": { "Tevet": ["Teves"] } } };
 
-/*! @hebcal/hdate v0.22.5, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+/*! @hebcal/hdate v0.22.7, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
 var poHe$1 = { "headers": { "plural-forms": "nplurals=2; plural=(n > 1);", "language": "he" }, "contexts": { "": { "Adar": ["אֲדָר"], "Adar I": ["אֲדָר א׳"], "Adar II": ["אֲדָר ב׳"], "Av": ["אָב"], "Cheshvan": ["חֶשְׁוָן"], "Elul": ["אֱלוּל"], "Iyyar": ["אִיָּיר"], "Kislev": ["כִּסְלֵו"], "Nisan": ["נִיסָן"], "Sh'vat": ["שְׁבָט"], "Sivan": ["סִיוָן"], "Tamuz": ["תַּמּוּז"], "Tammuz": ["תַּמּוּז"], "Tevet": ["טֵבֵת"], "Tishrei": ["תִּשְׁרֵי"] } } };
 
-/*! @hebcal/hdate v0.22.5, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
-
+/*! @hebcal/hdate v0.22.7, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
 const noopLocale = {
     headers: { 'plural-forms': 'nplurals=2; plural=(n!=1);' },
     contexts: { '': {} },
@@ -1066,6 +1253,27 @@ function getExistingLocale(locale) {
  * * `ashkenazi` - Ashkenazi transliterations (e.g. "Shabbos")
  * * `he` - Hebrew (e.g. "שַׁבָּת")
  * * `he-x-NoNikud` - Hebrew without nikud (e.g. "שבת")
+ *
+ * The locale set that ships here covers only what this package needs:
+ * month names, a handful of connective words, and the parts of speech
+ * used by {@link HDate.render}. Packages built on top of it (such as
+ * `@hebcal/core`) register their own holiday translations into the same
+ * locales with {@link Locale.addTranslations}.
+ *
+ * Every method is static — `Locale` is a namespace, not something you
+ * instantiate. Locale names are matched case-insensitively, and the
+ * single letters `h`, `a` and `s` are accepted as aliases for `he`,
+ * `ashkenazi` and `en` respectively.
+ * @example
+ * import {Locale, HDate, months} from '@hebcal/hdate';
+ *
+ * Locale.gettext('Cheshvan', 'he');        // 'חֶשְׁוָן'
+ * Locale.gettext('Cheshvan', 'ashkenazi'); // 'Cheshvan'
+ * Locale.ordinal(15, 'en');                // '15th'
+ *
+ * const hd = new HDate(15, months.CHESHVAN, 5769);
+ * hd.render('en'); // '15th of Cheshvan, 5769'
+ * hd.render('he'); // '15 חֶשְׁוָן, 5769'
  */
 class Locale {
     /**
@@ -1103,11 +1311,16 @@ class Locale {
         return text;
     }
     /**
-     * Register locale translations.
+     * Register locale translations, replacing the locale entirely if it
+     * was already registered. Use {@link Locale.addTranslations} to merge
+     * into an existing locale instead.
      * @param locale Locale name (i.e.: `'he'`, `'fr'`)
      * @param data parsed data from a `.po` file.
+     * @throws {TypeError} if `data` is not in the compact `.po` format
      * @example
-     * import poFr from './fr.po';
+     * import {Locale} from '@hebcal/hdate';
+     * // typically `import poFr from './fr.po'` — inlined here for clarity
+     * const poFr = {headers: {}, contexts: {'': {Shabbat: ['Chabbat']}}};
      * Locale.addLocale('fr', poFr);
      * Locale.gettext('Shabbat', 'fr'); // 'Chabbat'
      */
@@ -1155,6 +1368,16 @@ class Locale {
      * existing locale.
      * @param locale Locale name (i.e: `'he'`, `'fr'`).
      * @param data parsed data from a `.po` file.
+     * @throws {RangeError} if `locale` has not been registered
+     * @throws {TypeError} if `data` is not in the compact `.po` format
+     * @example
+     * import {Locale} from '@hebcal/hdate';
+     * Locale.addTranslations('ashkenazi', {
+     *   headers: {},
+     *   contexts: {'': {Sukkot: ['Sukkos'], Shavuot: ['Shavuos']}},
+     * });
+     * Locale.gettext('Sukkot', 'ashkenazi'); // 'Sukkos'
+     * Locale.gettext('Tevet', 'ashkenazi');  // 'Teves' (existing translations kept)
      */
     static addTranslations(locale, data) {
         const loc = getExistingLocale(locale);
@@ -1222,6 +1445,18 @@ class Locale {
      * This is the helper used internally to build the `he-x-NoNikud`
      * locale from `he`; call it when registering a derived "no nikud"
      * variant of a custom Hebrew-script locale.
+     * @param data locale data to copy
+     * @returns a new `LocaleData` with niqqud removed
+     * @see {@link Locale.hebrewStripNikkud}
+     * @example
+     * import {Locale} from '@hebcal/hdate';
+     * const withNikud = {
+     *   headers: {},
+     *   contexts: {'': {Elul: ['אֱלוּל']}},
+     * };
+     * const stripped = Locale.copyLocaleNoNikud(withNikud);
+     * stripped.contexts[''].Elul[0];   // 'אלול'
+     * withNikud.contexts[''].Elul[0];  // 'אֱלוּל' (input unchanged)
      */
     static copyLocaleNoNikud(data) {
         const strs = data.contexts[''];
@@ -1259,8 +1494,7 @@ Locale.addLocale('he', poHe$1);
 const poHeNoNikud$1 = Locale.copyLocaleNoNikud(poHe$1);
 Locale.addLocale('he-x-NoNikud', poHeNoNikud$1);
 
-/*! @hebcal/hdate v0.22.5, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
-
+/*! @hebcal/hdate v0.22.7, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
 /*
     Hebcal - A Jewish Calendar Generator
     Copyright (c) 1994-2020 Danny Sadinoff
@@ -1461,7 +1695,7 @@ class HDate {
      * @returns an integer 0-6
      * @example
      * const hd = new HDate(new Date(2008, 10, 13)); // 15 Cheshvan 5769
-     * hd.getDate(); // 4
+     * hd.getDay(); // 4 (Thursday)
      */
     getDay() {
         return mod(this.abs(), 7);
@@ -1579,10 +1813,15 @@ class HDate {
     }
     /**
      * Returns an `HDate` corresponding to the specified day of week
-     * **before** this Hebrew date
+     * **before** this Hebrew date.
+     *
+     * Strictly before: if this date already falls on `dayOfWeek`, the
+     * previous occurrence a week earlier is returned.
      * @example
-     * new HDate(new Date('Wednesday February 19, 2014')).before(6).greg() // Sat Feb 15 2014
+     * const wed = new HDate(new Date('Wednesday February 19, 2014'));
+     * wed.before(6).greg().toDateString(); // 'Sat Feb 15 2014'
      * @param dayOfWeek day of week: Sunday=0, Saturday=6
+     * @returns a new `HDate`; the original is not modified
      */
     before(dayOfWeek) {
         return onOrBefore(dayOfWeek, this, -1);
@@ -1591,21 +1830,31 @@ class HDate {
      * Returns an `HDate` corresponding to the specified day of week
      * **on or before** this Hebrew date
      * @example
-     * new HDate(new Date('Wednesday February 19, 2014')).onOrBefore(6).greg() // Sat Feb 15 2014
-     * new HDate(new Date('Saturday February 22, 2014')).onOrBefore(6).greg() // Sat Feb 22 2014
-     * new HDate(new Date('Sunday February 23, 2014')).onOrBefore(6).greg() // Sat Feb 22 2014
+     * const wed = new HDate(new Date('Wednesday February 19, 2014'));
+     * const sat = new HDate(new Date('Saturday February 22, 2014'));
+     * const sun = new HDate(new Date('Sunday February 23, 2014'));
+     * wed.onOrBefore(6).greg().toDateString(); // 'Sat Feb 15 2014'
+     * sat.onOrBefore(6).greg().toDateString(); // 'Sat Feb 22 2014'
+     * sun.onOrBefore(6).greg().toDateString(); // 'Sat Feb 22 2014'
      * @param dayOfWeek day of week: Sunday=0, Saturday=6
+     * @returns a new `HDate`; the original is not modified
      */
     onOrBefore(dayOfWeek) {
         return onOrBefore(dayOfWeek, this, 0);
     }
     /**
      * Returns an `HDate` corresponding to the specified day of week
-     * **nearest** to this Hebrew date
+     * **nearest** to this Hebrew date.
+     *
+     * Ties are broken forward: a date exactly 3 days from `dayOfWeek` in
+     * both directions resolves to the later one.
      * @example
-     * new HDate(new Date('Wednesday February 19, 2014')).nearest(6).greg() // Sat Feb 22 2014
-     * new HDate(new Date('Tuesday February 18, 2014')).nearest(6).greg() // Sat Feb 15 2014
+     * const wed = new HDate(new Date('Wednesday February 19, 2014'));
+     * const tue = new HDate(new Date('Tuesday February 18, 2014'));
+     * wed.nearest(6).greg().toDateString(); // 'Sat Feb 22 2014'
+     * tue.nearest(6).greg().toDateString(); // 'Sat Feb 15 2014'
      * @param dayOfWeek day of week: Sunday=0, Saturday=6
+     * @returns a new `HDate`; the original is not modified
      */
     nearest(dayOfWeek) {
         return onOrBefore(dayOfWeek, this, 3);
@@ -1614,40 +1863,53 @@ class HDate {
      * Returns an `HDate` corresponding to the specified day of week
      * **on or after** this Hebrew date
      * @example
-     * new HDate(new Date('Wednesday February 19, 2014')).onOrAfter(6).greg() // Sat Feb 22 2014
-     * new HDate(new Date('Saturday February 22, 2014')).onOrAfter(6).greg() // Sat Feb 22 2014
-     * new HDate(new Date('Sunday February 23, 2014')).onOrAfter(6).greg() // Sat Mar 01 2014
+     * const wed = new HDate(new Date('Wednesday February 19, 2014'));
+     * const sat = new HDate(new Date('Saturday February 22, 2014'));
+     * const sun = new HDate(new Date('Sunday February 23, 2014'));
+     * wed.onOrAfter(6).greg().toDateString(); // 'Sat Feb 22 2014'
+     * sat.onOrAfter(6).greg().toDateString(); // 'Sat Feb 22 2014'
+     * sun.onOrAfter(6).greg().toDateString(); // 'Sat Mar 01 2014'
      * @param dayOfWeek day of week: Sunday=0, Saturday=6
+     * @returns a new `HDate`; the original is not modified
      */
     onOrAfter(dayOfWeek) {
         return onOrBefore(dayOfWeek, this, 6);
     }
     /**
      * Returns an `HDate` corresponding to the specified day of week
-     * **after** this Hebrew date
+     * **after** this Hebrew date.
+     *
+     * Strictly after: if this date already falls on `dayOfWeek`, the next
+     * occurrence a week later is returned.
      * @example
-     * new HDate(new Date('Wednesday February 19, 2014')).after(6).greg() // Sat Feb 22 2014
-     * new HDate(new Date('Saturday February 22, 2014')).after(6).greg() // Sat Mar 01 2014
-     * new HDate(new Date('Sunday February 23, 2014')).after(6).greg() // Sat Mar 01 2014
+     * const wed = new HDate(new Date('Wednesday February 19, 2014'));
+     * const sat = new HDate(new Date('Saturday February 22, 2014'));
+     * const sun = new HDate(new Date('Sunday February 23, 2014'));
+     * wed.after(6).greg().toDateString(); // 'Sat Feb 22 2014'
+     * sat.after(6).greg().toDateString(); // 'Sat Mar 01 2014'
+     * sun.after(6).greg().toDateString(); // 'Sat Mar 01 2014'
      * @param dayOfWeek day of week: Sunday=0, Saturday=6
+     * @returns a new `HDate`; the original is not modified
      */
     after(dayOfWeek) {
         return onOrBefore(dayOfWeek, this, 7);
     }
     /**
      * Returns the next Hebrew date
+     * @returns a new `HDate` one day later; the original is not modified
      * @example
      * const hd = new HDate(new Date(2008, 10, 13)); // 15 Cheshvan 5769
-     * hd.next(); // '16 Cheshvan 5769'
+     * hd.next().toString(); // '16 Cheshvan 5769'
      */
     next() {
         return new HDate(this.abs() + 1);
     }
     /**
      * Returns the previous Hebrew date
+     * @returns a new `HDate` one day earlier; the original is not modified
      * @example
      * const hd = new HDate(new Date(2008, 10, 13)); // 15 Cheshvan 5769
-     * hd.prev(); // '14 Cheshvan 5769'
+     * hd.prev().toString(); // '14 Cheshvan 5769'
      */
     prev() {
         return new HDate(this.abs() - 1);
@@ -1668,9 +1930,13 @@ class HDate {
      * import {HDate, months} from '@hebcal/hdate';
      *
      * const hd1 = new HDate(15, months.CHESHVAN, 5769);
-     * hd1.add(7, 'd');     // 22 Cheshvan 5769
-     * hd1.add(1, 'weeks'); // 22 Cheshvan 5769
-     * hd1.add(1, 'year');  // 15 Cheshvan 5770
+     * hd1.add(7, 'd').toString();     // '22 Cheshvan 5769'
+     * hd1.add(1, 'weeks').toString(); // '22 Cheshvan 5769'
+     * hd1.add(1, 'year').toString();  // '15 Cheshvan 5770'
+     * @param amount number of units to add (negative values subtract)
+     * @param [units=d] unit of time, defaults to days
+     * @returns a new `HDate`; the original is not modified
+     * @throws {TypeError} if `units` is not a recognized unit of time
      */
     add(amount, units = 'd') {
         amount = typeof amount === 'string' ? parseInt(amount, 10) : amount;
@@ -1714,8 +1980,12 @@ class HDate {
      * import {HDate, months} from '@hebcal/hdate';
      *
      * const hd1 = new HDate(15, months.CHESHVAN, 5769);
-     * const hd2 = hd1.add(1, 'weeks'); // 7 Kislev 5769
-     * const hd3 = hd1.add(-3, 'M'); // 30 Av 5768
+     * hd1.subtract(1, 'weeks').toString(); // '8 Cheshvan 5769'
+     * hd1.subtract(3, 'M').toString();     // '16 Av 5768'
+     * @param amount number of units to subtract (negative values add)
+     * @param [units=d] unit of time, defaults to days
+     * @returns a new `HDate`; the original is not modified
+     * @throws {TypeError} if `units` is not a recognized unit of time
      */
     subtract(amount, units = 'd') {
         return this.add(amount * -1, units);
@@ -1879,7 +2149,18 @@ class HDate {
      * absolute day d. Similarly, applying it to d+3 gives the `dayOfWeek` nearest to
      * absolute date d, applying it to d-1 gives the `dayOfWeek` previous to absolute
      * date d, and applying it to d+7 gives the `dayOfWeek` following absolute date d.
+     *
+     * The instance methods {@link HDate.before}, {@link HDate.onOrBefore},
+     * {@link HDate.nearest}, {@link HDate.onOrAfter} and {@link HDate.after}
+     * wrap this with those offsets already applied.
      * @param dayOfWeek day of week: Sunday=0, Saturday=6
+     * @param absdate R.D. number of days
+     * @returns R.D. number of days
+     * @example
+     * import {HDate} from '@hebcal/hdate';
+     * // 733359 is Thursday 13 November 2008
+     * HDate.dayOnOrBefore(6, 733359); // 733354 (Saturday 8 November 2008)
+     * HDate.dayOnOrBefore(6, 733359 + 6); // 733361 (Saturday 15 November 2008)
      */
     static dayOnOrBefore(dayOfWeek, absdate) {
         return absdate - ((absdate - dayOfWeek) % 7);
@@ -1904,11 +2185,22 @@ class HDate {
             typeof obj.abs === 'function');
     }
     /**
-     * Construct a new instance of `HDate` from a Gematriya-formatted string
+     * Construct a new instance of `HDate` from a Gematriya-formatted string.
+     *
+     * The string must have the form day-month-year, with the month name
+     * written in Hebrew script (nikud optional, an optional bet prefix
+     * allowed). A year below 1000 is assumed to omit the thousands and has
+     * `currentThousands` added to it.
+     * @param str Hebrew date in gematriya, e.g. `'כ״ז בְּתַמּוּז תשפ״ג'`
+     * @param [currentThousands=5000] added to a year below 1000
+     * @returns the parsed Hebrew date
+     * @throws {TypeError} if `str` is not a string
+     * @throws {RangeError} if `str` is not 3 or 4 space-separated parts,
+     *   or the month name is not recognized
      * @example
-     * HDate.fromGematriyaString('כ״ז בְּתַמּוּז תשפ״ג') // 27 Tamuz 5783
-     * HDate.fromGematriyaString('כ׳ סיון תש״ד') // 20 Sivan 5704
-     * HDate.fromGematriyaString('ה׳ אִיָיר תש״ח') // 5 Iyyar 5708
+     * HDate.fromGematriyaString('כ״ז בְּתַמּוּז תשפ״ג').toString(); // '27 Tamuz 5783'
+     * HDate.fromGematriyaString('כ׳ סיון תש״ד').toString(); // '20 Sivan 5704'
+     * HDate.fromGematriyaString('ה׳ אִיָיר תש״ח').toString(); // '5 Iyyar 5708'
      */
     static fromGematriyaString(str, currentThousands = 5000) {
         if (typeof str !== 'string') {
@@ -2034,6 +2326,87 @@ function onOrBefore(day, t, offset) {
     return new HDate(HDate.dayOnOrBefore(day, t.abs() + offset));
 }
 
+/*! @hebcal/hdate v0.22.7, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+/**
+ * Calculates yahrzeit, the anniversary of a death, and returns it as an
+ * {@link HDate}.
+ *
+ * Same calculation as {@link getYahrzeitHD}, but the result comes back
+ * as an `HDate` instance rather than a plain `{yy, mm, dd}` object, so it
+ * can be rendered (`render`, `renderGematriya`) or used for further
+ * Hebrew calendar arithmetic directly.
+ *
+ * Note that a yahrzeit is *not* calculated the same way as a birthday:
+ * when the original date is missing from `hyear` it moves earlier rather
+ * than later. See {@link getYahrzeitHD} for the full algorithm and its
+ * edge cases (Marcheshvan 30, Kislev 30, Adar I / Adar II).
+ *
+ * `hyear` must be strictly after the year of death. A yahrzeit is an
+ * *anniversary* of a death, so the first one is the earliest that
+ * exists — the day of the death itself is not a yahrzeit, and there is
+ * no meaningful "zeroth" one to return. This is the one place where
+ * {@link birthdayOrAnniversary} legitimately accepts a year that this
+ * function rejects: a birth date is a real day in its own right.
+ *
+ * The `date` argument is never modified, so a single original date can be
+ * reused to generate a run of years.
+ * @param hyear Hebrew year in which to find the anniversary
+ * @param date Gregorian or Hebrew date of death
+ * @returns anniversary occurring in `hyear`, or `undefined` when `hyear`
+ *   is on or before the year of death
+ * @see {@link getYahrzeitHD}
+ * @see {@link birthdayOrAnniversary}
+ * @example
+ * import {yahrzeit} from '@hebcal/hdate';
+ * const dt = new Date(2014, 2, 2); // '2014-03-02' == '30 Adar I 5774'
+ * yahrzeit(5780, dt)?.toString();          // '30 Sh\'vat 5780'
+ * yahrzeit(5780, dt)?.renderGematriya();   // 'ל׳ שְׁבָט תש״פ'
+ * yahrzeit(5774, dt);                      // undefined (year of death)
+ */
+function yahrzeit(hyear, date) {
+    const hd = getYahrzeitHD(hyear, date);
+    return hd && new HDate(hd);
+}
+/**
+ * Calculates a birthday or anniversary (non-yahrzeit) and returns it as
+ * an {@link HDate}.
+ *
+ * Same calculation as {@link getBirthdayHD}, but the result comes back
+ * as an `HDate` instance rather than a plain `{yy, mm, dd}` object, so it
+ * can be rendered (`render`, `renderGematriya`) or used for further
+ * Hebrew calendar arithmetic directly.
+ *
+ * Note that a birthday is *not* calculated the same way as a yahrzeit:
+ * when the original date is missing from `hyear` it is postponed rather
+ * than moved earlier. See {@link getBirthdayHD} for the full algorithm
+ * and its edge cases.
+ *
+ * `hyear` may be the original year, in which case the original date is
+ * returned unchanged: someone's birth date is a meaningful day in its
+ * own right, not merely the zeroth anniversary of itself. A death has no
+ * equivalent — a yahrzeit begins at the first anniversary — which is why
+ * {@link yahrzeit} rejects the year of death.
+ *
+ * The `date` argument is never modified, so a single original date can be
+ * reused to generate a run of years.
+ * @param hyear Hebrew year in which to find the anniversary
+ * @param date Gregorian or Hebrew date of the original event
+ * @returns anniversary occurring in `hyear`, or `undefined` when `hyear`
+ *   precedes the original year
+ * @see {@link getBirthdayHD}
+ * @see {@link yahrzeit}
+ * @example
+ * import {birthdayOrAnniversary} from '@hebcal/hdate';
+ * const dt = new Date(2014, 2, 2); // '2014-03-02' == '30 Adar I 5774'
+ * birthdayOrAnniversary(5780, dt)?.toString(); // '1 Nisan 5780'
+ * birthdayOrAnniversary(5774, dt)?.toString(); // '30 Adar I 5774'
+ * birthdayOrAnniversary(5773, dt);             // undefined
+ */
+function birthdayOrAnniversary(hyear, date) {
+    const hd = getBirthdayHD(hyear, date);
+    return hd && new HDate(hd);
+}
+
 var poAshkenazi = { "headers": { "plural-forms": "nplurals=2; plural=(n > 1);", "language": "und-x-ashkenaz" }, "contexts": { "": { "Shabbat": ["Shabbos"], "Achrei Mot": ["Achrei Mos"], "Bechukotai": ["Bechukosai"], "Beha'alotcha": ["Beha’aloscha"], "Bereshit": ["Bereshis"], "Chukat": ["Chukas"], "Erev Shavuot": ["Erev Shavuos"], "Erev Sukkot": ["Erev Sukkos"], "Ki Tavo": ["Ki Savo"], "Ki Teitzei": ["Ki Seitzei"], "Ki Tisa": ["Ki Sisa"], "Matot": ["Matos"], "Pesach Shabbat Chol ha-Moed": ["Pesach Shabbos Chol ha-Moed"], "Purim Katan": ["Purim Koton"], "Rosh Hashana LaBehemot": ["Rosh Hashana LaBeheimos"], "Shabbat Chazon": ["Shabbos Chazon"], "Shabbat HaChodesh": ["Shabbos HaChodesh"], "Shabbat HaGadol": ["Shabbos HaGadol"], "Shabbat Nachamu": ["Shabbos Nachamu"], "Shabbat Parah": ["Shabbos Parah"], "Shabbat Shekalim": ["Shabbos Shekalim"], "Shabbat Shuva": ["Shabbos Shuvah"], "Shabbat Zachor": ["Shabbos Zachor"], "Shavuot": ["Shavuos"], "Shavuot I": ["Shavuos I"], "Shavuot II": ["Shavuos II"], "Shemot": ["Shemos"], "Shmini Atzeret": ["Shmini Atzeres"], "Simchat Torah": ["Simchas Torah"], "Sukkot": ["Sukkos"], "Sukkot I": ["Sukkos I"], "Sukkot II": ["Sukkos II"], "Sukkot II (CH''M)": ["Sukkos II (CH’’M)"], "Sukkot III (CH''M)": ["Sukkos III (CH’’M)"], "Sukkot IV (CH''M)": ["Sukkos IV (CH’’M)"], "Sukkot V (CH''M)": ["Sukkos V (CH’’M)"], "Sukkot VI (CH''M)": ["Sukkos VI (CH’’M)"], "Sukkot VII (Hoshana Raba)": ["Sukkos VII (Hoshana Raba)"], "Sukkot Shabbat Chol ha-Moed": ["Sukkos Shabbos Chol ha-Moed"], "Ta'anit Bechorot": ["Ta’anis Bechoros"], "Ta'anit BeHaB": ["Ta’anis BeHaB"], "Ta'anit Esther": ["Ta’anis Esther"], "Toldot": ["Toldos"], "Vaetchanan": ["Vaeschanan"], "Yitro": ["Yisro"], "Vezot Haberakhah": ["Vezos Haberakhah"], "Parashat": ["Parshas"], "Leil Selichot": ["Leil Selichos"], "Shabbat Mevarchim Chodesh": ["Shabbos Mevorchim Chodesh"], "Shabbat Shirah": ["Shabbos Shirah"], "Asara B'Tevet": ["Asara B’Teves"], "Birkat Hachamah": ["Birkas HaChamah"], "Birkat HaChamah": ["Birkas HaChamah"], "Shushan Purim Katan": ["Shushan Purim Koton"], "Alot HaShachar": ["Alos HaShachar"], "Misheyakir": ["Misheyakir"], "Misheyakir Machmir": ["Misheyakir Machmir"], "Sunrise": ["Sunrise"], "Kriat Shema, sof zeman": ["Krias Shema, sof zman"], "Tefilah, sof zeman": ["Tefilah, sof zman"], "Kriat Shema, sof zeman (MGA)": ["Krias Shema, sof zman (MGA)"], "Kriat Shema, sof zeman (GRA)": ["Krias Shema, sof zman (GRA)"], "Tefilah, sof zeman (MGA)": ["Tefilah, sof zman (MGA)"], "Tefilah, sof zeman (GRA)": ["Tefilah, sof zman (GRA)"], "Chatzot HaLailah": ["Chatzos HaLailah"], "Chatzot HaYom": ["Chatzos"], "Chatzot hayom": ["Chatzos"], "Mincha Gedolah": ["Mincha Gedolah"], "Mincha Ketanah": ["Mincha Ketanah"], "Plag HaMincha": ["Plag HaMincha"], "Sunset": ["Sunset"], "Bein HaShemashot": ["Bein HaShemashos"], "Tzeit HaKochavim": ["Tzeis HaKochavim"] } } };
 
 var poHe = { "headers": { "plural-forms": "nplurals=2; plural=(n > 1);", "language": "he_IL" }, "contexts": { "": { "Shabbat": ["שַׁבָּת"], "Parashat": ["פָּרָשַׁת"], "Achrei Mot": ["אַחֲרֵי מוֹת"], "Balak": ["בָּלָק"], "Bamidbar": ["בְּמִדְבַּר"], "Bechukotai": ["בְּחֻקֹּתַי"], "Beha'alotcha": ["בְּהַעֲלֹתְךָ"], "Behar": ["בְּהַר"], "Bereshit": ["בְּרֵאשִׁית"], "Beshalach": ["בְּשַׁלַּח"], "Bo": ["בֹּא"], "Chayei Sara": ["חַיֵּי שָֹרָה"], "Chukat": ["חֻקַּת"], "Devarim": ["דְּבָרִים"], "Eikev": ["עֵקֶב"], "Emor": ["אֱמוֹר"], "Ha'azinu": ["הַאֲזִינוּ"], "Kedoshim": ["קְדֹשִׁים"], "Ki Tavo": ["כִּי־תָבוֹא"], "Ki Teitzei": ["כִּי־תֵצֵא"], "Ki Tisa": ["כִּי תִשָּׂא"], "Korach": ["קֹרַח"], "Lech-Lecha": ["לֶךְ־לְךָ"], "Masei": ["מַסְעֵי"], "Matot": ["מַטּוֹת"], "Metzora": ["מְצֹרָע"], "Miketz": ["מִקֵּץ"], "Mishpatim": ["מִשְׁפָּטִים"], "Nasso": ["נָשׂא"], "Nitzavim": ["נִצָּבִים"], "Noach": ["נֹחַ"], "Pekudei": ["פְקוּדֵי"], "Pinchas": ["פִּינְחָס"], "Re'eh": ["רְאֵה"], "Sh'lach": ["שְׁלַח־לְךָ"], "Shemot": ["שְׁמוֹת"], "Shmini": ["שְּׁמִינִי"], "Shoftim": ["שׁוֹפְטִים"], "Tazria": ["תַזְרִיעַ"], "Terumah": ["תְּרוּמָה"], "Tetzaveh": ["תְּצַוֶּה"], "Toldot": ["תּוֹלְדוֹת"], "Tzav": ["צַו"], "Vaera": ["וָאֵרָא"], "Vaetchanan": ["וָאֶתְחַנַּן"], "Vayakhel": ["וַיַּקְהֵל"], "Vayechi": ["וַיְחִי"], "Vayeilech": ["וַיֵּלֶךְ"], "Vayera": ["וַיֵּרָא"], "Vayeshev": ["וַיֵּשֶׁב"], "Vayetzei": ["וַיֵּצֵא"], "Vayigash": ["וַיִּגַּשׁ"], "Vayikra": ["וַיִּקְרָא"], "Vayishlach": ["וַיִּשְׁלַח"], "Vezot Haberakhah": ["וְזֹאת הַבְּרָכָה"], "Yitro": ["יִתְרוֹ"], "Asara B'Tevet": ["עֲשָׂרָה בְּטֵבֵת"], "Candle lighting": ["הַדְלָקַת נֵרוֹת"], "Chanukah": ["חֲנוּכָּה"], "Chanukah: 1 Candle": ["חֲנוּכָּה: א׳ נֵר"], "Chanukah: 2 Candles": ["חֲנוּכָּה: ב׳ נֵרוֹת"], "Chanukah: 3 Candles": ["חֲנוּכָּה: ג׳ נֵרוֹת"], "Chanukah: 4 Candles": ["חֲנוּכָּה: ד׳ נֵרוֹת"], "Chanukah: 5 Candles": ["חֲנוּכָּה: ה׳ נֵרוֹת"], "Chanukah: 6 Candles": ["חֲנוּכָּה: ו׳ נֵרוֹת"], "Chanukah: 7 Candles": ["חֲנוּכָּה: ז׳ נֵרוֹת"], "Chanukah: 8 Candles": ["חֲנוּכָּה: ח׳ נֵרוֹת"], "Chanukah: 8th Day": ["חֲנוּכָּה: יוֹם ח׳"], "Days of the Omer": ["סְפִירַת הָעוֹמֶר"], "Omer": ["עוֹמֶר"], "day of the Omer": ["בָּעוֹמֶר"], "Erev Pesach": ["עֶרֶב פֶּסַח"], "Erev Purim": ["עֶרֶב פּוּרִים"], "Erev Rosh Hashana": ["עֶרֶב רֹאשׁ הַשָּׁנָה"], "Erev Shavuot": ["עֶרֶב שָׁבוּעוֹת"], "Erev Simchat Torah": ["עֶרֶב שִׂמְחַת תּוֹרָה"], "Erev Sukkot": ["עֶרֶב סֻכּוֹת"], "Erev Tish'a B'Av": ["עֶרֶב תִּשְׁעָה בְּאָב"], "Erev Yom Kippur": ["עֶרֶב יוֹם כִּפּוּר"], "Havdalah": ["הַבְדָּלָה"], "Lag BaOmer": ["ל״ג בָּעוֹמֶר"], "Leil Selichot": ["סְלִיחוֹת"], "Pesach": ["פֶּסַח"], "Pesach I": ["פֶּסַח א׳"], "Pesach II": ["פֶּסַח ב׳"], "Pesach II (CH''M)": ["פֶּסַח ב׳ (חוה״מ)"], "Pesach III (CH''M)": ["פֶּסַח ג׳ (חוה״מ)"], "Pesach IV (CH''M)": ["פֶּסַח ד׳ (חוה״מ)"], "Pesach Sheni": ["פֶּסַח שֵׁנִי"], "Pesach V (CH''M)": ["פֶּסַח ה׳ (חוה״מ)"], "Pesach VI (CH''M)": ["פֶּסַח ו׳ (חוה״מ)"], "Pesach VII": ["פֶּסַח ז׳"], "Pesach VIII": ["פֶּסַח ח׳"], "Pesach Shabbat Chol ha-Moed": ["שַׁבַּת חֹל הַמּוֹעֵד פֶּסַח"], "Purim": ["פּוּרִים"], "Purim Katan": ["פּוּרִים קָטָן"], "Rosh Chodesh": ["רֹאשׁ חוֹדֶשׁ"], "Rosh Hashana": ["רֹאשׁ הַשָּׁנָה"], "Rosh Hashana I": ["רֹאשׁ הַשָּׁנָה א׳"], "Rosh Hashana II": ["רֹאשׁ הַשָּׁנָה ב׳"], "Shabbat Chazon": ["שַׁבַּת חֲזוֹן"], "Shabbat HaChodesh": ["שַׁבַּת הַחֹדֶשׁ"], "Shabbat HaGadol": ["שַׁבַּת הַגָּדוֹל"], "Shabbat Nachamu": ["שַׁבַּת נַחֲמוּ"], "Shabbat Parah": ["שַׁבַּת פָּרָה"], "Shabbat Shekalim": ["שַׁבַּת שְׁקָלִים"], "Shabbat Shuva": ["שַׁבַּת שׁוּבָה"], "Shabbat Zachor": ["שַׁבַּת זָכוֹר"], "Shavuot": ["שָׁבוּעוֹת"], "Shavuot I": ["שָׁבוּעוֹת א׳"], "Shavuot II": ["שָׁבוּעוֹת ב׳"], "Shmini Atzeret": ["שְׁמִינִי עֲצֶרֶת"], "Shushan Purim": ["שׁוּשָׁן פּוּרִים"], "Sigd": ["חַג הַסִּיגְד"], "Simchat Torah": ["שִׂמְחַת תּוֹרָה"], "Sukkot": ["סֻכּוֹת"], "Sukkot I": ["סֻכּוֹת א׳"], "Sukkot II": ["סֻכּוֹת ב׳"], "Sukkot II (CH''M)": ["סֻכּוֹת ב׳ (חוה״מ)"], "Sukkot III (CH''M)": ["סֻכּוֹת ג׳ (חוה״מ)"], "Sukkot IV (CH''M)": ["סֻכּוֹת ד׳ (חוה״מ)"], "Sukkot V (CH''M)": ["סֻכּוֹת ה׳ (חוה״מ)"], "Sukkot VI (CH''M)": ["סֻכּוֹת ו׳ (חוה״מ)"], "Sukkot VII (Hoshana Raba)": ["סֻכּוֹת ז׳ (הוֹשַׁעְנָא רַבָּה)"], "Sukkot Shabbat Chol ha-Moed": ["שַׁבַּת חֹל הַמּוֹעֵד סֻכּוֹת"], "Ta'anit Bechorot": ["תַּעֲנִית בְּכוֹרוֹת"], "Ta'anit BeHaB": ["תַּעֲנִית בה״ב"], "Ta'anit Esther": ["תַּעֲנִית אֶסְתֵּר"], "Tish'a B'Av": ["תִּשְׁעָה בְּאָב"], "Tu B'Av": ["ט״וּ בְּאָב"], "Tu BiShvat": ["ט״וּ בִּשְׁבָט"], "Tu B'Shvat": ["ט״וּ בִּשְׁבָט"], "Tzom Gedaliah": ["צוֹם גְּדַלְיָה"], "Tzom Tammuz": ["צוֹם י״ז בְּתַמּוּז"], "Yom HaAtzma'ut": ["יוֹם הָעַצְמָאוּת"], "Yom HaShoah": ["יוֹם הַשּׁוֹאָה"], "Yom HaZikaron": ["יוֹם הַזִּכָּרוֹן"], "Yom Kippur": ["יוֹם כִּפּוּר"], "Yom Yerushalayim": ["יוֹם יְרוּשָׁלַיִם"], "Yom HaAliyah": ["יוֹם הַעֲלִיָּה"], "Yom HaAliyah School Observance": ["שְׁמִירָת בֵּית הַסֵפֶר לְיוֹם הַעֲלִיָּה"], "Rosh Chodesh Adar": ["רֹאשׁ חוֹדֶשׁ אֲדָר"], "Rosh Chodesh Adar I": ["רֹאשׁ חוֹדֶשׁ אֲדָר א׳"], "Rosh Chodesh Adar II": ["רֹאשׁ חוֹדֶשׁ אֲדָר ב׳"], "Rosh Chodesh Av": ["רֹאשׁ חוֹדֶשׁ אָב"], "Rosh Chodesh Cheshvan": ["רֹאשׁ חוֹדֶשׁ חֶשְׁוָן"], "Rosh Chodesh Elul": ["רֹאשׁ חוֹדֶשׁ אֱלוּל"], "Rosh Chodesh Iyyar": ["רֹאשׁ חוֹדֶשׁ אִיָּיר"], "Rosh Chodesh Kislev": ["רֹאשׁ חוֹדֶשׁ כִּסְלֵו"], "Rosh Chodesh Nisan": ["רֹאשׁ חוֹדֶשׁ נִיסָן"], "Rosh Chodesh Sh'vat": ["רֹאשׁ חוֹדֶשׁ שְׁבָט"], "Rosh Chodesh Sivan": ["רֹאשׁ חוֹדֶשׁ סִיוָן"], "Rosh Chodesh Tamuz": ["רֹאשׁ חוֹדֶשׁ תַּמּוּז"], "Rosh Chodesh Tammuz": ["רֹאשׁ חוֹדֶשׁ תַּמּוּז"], "Rosh Chodesh Tevet": ["רֹאשׁ חוֹדֶשׁ טֵבֵת"], "min": ["דַּקּוֹת"], "Fast begins": ["תְּחִילַּת הַצוֹם"], "Fast ends": ["סִיּוּם הַצוֹם"], "Rosh Hashana LaBehemot": ["רֹאשׁ הַשָּׁנָה לְמַעְשַׂר בְּהֵמָה"], "Tish'a B'Av (observed)": ["(תִּשְׁעָה בְּאָב (נִדְחָה"], "Shabbat Mevarchim Chodesh": ["שַׁבַּת מְבָרְכִים חוֹדֶשׁ"], "Shabbat Shirah": ["שַׁבַּת שִׁירָה"], "Lovingkindness": ["חֶסֶד"], "Might": ["גְּבוּרָה"], "Beauty": ["תִּפְאֶרֶת"], "Eternity": ["נֶּצַח"], "Splendor": ["הוֹד"], "Foundation": ["יְּסוֹד"], "Majesty": ["מַּלְכוּת"], "day": ["יוֹם"], "Yom Kippur Katan": ["יוֹם כִּפּוּר קָטָן"], "Yizkor": ["יִזְכּוֹר"], "Family Day": ["יוֹם הַמִּשׁפָּחָה"], "Yitzhak Rabin Memorial Day": ["יוֹם הַזִּכָּרוֹן לְיִצְחָק רַבִּין"], "Jabotinsky Day": ["יוֹם זַ׳בּוֹטִינְסְקִי"], "Herzl Day": ["יוֹם הֶרְצְל"], "Ben-Gurion Day": ["יוֹם בֶּן־גּוּרִיּוֹן"], "Hebrew Language Day": ["יוֹם הַשָׂפָה הַעִברִית"], "Birkat Hachamah": ["בִּרְכַּת הַחַמָּה"], "Birkat HaChamah": ["בִּרְכַּת הַחַמָּה"], "Shushan Purim Katan": ["שׁוּשָׁן פּוּרִים קָטָן"], "Purim Meshulash": ["פּוּרִים מְשׁוּלָּשׁ"], "Chag HaBanot": ["חַג הַבָּנוֹת"], "Molad": ["מוֹלָד הָלְּבָנָה"], "chalakim": ["חֲלָקִים"], "Alot HaShachar": ["עֲלוֹת הַשַּׁחַר"], "Misheyakir": ["מִשֶּׁיַּכִּיר"], "Misheyakir Machmir": ["מִשֶּׁיַּכִּיר מַחְמִיר"], "Sunrise": ["נֵץ הַחַמָּה"], "Kriat Shema, sof zeman": ["סוֹף זְמַן קְרִיאַת שְׁמַע"], "Tefilah, sof zeman": ["סוֹף זְמַן תְּפִלָּה"], "Kriat Shema, sof zeman (MGA)": ["סוֹף זְמַן קְרִיאַת שְׁמַע (מג״א)"], "Kriat Shema, sof zeman (GRA)": ["סוֹף זְמַן קְרִיאַת שְׁמַע (גְּרָ״א)"], "Tefilah, sof zeman (MGA)": ["סוֹף זְמַן תְּפִלָּה (מג״א)"], "Tefilah, sof zeman (GRA)": ["סוֹף זְמַן תְּפִלָּה (גְּרָ״א)"], "Chatzot HaLailah": ["חֲצוֹת הַלַּיְלָה"], "Chatzot HaYom": ["חֲצוֹת הַיּוֹם"], "Chatzot hayom": ["חֲצוֹת הַיּוֹם"], "Mincha Gedolah": ["מִנְחָה גְּדוֹלָה"], "Mincha Ketanah": ["מִנְחָה קְטַנָּה"], "Plag HaMincha": ["פְּלַג הַמִּנְחָה"], "Sunset": ["שְׁקִיעַת הַחַמָּה"], "Bein HaShemashot": ["בֵּין הַשְּׁמָשׁוֹת"], "Tzeit HaKochavim": ["צֵאת הַכּוֹכָבִים"], "Biur Chametz": ["בִּעוּר חָמֵץ"], "Finish eating chametz": ["סוֹף זְמַן אֲכִילַת חָמֵץ"] } } };
@@ -2050,13 +2423,11 @@ Locale.addTranslations('he-x-NoNikud', noNikudOverride);
 /**
  * Holiday flags for Event. These flags are typically
  * combined using bitwise arithmetic to form a mask.
- * @readonly
- * @enum {number}
  */
 const flags = {
     /** Chag, yontiff, yom tov */
     CHAG: 0x000001,
-    /** Light candles 18 minutes before sundown */
+    /** Light candles before sundown */
     LIGHT_CANDLES: 0x000002,
     /** End of holiday (end of Yom Tov)  */
     YOM_TOV_ENDS: 0x000004,
@@ -2136,7 +2507,7 @@ const flagToCategory = [
  * Torah readings, Omer days, Hebrew dates, and more. Most concrete event
  * types are subclasses (e.g. {@link HolidayEvent}, {@link TimedEvent},
  * {@link ParshaEvent}, {@link OmerEvent}) and are produced by
- * {@link HebrewCalendar.calendar}.
+ * {@link calendar}.
  *
  * To get the title of the event in a language other than English with
  * Sephardic transliterations, use the {@link Event.render} method.
@@ -2997,7 +3368,7 @@ function computeIsoWeekFields(isoDateFields) {
   weeksInYear = computeIsoWeeksInYear(++yearOfWeek)), {
     weekOfYear: weekOfYear,
     yearOfWeek: yearOfWeek,
-    Ie: weeksInYear
+    Be: weeksInYear
   };
 }
 
@@ -3043,27 +3414,27 @@ function constrainIsoDateFields(isoDate, overflow) {
 }
 
 function computeCalendarDateFields(calendar, isoDate) {
-  return calendar ? calendar.ie(isoDate) : isoDate;
+  return calendar ? calendar.ae(isoDate) : isoDate;
 }
 
 function computeCalendarMonthCodeParts(calendar, year, month) {
-  return calendar ? calendar.O(year, month) : computeIsoMonthCodeParts(month);
+  return calendar ? calendar.L(year, month) : computeIsoMonthCodeParts(month);
 }
 
 function computeCalendarEraFields(calendar, isoDate) {
-  return 0 === calendar ? computeGregoryEraFields(isoDate) : calendar ? calendar.h(isoDate) : {};
+  return 0 === calendar ? computeGregoryEraFields(isoDate) : calendar && calendar.h?.(isoDate) || {};
 }
 
 function computeCalendarIsoFieldsFromParts(calendar, year, month, day) {
-  return calendar ? calendar.je(year, month, day) : computeIsoFieldsFromParts(year, month, day);
+  return calendar ? calendar.de(year, month, day) : computeIsoFieldsFromParts(year, month, day);
 }
 
 function computeCalendarMonthsInYearForYear(calendar, year) {
-  return calendar ? calendar.k(year) : 12;
+  return calendar ? calendar.j(year) : 12;
 }
 
 function computeCalendarDaysInMonthForYearMonth(calendar, year, month) {
-  return calendar ? calendar.p(year, month) : computeIsoDaysInMonth(year, month);
+  return calendar ? calendar.o(year, month) : computeIsoDaysInMonth(year, month);
 }
 
 function computeCalendarMonthCode(calendar, isoDate) {
@@ -3074,7 +3445,7 @@ function computeCalendarMonthCode(calendar, isoDate) {
 
 function computeCalendarInLeapYear(calendar, isoDate) {
   const {year: year} = computeCalendarDateFields(calendar, isoDate);
-  return calendar ? calendar.u(year) : computeIsoInLeapYear(year);
+  return calendar ? calendar.q(year) : computeIsoInLeapYear(year);
 }
 
 function computeCalendarMonthsInYear(calendar, isoDate) {
@@ -3089,7 +3460,7 @@ function computeCalendarDaysInMonth(calendar, isoDate) {
 
 function computeCalendarDaysInYear(calendar, isoDate) {
   const {year: year} = computeCalendarDateFields(calendar, isoDate);
-  return calendar ? calendar.j(year) : computeIsoDaysInYear(year);
+  return calendar ? calendar.i(year) : computeIsoDaysInYear(year);
 }
 
 function computeCalendarDayOfYear(calendar, isoDate) {
@@ -3121,9 +3492,6 @@ const durationDateFieldNamesAsc = /*@__PURE__*/ durationFieldNamesAsc.slice(6);
 
 const durationCalendarFieldNamesAsc = /*@__PURE__*/ durationDateFieldNamesAsc.slice(1);
 
-const durationFieldIndexes = /*@__PURE__*/ durationFieldNamesAsc.reduce((indexes, fieldName, i) => (indexes[fieldName] = i, 
-indexes), {});
-
 const durationFieldDefaults = /*@__PURE__*/ zipPropsConst(durationFieldNamesAsc, 0);
 
 const durationTimeFieldDefaults = /*@__PURE__*/ zipPropsConst(durationTimeFieldNamesAsc, 0);
@@ -3257,7 +3625,7 @@ function coerceUnitOption(optionName, options, minUnit = 0, ensureDefined) {
     return ensureDefined ? minUnit : null;
   }
   let unit = unitNameMap[unitStr];
-  return void 0 === unit && (unit = durationFieldIndexes[unitStr]), void 0 === unit && throwRangeError(invalidChoice(optionName, unitStr, unitNameMap)), 
+  return void 0 === unit && (unit = durationFieldNamesAsc.indexOf(unitStr)), unit < 0 && throwRangeError(invalidChoice(optionName, unitStr, unitNameMap)), 
   unit;
 }
 
@@ -3439,58 +3807,57 @@ function totalDuration(refineRelativeTo, slots, options) {
     let totalUnit = coerceTotalUnit(options);
     return totalUnit = requirePropDefined("unit", totalUnit), [ totalUnit, relativeToInternals ];
   })(options, refineRelativeTo);
-  if (!relativeToSlots && isUniformUnit(Math.max(totalUnit, maxDurationUnit), relativeToSlots)) {
+  const maxUnit = Math.max(totalUnit, maxDurationUnit);
+  const isZoned = relativeToSlots && isZonedEpochSlots(relativeToSlots);
+  if (!relativeToSlots && isUniformUnit(maxUnit, isZoned)) {
     return totalDayTimeDuration(slots, totalUnit);
   }
-  if (relativeToSlots || throwRangeError("Missing relativeTo"), !slots.sign && isUniformUnit(totalUnit, relativeToSlots)) {
+  if (relativeToSlots || throwRangeError("Missing relativeTo"), !slots.sign && isUniformUnit(totalUnit, isZoned)) {
     return 0;
   }
-  const markerSpanOps = createMarkerSpanOps(relativeToSlots);
-  const endMarker = markerSpanOps.G(markerSpanOps.i, slots);
-  checkMarkerSpanInBounds(markerSpanOps, endMarker);
-  const balancedDuration = markerSpanOps.re(markerSpanOps.i, endMarker, totalUnit);
-  return isUniformUnit(totalUnit, relativeToSlots) ? totalDayTimeDuration(balancedDuration, totalUnit) : totalRelativeDuration(balancedDuration, markerSpanOps.V(endMarker), totalUnit, markerSpanOps);
+  const [balancedDuration, endEpochNano, relativeOps] = spanRelativeDuration(relativeToSlots, slots, totalUnit);
+  return isUniformUnit(totalUnit, isZoned) ? totalDayTimeDuration(balancedDuration, totalUnit) : totalRelativeDuration(balancedDuration, endEpochNano, totalUnit, relativeOps);
 }
 
-function totalRelativeDuration(durationFields, endEpochNano, totalUnit, markerMoveOps) {
+function totalRelativeDuration(durationFields, endEpochNano, totalUnit, relativeOps) {
   const sign = computeDurationSign(durationFields) || 1;
-  const nudgeWindow = clampRelativeDuration(clearDurationFields(totalUnit, durationFields), totalUnit, sign, markerMoveOps, endEpochNano);
-  const epochNano0 = nudgeWindow.ae;
-  const epochNano1 = nudgeWindow.de;
+  const nudgeWindow = clampRelativeDuration(clearDurationFields(totalUnit, durationFields), totalUnit, sign, relativeOps, endEpochNano);
+  const epochNano0 = nudgeWindow.ee;
+  const epochNano1 = nudgeWindow.te;
   const denom = Number(epochNano1 - epochNano0);
   const numerator = Number(endEpochNano - epochNano0);
-  return nudgeWindow.ye[durationFieldNamesAsc[totalUnit]] + numerator / denom * sign;
+  return nudgeWindow.pe[durationFieldNamesAsc[totalUnit]] + numerator / denom * sign;
 }
 
 function totalDayTimeDuration(durationFields, totalUnit) {
   return divideBigNanoToExactNumber(durationDayTimeToBigNano(durationFields), unitNanoMap[totalUnit]);
 }
 
-function clampRelativeDuration(durationFields, clampUnit, clampDistance, markerMoveOps, epochNanoProgress) {
+function clampRelativeDuration(durationFields, clampUnit, clampDistance, relativeOps, epochNanoProgress) {
   const unitName = durationFieldNamesAsc[clampUnit];
   let startDurationFields = durationFields;
   let shifted = 0;
-  let window = computeRelativeDurationWindow(startDurationFields, unitName, clampDistance, markerMoveOps);
-  return epochNanoProgress && !((epochNanoProgress, epochNano0, epochNano1, sign) => sign > 0 ? compareBigInts(epochNano0, epochNanoProgress) <= 0 && compareBigInts(epochNanoProgress, epochNano1) <= 0 : compareBigInts(epochNano1, epochNanoProgress) <= 0 && compareBigInts(epochNanoProgress, epochNano0) <= 0)(epochNanoProgress, window.ae, window.de, Math.sign(clampDistance)) && (startDurationFields = {
+  let window = computeRelativeDurationWindow(startDurationFields, unitName, clampDistance, relativeOps);
+  return epochNanoProgress && !((epochNanoProgress, epochNano0, epochNano1, sign) => sign > 0 ? compareBigInts(epochNano0, epochNanoProgress) <= 0 && compareBigInts(epochNanoProgress, epochNano1) <= 0 : compareBigInts(epochNano1, epochNanoProgress) <= 0 && compareBigInts(epochNanoProgress, epochNano0) <= 0)(epochNanoProgress, window.ee, window.te, Math.sign(clampDistance)) && (startDurationFields = {
     ...durationFields,
     [unitName]: durationFields[unitName] + clampDistance
-  }, shifted = 1, window = computeRelativeDurationWindow(startDurationFields, unitName, clampDistance, markerMoveOps)), 
+  }, shifted = 1, window = computeRelativeDurationWindow(startDurationFields, unitName, clampDistance, relativeOps)), 
   {
     ...window,
-    ye: startDurationFields,
-    He: shifted
+    pe: startDurationFields,
+    Ae: shifted
   };
 }
 
-function computeRelativeDurationWindow(startDurationFields, unitName, clampDistance, markerMoveOps) {
+function computeRelativeDurationWindow(startDurationFields, unitName, clampDistance, relativeOps) {
   const endDurationFields = {
     ...startDurationFields,
     [unitName]: startDurationFields[unitName] + clampDistance
   };
   return {
-    ae: moveMarkerToEpochNano(markerMoveOps, startDurationFields),
-    de: moveMarkerToEpochNano(markerMoveOps, endDurationFields),
-    Ae: endDurationFields
+    ee: moveRelativeToEpochNano(relativeOps, startDurationFields),
+    te: moveRelativeToEpochNano(relativeOps, endDurationFields),
+    se: endDurationFields
   };
 }
 
@@ -3521,7 +3888,7 @@ function roundZonedEpochSlotsToUnit(slots, smallestUnit, roundingInc, roundingMo
     const isoFields1 = combineDateAndTime(moveByDays(isoFields0, 1), timeFieldDefaults);
     const epochNano0 = getStartOfDayInstantFor(timeZone, isoFields0);
     const epochNano1 = getStartOfDayInstantFor(timeZone, isoFields1);
-    epochNanoseconds = roundWithMode(computeEpochNanoFrac(epochNanoseconds, epochNano0, epochNano1), roundingMode) ? epochNano1 : epochNano0;
+    epochNanoseconds = roundWithMode(computeZonedDayRoundFrac(epochNanoseconds, epochNano0, epochNano1), roundingMode) ? epochNano1 : epochNano0;
   } else {
     const isoDateTime = zonedEpochSlotsToIso(slots);
     const offsetNano = isoDateTime.offsetNanoseconds;
@@ -3547,6 +3914,10 @@ function computeZonedStartOfDay(slots) {
   return createZonedEpochNanoSlots(getStartOfDayInstantFor(timeZone, combineDateAndTime(zonedEpochSlotsToIso(slots), timeFieldDefaults)), timeZone, calendar);
 }
 
+function computeZonedDayRoundFrac(epochNano, epochNano0, epochNano1) {
+  return computeEpochNanoFrac(epochNano < epochNano1 ? epochNano : epochNano1 - 1n, epochNano0, epochNano1);
+}
+
 function roundDateTimeToNano(isoDateTime, nanoInc, roundingMode) {
   const [roundedTimeFields, dayDelta] = roundTimeToNano(isoDateTime, nanoInc, roundingMode);
   const roundedIsoDateTime = combineDateAndTime(moveByDays(isoDateTime, dayDelta), roundedTimeFields);
@@ -3574,28 +3945,28 @@ function roundDayTimeDurationByInc(durationFields, nanoInc, roundingMode) {
   return nanoToDurationDayTimeFields(roundBigNanoToInc(durationDayTimeToBigNano(durationFields), BigInt(nanoInc), roundingMode), maxUnit);
 }
 
-function roundRelativeDuration(durationFields, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode, markerMoveOps) {
+function roundRelativeDuration(durationFields, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode, relativeOps, isZoned) {
   if (0 === smallestUnit && 1 === roundingInc) {
     return durationFields;
   }
   const sign = computeDurationSign(durationFields) || 1;
-  const nudgeFunc = isUniformUnit(smallestUnit, markerMoveOps.i) ? isZonedEpochSlots(markerMoveOps.i) && smallestUnit < 6 && largestUnit >= 6 ? nudgeZonedTimeDuration : nudgeDayTimeDuration : nudgeRelativeDuration;
-  let [roundedDurationFields, roundedEpochNano, grewBigUnit] = nudgeFunc(sign, durationFields, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode, markerMoveOps);
-  return grewBigUnit && 7 !== smallestUnit && (roundedDurationFields = ((durationFields, endEpochNano, largestUnit, smallestUnit, sign, markerMoveOps) => {
+  const nudgeFunc = isUniformUnit(smallestUnit, isZoned) ? isZoned && smallestUnit < 6 && largestUnit >= 6 ? nudgeZonedTimeDuration : nudgeDayTimeDuration : nudgeRelativeDuration;
+  let [roundedDurationFields, roundedEpochNano, grewBigUnit] = nudgeFunc(sign, durationFields, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode, relativeOps);
+  return grewBigUnit && 7 !== smallestUnit && (roundedDurationFields = ((durationFields, endEpochNano, largestUnit, smallestUnit, sign, relativeOps) => {
     for (let currentUnit = smallestUnit + 1; currentUnit <= largestUnit; currentUnit++) {
       if (7 === currentUnit && 7 !== largestUnit) {
         continue;
       }
       const baseDurationFields = clearDurationFields(currentUnit, durationFields);
       baseDurationFields[durationFieldNamesAsc[currentUnit]] += sign;
-      const thresholdCompare = compareBigInts(endEpochNano, moveMarkerToEpochNano(markerMoveOps, baseDurationFields));
+      const thresholdCompare = compareBigInts(endEpochNano, moveRelativeToEpochNano(relativeOps, baseDurationFields));
       if (thresholdCompare && thresholdCompare !== sign) {
         break;
       }
       durationFields = baseDurationFields;
     }
     return durationFields;
-  })(roundedDurationFields, roundedEpochNano, largestUnit, Math.max(6, smallestUnit), sign, markerMoveOps)), 
+  })(roundedDurationFields, roundedEpochNano, largestUnit, Math.max(6, smallestUnit), sign, relativeOps)), 
   roundedDurationFields;
 }
 
@@ -3638,16 +4009,16 @@ function nudgeDayTimeDuration(sign, durationFields, endEpochNano, largestUnit, s
   }, endEpochNano + nanoDiff, expandedBigUnit ];
 }
 
-function nudgeZonedTimeDuration(sign, durationFields, endEpochNano, _largestUnit, smallestUnit, roundingInc, roundingMode, markerMoveOps) {
+function nudgeZonedTimeDuration(sign, durationFields, endEpochNano, _largestUnit, smallestUnit, roundingInc, roundingMode, relativeOps) {
   const timeNano = Number(durationTimeToBigNano(durationFields));
   const nanoInc = computeNanoInc(smallestUnit, roundingInc);
   let roundedTimeNano = roundNumberToInc(timeNano, nanoInc, roundingMode);
   const dayWindow = clampRelativeDuration({
     ...durationFields,
     ...durationTimeFieldDefaults
-  }, 6, sign, markerMoveOps, endEpochNano);
-  const dayEpochNano0 = dayWindow.ae;
-  const dayEpochNano1 = dayWindow.de;
+  }, 6, sign, relativeOps, endEpochNano);
+  const dayEpochNano0 = dayWindow.ee;
+  const dayEpochNano1 = dayWindow.te;
   const beyondDayNano = roundedTimeNano - Number(dayEpochNano1 - dayEpochNano0);
   let dayDelta = 0;
   beyondDayNano && Math.sign(beyondDayNano) !== sign ? endEpochNano = dayEpochNano0 + BigInt(roundedTimeNano) : (dayDelta += sign, 
@@ -3660,7 +4031,7 @@ function nudgeZonedTimeDuration(sign, durationFields, endEpochNano, _largestUnit
   }, endEpochNano, Boolean(dayDelta) ];
 }
 
-function nudgeRelativeDuration(sign, durationFields, endEpochNano, _largestUnit, smallestUnit, roundingInc, roundingMode, markerMoveOps) {
+function nudgeRelativeDuration(sign, durationFields, endEpochNano, _largestUnit, smallestUnit, roundingInc, roundingMode, relativeOps) {
   const smallestUnitFieldName = durationFieldNamesAsc[smallestUnit];
   const baseDurationFields = clearDurationFields(smallestUnit, durationFields);
   7 === smallestUnit && (durationFields = {
@@ -3669,19 +4040,19 @@ function nudgeRelativeDuration(sign, durationFields, endEpochNano, _largestUnit,
   });
   const truncedVal = divTrunc(durationFields[smallestUnitFieldName], roundingInc) * roundingInc;
   baseDurationFields[smallestUnitFieldName] = truncedVal;
-  const nudgeWindow = clampRelativeDuration(baseDurationFields, smallestUnit, roundingInc * sign, markerMoveOps, endEpochNano);
-  const epochNano0 = nudgeWindow.ae;
-  const epochNano1 = nudgeWindow.de;
+  const nudgeWindow = clampRelativeDuration(baseDurationFields, smallestUnit, roundingInc * sign, relativeOps, endEpochNano);
+  const epochNano0 = nudgeWindow.ee;
+  const epochNano1 = nudgeWindow.te;
   const frac = computeEpochNanoFrac(endEpochNano, epochNano0, epochNano1);
-  const windowStartVal = nudgeWindow.ye[smallestUnitFieldName];
-  const windowEndVal = nudgeWindow.Ae[smallestUnitFieldName];
+  const windowStartVal = nudgeWindow.pe[smallestUnitFieldName];
+  const windowEndVal = nudgeWindow.se[smallestUnitFieldName];
   const roundedVal = roundNumberToInc(windowStartVal + frac * sign * roundingInc, roundingInc, roundingMode);
   const roundedToEnd = roundedVal === windowEndVal;
-  return baseDurationFields[smallestUnitFieldName] = roundedVal, [ baseDurationFields, roundedToEnd ? epochNano1 : epochNano0, nudgeWindow.He || roundedToEnd ];
+  return baseDurationFields[smallestUnitFieldName] = roundedVal, [ baseDurationFields, roundedToEnd ? epochNano1 : epochNano0, nudgeWindow.Ae || roundedToEnd ];
 }
 
 function getTimeZoneTransitionEpochNanoseconds(slots, options) {
-  return slots.timeZone.U(slots.epochNanoseconds, (options => {
+  return slots.timeZone.O(slots.epochNanoseconds, (options => {
     const normalizedOptions = normalizeOptionsOrString(options, "direction");
     const res = coerceDirection(normalizedOptions, 0);
     return res || throwRangeError(invalidEntity("direction", res)), res;
@@ -3692,7 +4063,7 @@ const zonedEpochSlotsToIso = /*@__PURE__*/ memoize(_zonedEpochSlotsToIso, WeakMa
 
 function _zonedEpochSlotsToIso(slots) {
   const {epochNanoseconds: epochNanoseconds, timeZone: timeZone} = slots;
-  const offsetNanoseconds = timeZone.C(epochNanoseconds);
+  const offsetNanoseconds = timeZone.B(epochNanoseconds);
   return {
     ...epochNanoToIsoDateTime(epochNanoseconds + BigInt(offsetNanoseconds)),
     offsetNanoseconds: offsetNanoseconds
@@ -3704,7 +4075,7 @@ function getMatchingInstantFor(timeZone, isoDateTime, offsetNano, offsetDisambig
     return isoDateTimeAndOffsetToEpochNano(isoDateTime, offsetNano);
   }
   2 !== offsetDisambig && 0 !== offsetDisambig || checkIsoDateInBounds(isoDateTime, 0);
-  const possibleEpochNanos = timeZone.R(isoDateTime);
+  const possibleEpochNanos = timeZone.N(isoDateTime);
   if (void 0 !== offsetNano && 3 !== offsetDisambig) {
     const matchingEpochNano = ((possibleEpochNanos, isoDateTime, offsetNano, fuzzy) => {
       const zonedEpochNano = isoDateTimeToEpochNano(isoDateTime);
@@ -3724,7 +4095,7 @@ function getMatchingInstantFor(timeZone, isoDateTime, offsetNano, offsetDisambig
   return hasZ ? isoDateTimeToEpochNano(isoDateTime) : getSingleInstantFor(timeZone, isoDateTime, epochDisambig, possibleEpochNanos);
 }
 
-function getSingleInstantFor(timeZone, isoDateTime, disambig = 0, possibleEpochNanos = timeZone.R(isoDateTime)) {
+function getSingleInstantFor(timeZone, isoDateTime, disambig = 0, possibleEpochNanos = timeZone.N(isoDateTime)) {
   if (1 === possibleEpochNanos.length) {
     return possibleEpochNanos[0];
   }
@@ -3733,21 +4104,21 @@ function getSingleInstantFor(timeZone, isoDateTime, disambig = 0, possibleEpochN
   }
   const zonedEpochNano = isoDateTimeToEpochNano(isoDateTime);
   const gapNano = ((timeZone, zonedEpochNano) => {
-    const startOffsetNano = timeZone.C(zonedEpochNano - bigNanoInUtcDay);
+    const startOffsetNano = timeZone.B(zonedEpochNano - bigNanoInUtcDay);
     return (gapNano => (gapNano > nanoInUtcDay && throwRangeError("Out-of-bounds TimeZone gap"), 
-    gapNano))(timeZone.C(zonedEpochNano + bigNanoInUtcDay) - startOffsetNano);
+    gapNano))(timeZone.B(zonedEpochNano + bigNanoInUtcDay) - startOffsetNano);
   })(timeZone, zonedEpochNano);
   const shiftedIsoDateTime = epochNanoToIsoDateTime(zonedEpochNano + BigInt(gapNano * (2 === disambig ? -1 : 1)));
-  return (possibleEpochNanos = timeZone.R(shiftedIsoDateTime))[2 === disambig ? 0 : possibleEpochNanos.length - 1];
+  return (possibleEpochNanos = timeZone.N(shiftedIsoDateTime))[2 === disambig ? 0 : possibleEpochNanos.length - 1];
 }
 
 function getStartOfDayInstantFor(timeZone, isoDateTime) {
-  const possibleEpochNanos = timeZone.R(isoDateTime);
+  const possibleEpochNanos = timeZone.N(isoDateTime);
   if (possibleEpochNanos.length) {
     return possibleEpochNanos[0];
   }
   const zonedEpochNanoDayBefore = isoDateTimeToEpochNano(isoDateTime) - bigNanoInUtcDay;
-  return timeZone.U(zonedEpochNanoDayBefore, 1);
+  return timeZone.O(zonedEpochNanoDayBefore, 1);
 }
 
 function moveYearMonth(doSubtract, calendar, isoDateFields, durationSlots, options) {
@@ -3784,12 +4155,11 @@ function moveZonedEpochSlots(slots, durationFields, options) {
 
 function moveDateTime(calendar, isoDateTimeFields, durationFields, options) {
   const [movedTimeFields, dayDelta] = moveTime(isoDateTimeFields, durationFields);
-  const movedIsoDateTimeFields = combineDateAndTime(moveDate(calendar, isoDateTimeFields, {
+  return checkIsoDateTimeInBounds(combineDateAndTime(moveDate(calendar, isoDateTimeFields, {
     ...durationFields,
     ...durationTimeFieldDefaults,
     days: durationFields.days + dayDelta
-  }, options), movedTimeFields);
-  return checkIsoDateTimeInBounds(movedIsoDateTimeFields), movedIsoDateTimeFields;
+  }, options), movedTimeFields));
 }
 
 function moveDate(calendar, isoDateFields, durationFields, options) {
@@ -3836,11 +4206,11 @@ function addDateMonths(calendar, isoDateFields, years, months, overflow) {
   let {year: year, month: month, day: day} = dateParts;
   if (years) {
     const [monthCodeNumber, isLeapMonth] = computeCalendarMonthCodeParts(calendar, year, month);
-    year += years, month = computeYearMovedMonth(calendar, monthCodeNumber, isLeapMonth, calendar ? calendar.q(year) : void 0, overflow), 
+    year += years, month = computeYearMovedMonth(calendar, monthCodeNumber, isLeapMonth, calendar ? calendar.p(year) : void 0, overflow), 
     month = clampEntity("month", month, 1, computeCalendarMonthsInYearForYear(calendar, year), overflow);
   }
   if (months) {
-    const yearMonthParts = calendar ? calendar.N(year, month, months) : addIsoMonths(year, month, months);
+    const yearMonthParts = calendar ? calendar.K(year, month, months) : addIsoMonths(year, month, months);
     ({year: year, month: month} = yearMonthParts);
   }
   return day = clampEntity("day", day, 1, computeCalendarDaysInMonthForYearMonth(calendar, year, month), overflow), 
@@ -3849,7 +4219,7 @@ function addDateMonths(calendar, isoDateFields, years, months, overflow) {
 
 function computeYearMovedMonth(calendar, monthCodeNumber, isLeapMonth, targetLeapMonth, overflow) {
   if (isLeapMonth) {
-    const leapMonthMeta = calendar ? calendar.m : void 0;
+    const leapMonthMeta = calendar ? calendar.l : void 0;
     return void 0 !== targetLeapMonth && (leapMonthMeta < 0 || targetLeapMonth === monthCodeNumber + 1) ? targetLeapMonth : (1 === overflow && throwRangeError(invalidLeapMonth), 
     leapMonthMeta < 0 ? -leapMonthMeta : monthCodeNumber);
   }
@@ -3862,7 +4232,7 @@ function getCommonCalendar(a, b) {
 }
 
 function getCommonTimeZone(a, b) {
-  return a.o !== b.o && throwRangeError("Mismatching TimeZones"), 
+  return a.m !== b.m && throwRangeError("Mismatching TimeZones"), 
   a;
 }
 
@@ -3881,9 +4251,18 @@ function diffZonedDateTimes(invert, calendar, slots0, slots1, options) {
   const epochNano0 = slots0.epochNanoseconds;
   const epochNano1 = slots1.epochNanoseconds;
   let durationFields;
-  return compareBigInts(epochNano1, epochNano0) ? largestUnit < 6 ? durationFields = diffEpochNanos(epochNano0, epochNano1, largestUnit, smallestUnit, roundingInc, roundingMode) : (durationFields = diffZonedEpochsExact(getCommonTimeZone(slots0.timeZone, slots1.timeZone), calendar, slots0, slots1, largestUnit), 
-  durationFields = roundRelativeDuration(durationFields, epochNano1, largestUnit, smallestUnit, roundingInc, roundingMode, createMarkerMoveOps(slots0, getEpochNano, moveZonedEpochSlots))) : durationFields = durationFieldDefaults, 
-  createDurationSlots(invert ? negateDurationFields(durationFields) : durationFields);
+  if (compareBigInts(epochNano1, epochNano0)) {
+    if (largestUnit < 6) {
+      durationFields = diffEpochNanos(epochNano0, epochNano1, largestUnit, smallestUnit, roundingInc, roundingMode);
+    } else {
+      const timeZone = getCommonTimeZone(slots0.timeZone, slots1.timeZone);
+      durationFields = diffZonedEpochsExact(timeZone, calendar, slots0, slots1, largestUnit), 
+      durationFields = roundRelativeDuration(durationFields, epochNano1, largestUnit, smallestUnit, roundingInc, roundingMode, createZonedRelativeOps(calendar, timeZone, slots0), 1);
+    }
+  } else {
+    durationFields = durationFieldDefaults;
+  }
+  return createDurationSlots(invert ? negateDurationFields(durationFields) : durationFields);
 }
 
 function diffPlainDateTimes(invert, calendar, plainDateTimeSlots0, plainDateTimeSlots1, options) {
@@ -3893,7 +4272,7 @@ function diffPlainDateTimes(invert, calendar, plainDateTimeSlots0, plainDateTime
   const sign = compareBigInts(endEpochNano, startEpochNano);
   let durationFields;
   return sign ? largestUnit <= 6 ? durationFields = diffEpochNanos(startEpochNano, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode) : (durationFields = diffDateTimesBig(calendar, plainDateTimeSlots0, plainDateTimeSlots1, sign, largestUnit), 
-  durationFields = roundRelativeDuration(durationFields, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode, createMarkerMoveOps(plainDateTimeSlots0, isoDateTimeToEpochNano, bindArgs(moveDateTime, calendar)))) : durationFields = durationFieldDefaults, 
+  durationFields = roundRelativeDuration(durationFields, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode, createDateTimeRelativeOps(calendar, plainDateTimeSlots0))) : durationFields = durationFieldDefaults, 
   createDurationSlots(invert ? negateDurationFields(durationFields) : durationFields);
 }
 
@@ -3914,7 +4293,7 @@ function diffDateLike(invert, calendar, startIsoDate, endIsoDate, largestUnit, s
   const endEpochNano = isoDateToEpochNano(endIsoDate);
   let durationFields;
   return compareBigInts(endEpochNano, startEpochNano) ? 6 === largestUnit ? durationFields = diffEpochNanos(startEpochNano, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode) : (durationFields = diffCalendarDates(calendar, startIsoDate, endIsoDate, largestUnit), 
-  smallestUnit === smallestPrecision && 1 === roundingInc || (durationFields = roundRelativeDuration(durationFields, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode, createMarkerMoveOps(startIsoDate, isoDateToEpochNano, bindArgs(moveDate, calendar))))) : durationFields = durationFieldDefaults, 
+  smallestUnit === smallestPrecision && 1 === roundingInc || (durationFields = roundRelativeDuration(durationFields, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode, createDateRelativeOps(calendar, startIsoDate)))) : durationFields = durationFieldDefaults, 
   createDurationSlots(invert ? negateDurationFields(durationFields) : durationFields);
 }
 
@@ -3996,7 +4375,7 @@ function diffCalendarDates(calendar, startIsoDate, endIsoDate, largestUnit) {
     let months = 0;
     let days = 0;
     if (sign) {
-      months = calendar ? calendar.ne(year0, month0, year1, month1) : diffIsoMonthSlots(year0, month0, year1, month1);
+      months = calendar ? calendar._(year0, month0, year1, month1) : diffIsoMonthSlots(year0, month0, year1, month1);
       let anchorIsoDate = addDateMonths(calendar, startIsoDate, 0, months, 0);
       sign * compareNumbers(day0, day1) > 0 && (months -= sign, anchorIsoDate = addDateMonths(calendar, startIsoDate, 0, months, 0)), 
       days = diffDays(anchorIsoDate, endIsoDate);
@@ -4018,7 +4397,7 @@ function diffCalendarDates(calendar, startIsoDate, endIsoDate, largestUnit) {
     let dayCorrect = 0;
     if (Math.sign(day1 - day0) === -sign) {
       const origDaysInMonth1 = daysInMonth1;
-      const yearMonthParts = calendar ? calendar.N(year1, month1, -sign) : addIsoMonths(year1, month1, -sign);
+      const yearMonthParts = calendar ? calendar.K(year1, month1, -sign) : addIsoMonths(year1, month1, -sign);
       (({year: year1, month: month1} = yearMonthParts)), yearDiff = year1 - year0, monthDiff = month1 - month0, 
       daysInMonth1 = computeCalendarDaysInMonthForYearMonth(calendar, year1, month1), 
       dayCorrect = sign < 0 ? -origDaysInMonth1 : daysInMonth1;
@@ -4026,14 +4405,14 @@ function diffCalendarDates(calendar, startIsoDate, endIsoDate, largestUnit) {
     if (dayDiff = day1 - Math.min(day0, daysInMonth1) + dayCorrect, yearDiff) {
       const [monthCodeNumber0, isLeapMonth0] = computeCalendarMonthCodeParts(calendar, year0, month0);
       const [monthCodeNumber1, isLeapMonth1] = computeCalendarMonthCodeParts(calendar, year1, month1);
-      const leapMonthMeta = calendar ? calendar.m : void 0;
+      const leapMonthMeta = calendar ? calendar.l : void 0;
       if (monthDiff = void 0 !== leapMonthMeta && isLeapMonth0 && !isLeapMonth1 && (leapMonthMeta < 0 ? sign > 0 && monthCodeNumber1 === -leapMonthMeta : sign < 0 && monthCodeNumber1 === monthCodeNumber0) ? 0 : monthCodeNumber1 - monthCodeNumber0 || Number(isLeapMonth1) - Number(isLeapMonth0), 
       Math.sign(monthDiff) === -sign) {
         const monthCorrect = sign < 0 && -computeCalendarMonthsInYearForYear(calendar, year1);
-        year1 -= sign, yearDiff = year1 - year0, monthDiff = month1 - computeYearMovedMonth(calendar, monthCodeNumber0, isLeapMonth0, calendar ? calendar.q(year1) : void 0, 0) + (monthCorrect || computeCalendarMonthsInYearForYear(calendar, year1));
+        year1 -= sign, yearDiff = year1 - year0, monthDiff = month1 - computeYearMovedMonth(calendar, monthCodeNumber0, isLeapMonth0, calendar ? calendar.p(year1) : void 0, 0) + (monthCorrect || computeCalendarMonthsInYearForYear(calendar, year1));
       } else if (calendar) {
-        const month0Projected = computeYearMovedMonth(calendar, monthCodeNumber0, isLeapMonth0, calendar.q(year1), 0);
-        monthDiff = calendar.ne(year1, month0Projected, year1, month1);
+        const month0Projected = computeYearMovedMonth(calendar, monthCodeNumber0, isLeapMonth0, calendar.p(year1), 0);
+        monthDiff = calendar._(year1, month0Projected, year1, month1);
       }
     }
   }
@@ -4077,56 +4456,60 @@ function diffDays(startIsoDate, endIsoDate) {
   return isoDateToEpochDays(endIsoDate) - isoDateToEpochDays(startIsoDate);
 }
 
-function createMarkerMoveOps(marker, markerToEpochNano, moveMarker) {
+function createDateRelativeOps(calendar, origin) {
   return {
-    i: marker,
-    V: markerToEpochNano,
-    G: moveMarker
+    origin: origin,
+    ie: isoDateToEpochNano(origin),
+    calendar: calendar,
+    he: isoDateToEpochNano
   };
 }
 
-function createMarkerSpanOps(relativeToSlots) {
-  const {calendar: calendar} = relativeToSlots;
-  if (isZonedEpochSlots(relativeToSlots)) {
-    const {timeZone: timeZone} = relativeToSlots;
-    return {
-      i: relativeToSlots,
-      V: getEpochNano,
-      G: moveZonedEpochSlots,
-      re: bindArgs(diffZonedEpochsExact, timeZone, calendar)
-    };
-  }
+function createDateTimeRelativeOps(calendar, origin) {
   return {
-    i: normalizeDateTimeMarker(relativeToSlots),
-    V: isoDateTimeToEpochNano,
-    G: bindArgs(moveDateTime, calendar),
-    re: bindArgs(diffDateTimesExact, calendar)
+    origin: origin,
+    ie: isoDateTimeToEpochNano(origin),
+    calendar: calendar,
+    he: movedIsoDate => isoDateTimeToEpochNano(combineDateAndTime(movedIsoDate, origin))
   };
 }
 
-function moveMarkerToEpochNano(markerMoveOps, durationFields) {
-  return markerMoveOps.V(markerMoveOps.G(markerMoveOps.i, durationFields));
+function createZonedRelativeOps(calendar, timeZone, slots) {
+  const origin = zonedEpochSlotsToIso(slots);
+  return {
+    origin: origin,
+    ie: slots.epochNanoseconds,
+    calendar: calendar,
+    he: movedIsoDate => getSingleInstantFor(timeZone, combineDateAndTime(movedIsoDate, origin))
+  };
 }
 
-function isZonedEpochSlots(marker) {
-  return "timeZone" in marker;
+function moveRelativeToEpochNano(relativeOps, dateDuration) {
+  return durationHasDateParts(dateDuration) ? relativeOps.he(moveDate(relativeOps.calendar, relativeOps.origin, dateDuration)) : relativeOps.ie;
 }
 
-function checkMarkerSpanInBounds(markerSpanOps, endMarker) {
-  isZonedEpochSlots(markerSpanOps.i) || (checkMarkerInBounds(markerSpanOps.i), 
-  checkMarkerInBounds(endMarker));
+function spanRelativeDuration(relativeToSlots, durationFields, largestUnit) {
+  const {calendar: calendar} = relativeToSlots;
+  if (isZonedEpochSlots(relativeToSlots)) {
+    const {timeZone: timeZone} = relativeToSlots;
+    const endSlots = moveZonedEpochSlots(relativeToSlots, durationFields);
+    return [ diffZonedEpochsExact(timeZone, calendar, relativeToSlots, endSlots, largestUnit), endSlots.epochNanoseconds, createZonedRelativeOps(calendar, timeZone, relativeToSlots) ];
+  }
+  const origin = checkIsoDateTimeInBounds(combineDateAndTime(relativeToSlots, timeFieldDefaults));
+  const end = moveDateTime(calendar, origin, durationFields);
+  return [ diffDateTimesExact(calendar, origin, end, largestUnit), isoDateTimeToEpochNano(end), createDateRelativeOps(calendar, relativeToSlots) ];
 }
 
-function normalizeDateTimeMarker(marker) {
-  return combineDateAndTime(marker, "hour" in marker ? marker : timeFieldDefaults);
+function moveRelativeEndpointToEpochNano(relativeToSlots, durationFields) {
+  return isZonedEpochSlots(relativeToSlots) ? moveZonedEpochSlots(relativeToSlots, durationFields).epochNanoseconds : isoDateTimeToEpochNano(moveDateTime(relativeToSlots.calendar, combineDateAndTime(relativeToSlots, timeFieldDefaults), durationFields));
 }
 
-function checkMarkerInBounds(marker) {
-  checkIsoDateTimeInBounds(normalizeDateTimeMarker(marker));
+function isZonedEpochSlots(slots) {
+  return "timeZone" in slots;
 }
 
-function isUniformUnit(unit, marker) {
-  return unit <= 6 - (marker && isZonedEpochSlots(marker) ? 1 : 0);
+function isUniformUnit(unit, isZoned) {
+  return unit <= 6 - (isZoned ? 1 : 0);
 }
 
 function nanoToGivenFields(nano, largestUnit, fieldNames) {
@@ -4143,14 +4526,18 @@ const maxDurationSeconds = 2 ** 53;
 function addDurations(refineRelativeTo, doSubtract, slots, otherSlots, options) {
   const relativeToSlots = refineRelativeTo(normalizeOptions(options).relativeTo);
   const maxUnit = Math.max(getMaxDurationUnit(slots), getMaxDurationUnit(otherSlots));
-  if (isUniformUnit(maxUnit, relativeToSlots)) {
-    return addDayTimeDurationsChecked(doSubtract, slots, otherSlots, maxUnit);
-  }
-  relativeToSlots || throwRangeError("Missing relativeTo"), doSubtract && (otherSlots = negateDurationFields(otherSlots));
-  const markerSpanOps = createMarkerSpanOps(relativeToSlots);
-  const midMarker = markerSpanOps.G(markerSpanOps.i, slots);
-  const endMarker = markerSpanOps.G(midMarker, otherSlots);
-  return createDurationSlots(markerSpanOps.re(markerSpanOps.i, endMarker, maxUnit));
+  return isUniformUnit(maxUnit, relativeToSlots && isZonedEpochSlots(relativeToSlots)) ? addDayTimeDurationsChecked(doSubtract, slots, otherSlots, maxUnit) : (relativeToSlots || throwRangeError("Missing relativeTo"), 
+  doSubtract && (otherSlots = negateDurationFields(otherSlots)), createDurationSlots(((relativeToSlots, durationFields0, durationFields1, largestUnit) => {
+    const {calendar: calendar} = relativeToSlots;
+    if (isZonedEpochSlots(relativeToSlots)) {
+      const {timeZone: timeZone} = relativeToSlots;
+      const midSlots = moveZonedEpochSlots(relativeToSlots, durationFields0);
+      return diffZonedEpochsExact(timeZone, calendar, relativeToSlots, moveZonedEpochSlots(midSlots, durationFields1), largestUnit);
+    }
+    const origin = combineDateAndTime(relativeToSlots, timeFieldDefaults);
+    const mid = moveDateTime(calendar, origin, durationFields0);
+    return diffDateTimesExact(calendar, origin, moveDateTime(calendar, mid, durationFields1), largestUnit);
+  })(relativeToSlots, slots, otherSlots, maxUnit)));
 }
 
 function addDayTimeDurationsChecked(doSubtract, slots, otherSlots, maxUnit) {
@@ -4188,17 +4575,14 @@ function roundDuration(refineRelativeTo, slots, options) {
       };
     })(slots, largestUnit, smallestUnit, roundingInc, roundingMode)));
   }
-  const needsZonedDayLength = relativeToSlots && isZonedEpochSlots(relativeToSlots) && largestUnit >= 6 && smallestUnit < 6;
+  const isZoned = relativeToSlots && isZonedEpochSlots(relativeToSlots);
+  const needsZonedDayLength = isZoned && largestUnit >= 6 && smallestUnit < 6;
   if (!slots.sign && !needsZonedDayLength) {
     return slots;
   }
   relativeToSlots || throwRangeError("Missing relativeTo");
-  const markerSpanOps = createMarkerSpanOps(relativeToSlots);
-  const endMarker = markerSpanOps.G(markerSpanOps.i, slots);
-  checkMarkerSpanInBounds(markerSpanOps, endMarker);
-  let balancedDuration = markerSpanOps.re(markerSpanOps.i, endMarker, largestUnit);
-  return balancedDuration = roundRelativeDuration(balancedDuration, markerSpanOps.V(endMarker), largestUnit, smallestUnit, roundingInc, roundingMode, markerSpanOps), 
-  createDurationSlots(balancedDuration);
+  const [balancedDuration, endEpochNano, relativeOps] = spanRelativeDuration(relativeToSlots, slots, largestUnit);
+  return createDurationSlots(roundRelativeDuration(balancedDuration, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode, relativeOps, isZoned));
 }
 
 function absDuration(slots) {
@@ -4275,26 +4659,15 @@ function getMaxDurationUnit(fields) {
   return unit;
 }
 
-function compareInstants(instantSlots0, instantSlots1) {
-  return compareBigInts(instantSlots0.epochNanoseconds, instantSlots1.epochNanoseconds);
-}
-
-function compareZonedDateTimes(zonedDateTimeSlots0, zonedDateTimeSlots1) {
-  return compareBigInts(zonedDateTimeSlots0.epochNanoseconds, zonedDateTimeSlots1.epochNanoseconds);
+function compareZonedEpochSlots(zonedEpochSlots0, zonedEpochSlots1) {
+  return compareBigInts(zonedEpochSlots0.epochNanoseconds, zonedEpochSlots1.epochNanoseconds);
 }
 
 function compareDurations(refineRelativeTo, durationSlots0, durationSlots1, options) {
   const relativeToSlots = refineRelativeTo(normalizeOptions(options).relativeTo);
   const maxUnit = Math.max(getMaxDurationUnit(durationSlots0), getMaxDurationUnit(durationSlots1));
-  if (allPropsEqual(durationFieldNamesAsc, durationSlots0, durationSlots1)) {
-    return 0;
-  }
-  if (isUniformUnit(maxUnit, relativeToSlots)) {
-    return compareBigInts(durationDayTimeToBigNano(durationSlots0), durationDayTimeToBigNano(durationSlots1));
-  }
-  relativeToSlots || throwRangeError("Missing relativeTo");
-  const markerSpanOps = createMarkerSpanOps(relativeToSlots);
-  return compareBigInts(moveMarkerToEpochNano(markerSpanOps, durationSlots0), moveMarkerToEpochNano(markerSpanOps, durationSlots1));
+  return allPropsEqual(durationFieldNamesAsc, durationSlots0, durationSlots1) ? 0 : isUniformUnit(maxUnit, relativeToSlots && isZonedEpochSlots(relativeToSlots)) ? compareBigInts(durationDayTimeToBigNano(durationSlots0), durationDayTimeToBigNano(durationSlots1)) : (relativeToSlots || throwRangeError("Missing relativeTo"), 
+  compareBigInts(moveRelativeEndpointToEpochNano(relativeToSlots, durationSlots0), moveRelativeEndpointToEpochNano(relativeToSlots, durationSlots1)));
 }
 
 function compareIsoDateTimeFields(isoDateTime0, isoDateTime1) {
@@ -4310,11 +4683,11 @@ function compareTimeFields(isoFields0, isoFields1) {
 }
 
 function instantsEqual(instantSlots0, instantSlots1) {
-  return !compareInstants(instantSlots0, instantSlots1);
+  return !compareZonedEpochSlots(instantSlots0, instantSlots1);
 }
 
 function zonedDateTimesEqual(zonedDateTimeSlots0, zonedDateTimeSlots1) {
-  return !compareZonedDateTimes(zonedDateTimeSlots0, zonedDateTimeSlots1) && zonedDateTimeSlots0.timeZone.o === zonedDateTimeSlots1.timeZone.o && zonedDateTimeSlots0.calendar === zonedDateTimeSlots1.calendar;
+  return !compareZonedEpochSlots(zonedDateTimeSlots0, zonedDateTimeSlots1) && zonedDateTimeSlots0.timeZone.m === zonedDateTimeSlots1.timeZone.m && zonedDateTimeSlots0.calendar === zonedDateTimeSlots1.calendar;
 }
 
 function plainDateTimesEqual(plainDateTimeSlots0, plainDateTimeSlots1) {
@@ -4338,7 +4711,7 @@ function plainTimesEqual(plainTimeSlots0, plainTimeSlots1) {
 }
 
 function getCalendarEraOrigins(calendar) {
-  return 0 === calendar ? gregoryEraOrigins : calendar ? calendar.l : void 0;
+  return 0 === calendar ? gregoryEraOrigins : calendar ? calendar.k : void 0;
 }
 
 function getCalendarFieldNames(calendar, fieldNames, fieldNamesWithEra = fieldNames) {
@@ -4356,7 +4729,7 @@ function resolveCalendarYear(calendar, fields) {
     const normalizedEra = normalizeEraName(era);
     const eraOrigin = eraOrigins[normalizedEra];
     void 0 === eraOrigin && throwRangeError((era => `Invalid era: ${era}`)(era));
-    const yearByEra = exoticCalendar?.te ? exoticCalendar.te(eraYear, normalizedEra, eraOrigin) : eraYearToYear(eraYear, eraOrigin);
+    const yearByEra = exoticCalendar?.$ ? exoticCalendar.$(eraYear, normalizedEra, eraOrigin) : eraYearToYear(eraYear, eraOrigin);
     void 0 !== year && year !== yearByEra && throwRangeError("Mismatching year/eraYear"), 
     year = yearByEra;
   } else {
@@ -4369,11 +4742,11 @@ function resolveCalendarMonth(calendar, fields, year, overflow, monthCodeParts)
   let {month: month, monthCode: monthCode} = fields;
   if (void 0 !== monthCode) {
     const monthByCode = ((calendar, monthCode, year, overflow, monthCodeParts = parseMonthCode(monthCode)) => {
-      const leapMonth = calendar ? calendar.q(year) : void 0;
+      const leapMonth = calendar ? calendar.p(year) : void 0;
       const [monthCodeNumber, wantsLeapMonth] = monthCodeParts;
       let month = monthCodeNumberToMonth(monthCodeNumber, wantsLeapMonth, leapMonth);
       if (wantsLeapMonth) {
-        const leapMonthMeta = calendar ? calendar.m : void 0;
+        const leapMonthMeta = calendar ? calendar.l : void 0;
         void 0 === leapMonthMeta && throwRangeError(invalidLeapMonth), leapMonthMeta > 0 ? (month > leapMonthMeta && throwRangeError(invalidLeapMonth), 
         leapMonth !== month && (1 === overflow && throwRangeError(invalidLeapMonth), month = monthCodeNumberToMonth(monthCodeNumber, 0, leapMonth))) : (month !== -leapMonthMeta && throwRangeError(invalidLeapMonth), 
         void 0 === leapMonth && 1 === overflow && throwRangeError(invalidLeapMonth));
@@ -4433,19 +4806,17 @@ function parseOffsetNanoMaybe(s, onlyHourMinute) {
 const dateFieldRefiners = {
   era: toStringViaPrimitive,
   month: toPositiveIntegerWithTruncation,
-  monthCode(monthCode, entityName = "monthCode") {
-    return ((monthCode, entityName) => {
-      if ("string" == typeof monthCode) {
-        return monthCode;
-      }
-      if (monthCode && "object" == typeof monthCode) {
-        const monthCodeToString = monthCode.toString;
-        if ("function" == typeof monthCodeToString) {
-          return requireString(monthCodeToString.call(monthCode), entityName);
-        }
+  monthCode(monthCode, entityName) {
+    if ("string" == typeof monthCode) {
+      return monthCode;
+    }
+    if (monthCode && "object" == typeof monthCode) {
+      const monthCodeToString = monthCode.toString;
+      if ("function" == typeof monthCodeToString) {
+        return requireString(monthCodeToString.call(monthCode), entityName);
       }
-      return requireString(monthCode, entityName);
-    })(monthCode, entityName);
+    }
+    return requireString(monthCode, entityName);
   },
   day: toPositiveIntegerWithTruncation
 };
@@ -4454,16 +4825,15 @@ const timeFieldRefiners = /*@__PURE__*/ zipPropsConst(timeFieldNamesAsc, toInteg
 
 const durationFieldRefiners = /*@__PURE__*/ zipPropsConst(durationFieldNamesAsc, toStrictInteger);
 
-const offsetFieldRefiners = {
+const dateTimeFieldRefiners = /*@__PURE__*/ Object.assign({}, dateFieldRefiners, timeFieldRefiners);
+
+const zonedDateTimeFieldRefiners = {
   offset(offsetString) {
     return parseOffsetNano(toStringViaPrimitive(offsetString));
-  }
+  },
+  ...dateTimeFieldRefiners
 };
 
-const dateTimeFieldRefiners = /*@__PURE__*/ Object.assign({}, dateFieldRefiners, timeFieldRefiners);
-
-const zonedDateTimeFieldRefiners = /*@__PURE__*/ Object.assign({}, dateTimeFieldRefiners, offsetFieldRefiners);
-
 function readAndRefineBagFields(bag, validFieldNames, fieldRefiners, requiredFieldNames, disallowEmpty = !requiredFieldNames) {
   const res = {};
   let anyMatching = 0;
@@ -4540,19 +4910,19 @@ function createPlainMonthDayFromFields(calendar, fields, options) {
     day = resolveCalendarDay(calendar, fields, month, yearMaybe, overflow), [monthCodeNumber, isLeapMonth] = computeCalendarMonthCodeParts(calendar, yearMaybe, month);
   } else {
     void 0 === fields.monthCode && throwTypeError("Missing month/monthCode"), [monthCodeNumber, isLeapMonth] = monthCodeParts;
-    const referenceYear = calendar ? calendar.ge : 1972;
+    const referenceYear = calendar ? calendar.ne : 1972;
     if (void 0 !== referenceYear) {
       day = resolveCalendarDay(calendar, fields, resolveCalendarMonth(calendar, fields, referenceYear, overflow, monthCodeParts), referenceYear, overflow);
     } else {
-      const constrainedDay = 0 === overflow && calendar ? calendar.ke?.(monthCodeNumber, isLeapMonth, fields.day) : void 0;
+      const constrainedDay = 0 === overflow && calendar ? calendar.fe?.(monthCodeNumber, isLeapMonth, fields.day) : void 0;
       day = void 0 !== constrainedDay ? constrainedDay : fields.day;
     }
   }
-  isLeapMonth && ((calendar && calendar.Z?.[monthCodeNumber]) ?? 1 / 0) < fields.day && (1 === overflow && throwRangeError(invalidLeapMonth), 
-  isLeapMonth = 0, day = constrainToRange(fields.day, 1, (calendar && calendar.X) ?? 1 / 0));
-  let res = calendar ? calendar.v(monthCodeNumber, Boolean(isLeapMonth), day) : computeIsoYearMonthFieldsForMonthDay(monthCodeNumber, Boolean(isLeapMonth));
+  isLeapMonth && ((calendar && calendar.U?.[monthCodeNumber]) ?? 1 / 0) < fields.day && (1 === overflow && throwRangeError(invalidLeapMonth), 
+  isLeapMonth = 0, day = constrainToRange(fields.day, 1, (calendar && calendar.R) ?? 1 / 0));
+  let res = calendar ? calendar.u(monthCodeNumber, Boolean(isLeapMonth), day) : computeIsoYearMonthFieldsForMonthDay(monthCodeNumber, Boolean(isLeapMonth));
   for (;!res && 0 === overflow && day > 1; ) {
-    day--, res = calendar ? calendar.v(monthCodeNumber, Boolean(isLeapMonth), day) : computeIsoYearMonthFieldsForMonthDay(monthCodeNumber, Boolean(isLeapMonth));
+    day--, res = calendar ? calendar.u(monthCodeNumber, Boolean(isLeapMonth), day) : computeIsoYearMonthFieldsForMonthDay(monthCodeNumber, Boolean(isLeapMonth));
   }
   res || throwRangeError("Cannot guess year");
   const {year: finalYear, month: finalMonth} = res;
@@ -4620,7 +4990,7 @@ function formatInstantIso(refineTimeZoneString, instantSlots, options) {
   const providedTimeZone = void 0 !== timeZoneArg;
   return ((providedTimeZone, timeZone, epochNano, roundingMode, nanoInc, subsecDigits) => {
     epochNano = roundBigNanoToDayOriginInc(epochNano, BigInt(nanoInc), roundingMode);
-    const offsetNano = timeZone.C(epochNano);
+    const offsetNano = timeZone.B(epochNano);
     return formatIsoDateTimeFields(epochNanoToIsoDateTime(epochNano + BigInt(offsetNano)), subsecDigits) + (providedTimeZone ? formatOffsetNano(roundToMinute(offsetNano)) : "Z");
   })(providedTimeZone, queryTimeZone(providedTimeZone ? refineTimeZoneString(timeZoneArg) : "UTC"), instantSlots.epochNanoseconds, roundingMode, nanoInc, subsecDigits);
 }
@@ -4637,7 +5007,7 @@ function formatZonedDateTimeIso(zonedDateTimeSlots0, options) {
   })(options);
   return ((calendar, timeZoneId, timeZone, epochNano, calendarDisplay, timeZoneDisplay, offsetDisplay, roundingMode, nanoInc, subsecDigits) => {
     epochNano = roundBigNanoToDayOriginInc(epochNano, BigInt(nanoInc), roundingMode);
-    const offsetNano = timeZone.C(epochNano);
+    const offsetNano = timeZone.B(epochNano);
     return formatIsoDateTimeFields(epochNanoToIsoDateTime(epochNano + BigInt(offsetNano)), subsecDigits) + formatOffsetNano(roundToMinute(offsetNano), offsetDisplay) + formatTimeZone(timeZoneId, timeZoneDisplay) + formatCalendar(calendar, calendarDisplay);
   })(zonedDateTimeSlots0.calendar, zonedDateTimeSlots0.timeZone.id, zonedDateTimeSlots0.timeZone, zonedDateTimeSlots0.epochNanoseconds, ...displayOptions);
 }
@@ -4793,8 +5163,8 @@ function resolveTimeZoneRecord(rawId) {
     if (void 0 !== offsetNano) {
       return {
         id: formatOffsetNano(offsetNano),
-        _: offsetNano,
-        o: offsetNano
+        X: offsetNano,
+        m: offsetNano
       };
     }
   })(upperRawId);
@@ -4814,7 +5184,7 @@ const queryNamedTimeZoneRecord = /*@__PURE__*/ memoize(normId => {
     return {
       kind: "utc",
       id: normId,
-      o: normId
+      m: normId
     };
   }
   const upperNormId = normId.toUpperCase();
@@ -4823,7 +5193,7 @@ const queryNamedTimeZoneRecord = /*@__PURE__*/ memoize(normId => {
     kind: "named",
     id: normId,
     format: format,
-    o: format.resolvedOptions().timeZone
+    m: format.resolvedOptions().timeZone
   };
 });
 
@@ -4844,24 +5214,24 @@ function queryTimeZone(rawTimeZoneId) {
   return queryTimeZoneRecord(record.id, record);
 }
 
-const queryTimeZoneRecord = /*@__PURE__*/ memoize((normTimeZoneId, record) => "named" === record.kind ? new IntlTimeZone(normTimeZoneId, record.o, record.format) : new FixedTimeZone(normTimeZoneId, record.o, "fixed" === record.kind ? record._ : 0));
+const queryTimeZoneRecord = /*@__PURE__*/ memoize((normTimeZoneId, record) => "named" === record.kind ? new IntlTimeZone(normTimeZoneId, record.m, record.format) : new FixedTimeZone(normTimeZoneId, record.m, "fixed" === record.kind ? record.X : 0));
 
 class FixedTimeZone {
   constructor(id, compareKey, offsetNano) {
-    this.id = id, this.o = compareKey, this._ = offsetNano;
+    this.id = id, this.m = compareKey, this.X = offsetNano;
   }
-  C() {
-    return this._;
+  B() {
+    return this.X;
   }
-  R(isoDateTime) {
-    return [ isoDateTimeAndOffsetToEpochNano(isoDateTime, this._) ];
+  N(isoDateTime) {
+    return [ isoDateTimeAndOffsetToEpochNano(isoDateTime, this.X) ];
   }
-  U() {}
+  O() {}
 }
 
 class IntlTimeZone {
   constructor(id, compareKey, format) {
-    this.id = id, this.o = compareKey, this.qe = ((computeOffsetSec, periodDays) => {
+    this.id = id, this.m = compareKey, this.ke = ((computeOffsetSec, periodDays) => {
       const getSample = memoize(computeOffsetSec);
       const getSplit = memoize(createSplitTuple);
       const periodSec = 86400 * periodDays;
@@ -4883,7 +5253,7 @@ class IntlTimeZone {
         return offsetSec;
       }
       return {
-        Ee(zonedEpochSec) {
+        xe(zonedEpochSec) {
           const wideOffsetSec0 = getOffsetSec(zonedEpochSec - 86400);
           const wideOffsetSec1 = getOffsetSec(zonedEpochSec + 86400);
           const wideUtcEpochSec0 = zonedEpochSec - wideOffsetSec0;
@@ -4894,8 +5264,8 @@ class IntlTimeZone {
           const narrowOffsetSec0 = getOffsetSec(wideUtcEpochSec0);
           return narrowOffsetSec0 === getOffsetSec(wideUtcEpochSec1) ? [ zonedEpochSec - narrowOffsetSec0 ] : wideOffsetSec0 > wideOffsetSec1 ? [ wideUtcEpochSec0, wideUtcEpochSec1 ] : [];
         },
-        De: getOffsetSec,
-        U: function getTransition(epochSec, direction) {
+        we: getOffsetSec,
+        O: function getTransition(epochSec, direction) {
           if (direction > 0 && epochSec >= 864e10) {
             return;
           }
@@ -4945,17 +5315,17 @@ class IntlTimeZone {
       return timeZonePeriodDaysByName[timeZoneName] || 60;
     })(id));
   }
-  C(epochNano) {
-    return this.qe.De((epochNano => epochNanoToSecMod(epochNano)[0])(epochNano)) * nanoInSec;
+  B(epochNano) {
+    return this.ke.we((epochNano => epochNanoToSecMod(epochNano)[0])(epochNano)) * nanoInSec;
   }
-  R(isoDateTime) {
+  N(isoDateTime) {
     const zonedEpochSec = 86400 * isoDateToEpochDays(isoDateTime) + timeFieldsToSec(isoDateTime);
     const subsecNano = timeFieldsToSubsecNano(isoDateTime);
-    return this.qe.Ee(zonedEpochSec).map(epochSec => checkEpochNanoInBounds(BigInt(epochSec) * bigNanoInSec + BigInt(subsecNano)));
+    return this.ke.xe(zonedEpochSec).map(epochSec => checkEpochNanoInBounds(BigInt(epochSec) * bigNanoInSec + BigInt(subsecNano)));
   }
-  U(epochNano, direction) {
+  O(epochNano, direction) {
     const [epochSec, subsecNano] = epochNanoToSecMod(epochNano);
-    const resEpochSec = this.qe.U(epochSec + (direction > 0 || subsecNano ? 1 : 0), direction);
+    const resEpochSec = this.ke.O(epochSec + (direction > 0 || subsecNano ? 1 : 0), direction);
     if (void 0 !== resEpochSec) {
       return BigInt(resEpochSec) * bigNanoInSec;
     }
@@ -5042,14 +5412,14 @@ function throwFailedParse(s) {
 function parseInstant(s) {
   const organized = parseDateTimeLike(s = toStringViaPrimitive(s));
   let offsetNano;
-  return organized || throwFailedParse(s), organized.F ? offsetNano = 0 : organized.offset ? offsetNano = parseOffsetNano(organized.offset) : throwFailedParse(s), 
+  return organized || throwFailedParse(s), organized.C ? offsetNano = 0 : organized.offset ? offsetNano = parseOffsetNano(organized.offset) : throwFailedParse(s), 
   organized.timeZoneId && parseOffsetNanoMaybe(organized.timeZoneId, 1), validateIsoDateTimeFields(organized), 
   createEpochNanoSlots(isoDateTimeAndOffsetToEpochNano(organized, offsetNano));
 }
 
 function parseRelativeToSlots(s, resolveCalendar) {
   const organized = parseDateTimeLike(requireString(s));
-  return organized || throwFailedParse(s), organized.timeZoneId ? finalizeZonedDateTime(organized, resolveCalendar, void 0) : (organized.F && throwFailedParse(s), 
+  return organized || throwFailedParse(s), organized.timeZoneId ? finalizeZonedDateTime(organized, resolveCalendar, void 0) : (organized.C && throwFailedParse(s), 
   finalizeDate(organized, resolveCalendar));
 }
 
@@ -5060,7 +5430,7 @@ function parseZonedDateTime(s, resolveCalendar, options) {
 
 function parsePlainDateTime(s, resolveCalendar) {
   const organized = parseDateTimeLike(requireString(s));
-  return organized && !organized.F || throwFailedParse(s), finalizeDateTime(organized, resolveCalendar);
+  return organized && !organized.C || throwFailedParse(s), finalizeDateTime(organized, resolveCalendar);
 }
 
 function parsePlainDate(s, resolveCalendar) {
@@ -5092,7 +5462,7 @@ function parsePlainMonthDay(s, resolveCalendar) {
   const {year: origYear, month: origMonth, day: day} = computeCalendarDateFields(calendar, dateSlots);
   const [monthCodeNumber, isLeapMonth] = computeCalendarMonthCodeParts(calendar, origYear, origMonth);
   const {year: year, month: month} = ((calendar, monthCodeNumber, isLeapMonth, day) => {
-    const yearMonthFields = calendar ? calendar.v(monthCodeNumber, isLeapMonth, day) : computeIsoYearMonthFieldsForMonthDay(monthCodeNumber, isLeapMonth);
+    const yearMonthFields = calendar ? calendar.u(monthCodeNumber, isLeapMonth, day) : computeIsoYearMonthFieldsForMonthDay(monthCodeNumber, isLeapMonth);
     return yearMonthFields || throwRangeError("Cannot guess year"), yearMonthFields;
   })(calendar, monthCodeNumber, isLeapMonth, day);
   return createDateSlots(checkIsoDateInBounds(computeCalendarIsoFieldsFromParts(calendar, year, month, day)), calendar);
@@ -5103,47 +5473,47 @@ function parsePlainTime(s) {
     const parts = parseTimeOnlyParts(s);
     return parts ? (organizeAnnotationParts(parts[13]), organizeTimeParts(parts, 1)) : void 0;
   })(s = requireString(s));
+  if (!organized) {
+    const dateTime = parseDateTimeLike(s);
+    dateTime && dateTime.re || throwFailedParse(s), dateTime.C && throwRangeError(invalidSubstring("Z")), 
+    requireIsoCalendar(dateTime), organized = dateTime;
+  }
   let altParsed;
-  return organized || (organized = parseDateTimeLike(s), organized ? (organized.fe || throwFailedParse(s), 
-  organized.F && throwRangeError(invalidSubstring("Z")), requireIsoCalendar(organized)) : throwFailedParse(s)), 
-  (altParsed = parseYearMonthOnly(s)) && isIsoDateFieldsValid(altParsed) && throwFailedParse(s), 
+  return (altParsed = parseYearMonthOnly(s)) && isIsoDateFieldsValid(altParsed) && throwFailedParse(s), 
   (altParsed = parseMonthDayOnly(s)) && isIsoDateFieldsValid(altParsed) && throwFailedParse(s), 
   createTimeSlots(validateTimeFields(organized));
 }
 
 function parseDuration(s) {
-  const parsed = (s => {
-    const parts = durationRegExp.exec(s);
-    return parts ? (parts => {
-      let hasAny = 0;
-      let hasAnyFrac = 0;
-      let leftoverNano = 0;
-      let durationFields = {
-        years: parseUnit(parts[2]),
-        months: parseUnit(parts[3]),
-        weeks: parseUnit(parts[4]),
-        days: parseUnit(parts[5]),
-        hours: parseUnit(parts[6], parts[7], 5),
-        minutes: parseUnit(parts[8], parts[9], 4),
-        seconds: parseUnit(parts[10], parts[11], 3),
-        ...nanoToGivenFields(leftoverNano, 2, durationFieldNamesAsc)
-      };
-      return hasAny || throwRangeError(noValidFields(durationFieldNamesAsc)), parseSign(parts[1]) < 0 && (durationFields = negateDurationFields(durationFields)), 
-      durationFields;
-      function parseUnit(wholeStr, fracStr, timeUnit) {
-        let leftoverUnits = 0;
-        let wholeUnits = 0;
-        return timeUnit && ([leftoverUnits, leftoverNano] = divModFloor(leftoverNano, unitNanoMap[timeUnit])), 
-        void 0 !== wholeStr && (hasAnyFrac && throwRangeError(invalidSubstring(wholeStr)), 
-        wholeUnits = (s => {
-          const n = parseInt(s);
-          return Number.isFinite(n) || throwRangeError(invalidSubstring(s)), n;
-        })(wholeStr), hasAny = 1, fracStr && (leftoverNano = parseSubsecNano(fracStr) * (unitNanoMap[timeUnit] / nanoInSec), 
-        hasAnyFrac = 1)), leftoverUnits + wholeUnits;
-      }
-    })(parts) : void 0;
-  })(requireString(s));
-  return parsed || throwFailedParse(s), createDurationSlots(validateDurationFields(parsed));
+  const parts = durationRegExp.exec(requireString(s));
+  return parts || throwFailedParse(s), createDurationSlots(validateDurationFields((parts => {
+    let hasAny = 0;
+    let hasAnyFrac = 0;
+    let leftoverNano = 0;
+    let durationFields = {
+      years: parseUnit(parts[2]),
+      months: parseUnit(parts[3]),
+      weeks: parseUnit(parts[4]),
+      days: parseUnit(parts[5]),
+      hours: parseUnit(parts[6], parts[7], 5),
+      minutes: parseUnit(parts[8], parts[9], 4),
+      seconds: parseUnit(parts[10], parts[11], 3),
+      ...nanoToGivenFields(leftoverNano, 2, durationFieldNamesAsc)
+    };
+    return hasAny || throwRangeError(noValidFields(durationFieldNamesAsc)), parseSign(parts[1]) < 0 && (durationFields = negateDurationFields(durationFields)), 
+    durationFields;
+    function parseUnit(wholeStr, fracStr, timeUnit) {
+      let leftoverUnits = 0;
+      let wholeUnits = 0;
+      return timeUnit && ([leftoverUnits, leftoverNano] = divModFloor(leftoverNano, unitNanoMap[timeUnit])), 
+      void 0 !== wholeStr && (hasAnyFrac && throwRangeError(invalidSubstring(wholeStr)), 
+      wholeUnits = (s => {
+        const n = parseInt(s);
+        return Number.isFinite(n) || throwRangeError(invalidSubstring(s)), n;
+      })(wholeStr), hasAny = 1, fracStr && (leftoverNano = parseSubsecNano(fracStr) * (unitNanoMap[timeUnit] / nanoInSec), 
+      hasAnyFrac = 1)), leftoverUnits + wholeUnits;
+    }
+  })(parts)));
 }
 
 function parseCalendarId(s) {
@@ -5157,17 +5527,17 @@ function parseCalendarId(s) {
 
 function parseTimeZoneId(s) {
   const parsed = parseDateTimeLike(s);
-  return parsed && (parsed.timeZoneId || parsed.F && "UTC" || parsed.offset) || s;
+  return parsed && (parsed.timeZoneId || parsed.C && "UTC" || parsed.offset) || s;
 }
 
 function parsePlainDateLike(s) {
   const organized = parseDateTimeLike(s);
-  return organized && !organized.F || throwFailedParse(s), organized;
+  return organized && !organized.C || throwFailedParse(s), organized;
 }
 
 function finalizeDateLike(organized, isoDateProjector, resolveCalendar) {
   return isoDateProjector && "iso8601" === organized.calendarId ? (validateIsoDateFields(organized), 
-  organized.fe && validateTimeFields(organized), finalizeDate(isoDateProjector(organized), resolveCalendar)) : organized.fe ? finalizeDateTime(organized, resolveCalendar) : finalizeDate(organized, resolveCalendar);
+  organized.re && validateTimeFields(organized), finalizeDate(isoDateProjector(organized), resolveCalendar)) : organized.re ? finalizeDateTime(organized, resolveCalendar) : finalizeDate(organized, resolveCalendar);
 }
 
 function projectIsoYearMonthDate(organized) {
@@ -5188,11 +5558,11 @@ function projectIsoMonthDayDate(organized) {
 function finalizeZonedDateTime(organized, resolveCalendar, options) {
   const timeZone = queryTimeZone(resolveTimeZoneId(organized.timeZoneId));
   let epochNano;
-  if (validateIsoDateTimeFields(organized), organized.fe) {
+  if (validateIsoDateTimeFields(organized), organized.re) {
     const offsetNano = organized.offset ? parseOffsetNano(organized.offset) : void 0;
     const [, offsetDisambig, epochDisambig] = refineZonedFieldOptions(options);
-    epochNano = getMatchingInstantFor(timeZone, organized, offsetNano, offsetDisambig, epochDisambig, !(timeZone._ || void 0 === organized.offset || (offset = organized.offset, 
-    offset.replace(/\D/g, "").length > 4)), organized.F);
+    epochNano = getMatchingInstantFor(timeZone, organized, offsetNano, offsetDisambig, epochDisambig, !(timeZone.X || void 0 === organized.offset || (offset = organized.offset, 
+    offset.replace(/\D/g, "").length > 4)), organized.C);
   } else {
     refineZonedFieldOptions(options), epochNano = getStartOfDayInstantFor(timeZone, organized);
   }
@@ -5221,11 +5591,7 @@ function timeRegExpStr(separatorIndex) {
   return `(\\d{2})(?:(:?)(\\d{2})(?:\\${separatorIndex}(\\d{2})(?:[.,](\\d{1,9}))?)?)?`;
 }
 
-function offsetRegExpStr(separatorIndex) {
-  return "([+-])" + timeRegExpStr(separatorIndex);
-}
-
-const dateTimeRegExpStr = "(?:(?:([+-])(\\d{6}))|(\\d{4}))(-?)(\\d{2})\\4(\\d{2})(?:[T ]" + timeRegExpStr(8) + "(Z|" + offsetRegExpStr(15) + ")?)?";
+const dateTimeRegExpStr = "(?:(?:([+-])(\\d{6}))|(\\d{4}))(-?)(\\d{2})\\4(\\d{2})(?:[T ]" + timeRegExpStr(8) + "(Z|([+-])" + timeRegExpStr(15) + ")?)?";
 
 const yearMonthRegExp = /*@__PURE__*/ createRegExp("(?:(?:([+-])(\\d{6}))|(\\d{4}))-?(\\d{2})((?:\\[(!?)([^\\]]*)\\]){0,9})");
 
@@ -5233,11 +5599,11 @@ const monthDayRegExp = /*@__PURE__*/ createRegExp("(?:--)?(\\d{2})-?(\\d{2})((?:
 
 const dateTimeRegExp = /*@__PURE__*/ createRegExp(dateTimeRegExpStr + "((?:\\[(!?)([^\\]]*)\\]){0,9})");
 
-const timeRegExp = /*@__PURE__*/ createRegExp("T?" + timeRegExpStr(2) + `(${offsetRegExpStr(9)})?((?:\\[(!?)([^\\]]*)\\]){0,9})`);
+const timeRegExp = /*@__PURE__*/ createRegExp("T?" + timeRegExpStr(2) + `(([+-])${timeRegExpStr(9)})?((?:\\[(!?)([^\\]]*)\\]){0,9})`);
 
 const annotationRegExp = /*@__PURE__*/ new RegExp("\\[(!?)([^\\]]*)\\]", "g");
 
-const durationRegExp = /*@__PURE__*/ createRegExp("([+-])?P(\\d+Y)?(\\d+M)?(\\d+W)?(\\d+D)?(?:T(?:(\\d+)(?:[.,](\\d{1,9}))?H)?(?:(\\d+)(?:[.,](\\d{1,9}))?M)?(?:(\\d+)(?:[.,](\\d{1,9}))?S)?)?");
+const durationRegExp = /*@__PURE__*/ createRegExp("([+-])?P(\\d+Y)?(\\d+M)?(\\d+W)?(\\d+D)?(?:T(?!$)(?:(\\d+)(?:[.,](\\d{1,9}))?H)?(?:(\\d+)(?:[.,](\\d{1,9}))?M)?(?:(\\d+)(?:[.,](\\d{1,9}))?S)?)?");
 
 function parseDateTimeLike(s) {
   const parts = dateTimeRegExp.exec(s);
@@ -5250,8 +5616,8 @@ function parseDateTimeLike(s) {
       day: parseInt(parts[6]),
       ...organizeTimeParts(parts, 7),
       ...organizeAnnotationParts(parts[19]),
-      fe: Boolean(parts[7]),
-      F: hasZ,
+      re: Boolean(parts[7]),
+      C: hasZ,
       offset: hasZ ? void 0 : zOrOffset
     };
   })(parts) : void 0;
@@ -5321,7 +5687,7 @@ function organizeAnnotationParts(s) {
 function mergeCalendarFields(calendar, baseFields, additionalFields) {
   const merged = Object.assign(Object.create(null), baseFields);
   return spliceFields(merged, additionalFields, monthFieldNames), getCalendarEraOrigins(calendar) && (spliceFields(merged, additionalFields, allYearFieldNames), 
-  calendar && calendar.le && spliceFields(merged, additionalFields, monthDayFieldNames, eraYearFieldNames)), 
+  calendar && calendar.ge && spliceFields(merged, additionalFields, monthDayFieldNames, eraYearFieldNames)), 
   merged;
 }
 
@@ -5462,10 +5828,7 @@ function zonedDateTimeToPlainTime(zonedDateTimeSlots0) {
 }
 
 function plainDateTimeToZonedDateTime(plainDateTimeSlots, timeZone, options) {
-  const epochNano = ((timeZone, isoDateTime, options) => {
-    const epochDisambig = (options => coerceEpochDisambig(normalizeOptions(options)))(options);
-    return getSingleInstantFor(timeZone, isoDateTime, epochDisambig);
-  })(timeZone, plainDateTimeSlots, options);
+  const epochNano = getSingleInstantFor(timeZone, plainDateTimeSlots, (options => coerceEpochDisambig(normalizeOptions(options)))(options));
   return createZonedEpochNanoSlots(checkEpochNanoInBounds(epochNano), timeZone, plainDateTimeSlots.calendar);
 }
 
@@ -5531,36 +5894,30 @@ function createOptionsTransformer(shapeFieldNames, invalidShapeFieldNames, ignor
   const invalidShapeFieldNameSet = new Set(invalidShapeFieldNames);
   const ignoredFieldNameSet = new Set(ignoredFieldNames);
   return (options, allowPartialOverlap) => {
-    const analysis = ((options, shapeFieldNameSet, invalidShapeFieldNameSet, ignoredFieldNameSet) => {
-      const analysis = {
-        dateStyle: void 0,
-        timeStyle: void 0,
-        me: {},
-        pe: {},
-        xe: {},
-        oe: 0,
-        ue: 0
-      };
-      for (const name of Object.keys(options)) {
-        const value = options[name];
-        void 0 === value || ignoredFieldNameSet.has(name) || (shapeFieldNameSet.has(name) ? "dateStyle" === name ? analysis.dateStyle = value : "timeStyle" === name ? analysis.timeStyle = value : analysis.me[name] = value : "era" === name ? analysis.pe[name] = value : invalidShapeFieldNameSet.has(name) ? "dateStyle" === name || "timeStyle" === name ? analysis.ue = 1 : analysis.oe = 1 : analysis.xe[name] = value);
-      }
-      return analysis;
-    })(options, shapeFieldNameSet, invalidShapeFieldNameSet, ignoredFieldNameSet);
-    const hasDateStyle = void 0 !== analysis.dateStyle;
-    const hasTimeStyle = void 0 !== analysis.timeStyle;
+    let dateStyle;
+    let timeStyle;
+    const granularShapeFields = {};
+    const modifierFields = {};
+    const otherFields = {};
+    let hasInvalidGranularShapeFields = 0;
+    let hasInvalidStyleFields = 0;
+    for (const name of Object.keys(options)) {
+      const value = options[name];
+      void 0 === value || ignoredFieldNameSet.has(name) || (shapeFieldNameSet.has(name) ? "dateStyle" === name ? dateStyle = value : "timeStyle" === name ? timeStyle = value : granularShapeFields[name] = value : "era" === name ? modifierFields[name] = value : invalidShapeFieldNameSet.has(name) ? "dateStyle" === name || "timeStyle" === name ? hasInvalidStyleFields = 1 : hasInvalidGranularShapeFields = 1 : otherFields[name] = value);
+    }
+    const hasDateStyle = void 0 !== dateStyle;
+    const hasTimeStyle = void 0 !== timeStyle;
     const hasAnyStyle = hasDateStyle || hasTimeStyle;
-    const hasGranularShapeFields = Object.keys(analysis.me).length > 0;
-    const hasInvalids = analysis.oe || analysis.ue;
+    const hasGranularShapeFields = Object.keys(granularShapeFields).length > 0;
+    const hasInvalids = hasInvalidGranularShapeFields || hasInvalidStyleFields;
     const hasShapeFields = hasGranularShapeFields || hasDateStyle || hasTimeStyle;
-    const hasModifierFields = Object.keys(analysis.pe).length > 0;
-    const hasStyleConflictFields = hasGranularShapeFields || hasModifierFields || analysis.oe;
-    (!allowPartialOverlap && hasInvalids || allowPartialOverlap && hasInvalids && !hasShapeFields || hasAnyStyle && hasStyleConflictFields) && throwTypeError("Invalid formatting options");
+    const hasModifierFields = Object.keys(modifierFields).length > 0;
+    (!allowPartialOverlap && hasInvalids || allowPartialOverlap && hasInvalids && !hasShapeFields || hasAnyStyle && (hasGranularShapeFields || hasModifierFields || hasInvalidGranularShapeFields)) && throwTypeError("Invalid formatting options");
     const transformedOptions = {};
     return hasAnyStyle || hasShapeFields || Object.assign(transformedOptions, defaultShapeFields), 
-    Object.assign(transformedOptions, analysis.me, analysis.pe, analysis.xe), 
-    hasDateStyle && (dateStyleReplacementFields ? Object.assign(transformedOptions, dateStyleReplacementFields[analysis.dateStyle]) : transformedOptions.dateStyle = analysis.dateStyle), 
-    hasTimeStyle && (transformedOptions.timeStyle = analysis.timeStyle), transformedOptions;
+    Object.assign(transformedOptions, granularShapeFields, modifierFields, otherFields), 
+    hasDateStyle && (dateStyleReplacementFields ? Object.assign(transformedOptions, dateStyleReplacementFields[dateStyle]) : transformedOptions.dateStyle = dateStyle), 
+    hasTimeStyle && (transformedOptions.timeStyle = timeStyle), transformedOptions;
   };
 }
 
@@ -5578,20 +5935,6 @@ const timeDefaultShapeFields = {
 
 const dateTimeDefaultShapeFields = /*@__PURE__*/ Object.assign({}, dateDefaultShapeFields, timeDefaultShapeFields);
 
-const zonedDateTimeDefaultShapeFields = /*@__PURE__*/ Object.assign({}, dateTimeDefaultShapeFields, {
-  timeZoneName: "short"
-});
-
-const yearMonthDefaultShapeFields = {
-  year: "numeric",
-  month: "numeric"
-};
-
-const monthDayDefaultShapeFields = {
-  month: "numeric",
-  day: "numeric"
-};
-
 const dateShapeFieldNames = [ "weekday", "year", "month", "day", "dateStyle" ];
 
 const timeShapeFieldNames = [ "dayPeriod", "hour", "minute", "second", "fractionalSecondDigits", "timeStyle" ];
@@ -5604,7 +5947,10 @@ const monthDayIgnoredFieldNames = /*@__PURE__*/ [ "weekday", "year" ].concat(tim
 
 const transformInstantOptions = /*@__PURE__*/ createOptionsTransformer(dateTimeShapeFieldNames, [], [], dateTimeDefaultShapeFields);
 
-const transformZonedOptions = /*@__PURE__*/ createOptionsTransformer(dateTimeShapeFieldNames, [], [], zonedDateTimeDefaultShapeFields);
+const transformZonedOptions = /*@__PURE__*/ createOptionsTransformer(dateTimeShapeFieldNames, [], [], {
+  ...dateTimeDefaultShapeFields,
+  timeZoneName: "short"
+});
 
 const transformDateTimeOptions = /*@__PURE__*/ createOptionsTransformer(dateTimeShapeFieldNames, [], [ "timeZoneName" ], dateTimeDefaultShapeFields);
 
@@ -5612,7 +5958,10 @@ const transformDateOptions = /*@__PURE__*/ createOptionsTransformer(dateShapeFie
 
 const transformTimeOptions = /*@__PURE__*/ createOptionsTransformer(timeShapeFieldNames, dateShapeFieldNames, [ "timeZoneName", "era" ], timeDefaultShapeFields);
 
-const transformYearMonthOptions = /*@__PURE__*/ createOptionsTransformer([ "year", "month", "dateStyle" ], yearMonthIgnoredFieldNames, [ "timeZoneName" ], yearMonthDefaultShapeFields, {
+const transformYearMonthOptions = /*@__PURE__*/ createOptionsTransformer([ "year", "month", "dateStyle" ], yearMonthIgnoredFieldNames, [ "timeZoneName" ], {
+  year: "numeric",
+  month: "numeric"
+}, {
   full: {
     year: "numeric",
     month: "long"
@@ -5631,7 +5980,10 @@ const transformYearMonthOptions = /*@__PURE__*/ createOptionsTransformer([ "year
   }
 });
 
-const transformMonthDayOptions = /*@__PURE__*/ createOptionsTransformer([ "month", "day", "dateStyle" ], monthDayIgnoredFieldNames, [ "timeZoneName", "era" ], monthDayDefaultShapeFields, {
+const transformMonthDayOptions = /*@__PURE__*/ createOptionsTransformer([ "month", "day", "dateStyle" ], monthDayIgnoredFieldNames, [ "timeZoneName", "era" ], {
+  month: "numeric",
+  day: "numeric"
+}, {
   full: {
     month: "long",
     day: "numeric"
@@ -5662,7 +6014,7 @@ function zonedDateTimeWithPlainTime(zonedDateTimeSlots, plainTimeFields) {
 
 function getCurrentIsoDateTime(timeZone) {
   const epochNano = getCurrentEpochNano();
-  const offsetNano = timeZone.C(epochNano);
+  const offsetNano = timeZone.B(epochNano);
   return epochNanoToIsoDateTime(epochNano + BigInt(offsetNano));
 }
 
@@ -5683,29 +6035,36 @@ function createDateTimeFormatShell(createArgsProvider, transformOptions = identi
   class ShimDateTimeFormat {
     constructor(locales, options = Object.create(null)) {
       const transformedOptions = transformOptions(options);
-      const baseFormat = new RawDateTimeFormat(locales, transformedOptions);
+      const observedOptionNames = [];
+      const trackedOptions = new Proxy(Object.create(null), {
+        get(_target, name) {
+          const value = transformedOptions[name];
+          return void 0 !== value && observedOptionNames.push(name), value;
+        }
+      });
+      const baseFormat = new RawDateTimeFormat(locales, trackedOptions);
       const resolvedOptions = baseFormat.resolvedOptions();
-      const copiedOptions = pluckProps(Object.keys(options), resolvedOptions);
+      const copiedOptions = pluckProps(observedOptionNames, resolvedOptions);
       internalsMap.set(this, {
-        ee: createArgsProvider({
+        Z: createArgsProvider({
           t: baseFormat,
-          Ge: resolvedOptions.locale,
-          I: copiedOptions,
-          Je: transformedOptions
+          ze: resolvedOptions.locale,
+          F: copiedOptions,
+          Ce: transformedOptions
         }),
         t: baseFormat
       });
     }
     get format() {
       const internals = getInternals(this);
-      return internals.ze || (internals.ze = record => {
-        const [format, ...rest] = internals.ee.B(record);
+      return internals.qe || (internals.qe = record => {
+        const [format, ...rest] = internals.Z.A(record);
         return format.format(...rest);
       });
     }
     formatToParts(record) {
-      const {ee: argsProvider} = getInternals(this);
-      const [format, ...rest] = argsProvider.B(record);
+      const {Z: argsProvider} = getInternals(this);
+      const [format, ...rest] = argsProvider.A(record);
       return format.formatToParts(...rest);
     }
     resolvedOptions() {
@@ -5718,13 +6077,13 @@ function createDateTimeFormatShell(createArgsProvider, transformOptions = identi
   }
   RawDateTimeFormat.prototype.formatRange && Object.defineProperties(prototype, createPropDescriptors({
     formatRange(record0, record1) {
-      const {ee: argsProvider} = getInternals(this);
-      const [format, epochMilli0, epochMilli1] = argsProvider.A(record0, record1);
+      const {Z: argsProvider} = getInternals(this);
+      const [format, epochMilli0, epochMilli1] = argsProvider.v(record0, record1);
       return format.formatRange(epochMilli0, epochMilli1);
     },
     formatRangeToParts(record0, record1) {
-      const {ee: argsProvider} = getInternals(this);
-      const [format, epochMilli0, epochMilli1] = argsProvider.A(record0, record1);
+      const {Z: argsProvider} = getInternals(this);
+      const [format, epochMilli0, epochMilli1] = argsProvider.v(record0, record1);
       return format.formatRangeToParts(epochMilli0, epochMilli1);
     }
   }));
@@ -5753,20 +6112,13 @@ const InstantBranding = "Instant";
 const DurationBranding = "Duration";
 
 function defineTemporalClass(branding, cls, getSlots, ...getterMaps) {
-  Object.defineProperties(cls, createNameDescriptors(branding)), Object.defineProperties(cls.prototype, createStringTagDescriptors("Temporal." + branding));
-  for (const getterMap of getterMaps) {
-    defineSlotGetters(cls.prototype, getSlots, getterMap);
-  }
-  return cls;
-}
-
-function defineSlotGetters(destPrototype, getSlots, getterMap) {
-  Object.defineProperties(destPrototype, mapProps(getter => ({
+  return Object.defineProperties(cls, createNameDescriptors(branding)), Object.defineProperties(cls.prototype, createStringTagDescriptors("Temporal." + branding)), 
+  Object.defineProperties(cls.prototype, mapProps(getter => ({
     get() {
       return getter(getSlots(this));
     },
     configurable: 1
-  }), getterMap));
+  }), Object.assign({}, ...getterMaps))), cls;
 }
 
 const attachDebugString = "noop" === noop.name ? instance => {
@@ -5884,40 +6236,40 @@ createNativeGetters(yearMonthDerivedGetters), createNativeGetters(dateDerivedGet
 
 function createDateTimeFormatClass(getTemporalBrandingAndSlots) {
   return createDateTimeFormatShell(internals => {
-    const getTemporalFormat = memoize(branding => ((internals, branding) => {
+    const getTemporalFormat = memoize(branding => {
       let options;
       switch (branding) {
        case InstantBranding:
-        options = transformInstantOptions(internals.I, 1);
+        options = transformInstantOptions(internals.F, 1);
         break;
 
        case PlainDateTimeBranding:
-        options = applyPlainFormatTimeZone(transformDateTimeOptions(internals.I, 1));
+        options = applyPlainFormatTimeZone(transformDateTimeOptions(internals.F, 1));
         break;
 
        case PlainDateBranding:
-        options = applyPlainFormatTimeZone(transformDateOptions(internals.I, 1));
+        options = applyPlainFormatTimeZone(transformDateOptions(internals.F, 1));
         break;
 
        case PlainTimeBranding:
-        options = applyPlainFormatTimeZone(transformTimeOptions(internals.I, 1));
+        options = applyPlainFormatTimeZone(transformTimeOptions(internals.F, 1));
         break;
 
        case PlainYearMonthBranding:
-        options = applyPlainFormatTimeZone(transformYearMonthOptions(internals.I, 1));
+        options = applyPlainFormatTimeZone(transformYearMonthOptions(internals.F, 1));
         break;
 
        case PlainMonthDayBranding:
-        options = applyPlainFormatTimeZone(transformMonthDayOptions(internals.I, 1));
+        options = applyPlainFormatTimeZone(transformMonthDayOptions(internals.F, 1));
         break;
 
        default:
         throwTypeError(invalidFormatType(branding));
       }
-      return new RawDateTimeFormat(internals.Ge, options);
-    })(internals, branding));
+      return new RawDateTimeFormat(internals.ze, options);
+    });
     return {
-      B(formattable) {
+      A(formattable) {
         if (void 0 === formattable) {
           return [ internals.t ];
         }
@@ -5929,7 +6281,7 @@ function createDateTimeFormatClass(getTemporalBrandingAndSlots) {
         const format = getTemporalFormat(branding);
         return checkTemporalDateTimeFormatCompatible(format, branding, slots), [ format, temporalDateTimeToEpochMilli(branding, slots) ];
       },
-      A(start, end) {
+      v(start, end) {
         void 0 !== start && void 0 !== end || throwTypeError(mismatchingFormatTypes);
         const startBrandingAndSlots = getTemporalBrandingAndSlots(start);
         const startEpochMilli = startBrandingAndSlots ? void 0 : Number(start);
@@ -6012,7 +6364,7 @@ const ZonedDateTime = /*@__PURE__*/ defineTemporalClass(ZonedDateTimeBranding, c
     return createZonedDateTime(toZonedDateTimeSlots(arg, options));
   }
   static compare(arg0, arg1) {
-    return compareZonedDateTimes(toZonedDateTimeSlots(arg0), toZonedDateTimeSlots(arg1));
+    return compareZonedEpochSlots(toZonedDateTimeSlots(arg0), toZonedDateTimeSlots(arg1));
   }
   get calendarId() {
     return getCalendarSlotId(getZonedDateTimeSlots(this).calendar);
@@ -6182,7 +6534,7 @@ const Instant = /*@__PURE__*/ defineTemporalClass(InstantBranding, class {
     return createInstant(epochNanoToInstant(epochNano));
   }
   static compare(a, b) {
-    return compareInstants(toInstantSlots(a), toInstantSlots(b));
+    return compareZonedEpochSlots(toInstantSlots(a), toInstantSlots(b));
   }
   get epochMilliseconds() {
     return getEpochMilli(getInstantSlots(this));
@@ -8122,7 +8474,73 @@ class NOAACalculator {
     }
 }
 
-var citiesJson = ["Ashdod|IL|31.79213|34.64966|Asia/Jerusalem|27","Atlanta|US|33.749|-84.38798|America/New_York|336","Austin|US|30.26715|-97.74306|America/Chicago|165","Baghdad|IQ|33.34058|44.40088|Asia/Baghdad|41","Beer Sheva|IL|31.25181|34.7913|Asia/Jerusalem|285","Berlin|DE|52.52437|13.41053|Europe/Berlin|43","Baltimore|US|39.29038|-76.61219|America/New_York|35","Bogota|CO|4.60971|-74.08175|America/Bogota|2582","Boston|US|42.35843|-71.05977|America/New_York|38","Budapest|HU|47.49801|19.03991|Europe/Budapest|104","Buenos Aires|AR|-34.61315|-58.37723|America/Argentina/Buenos_Aires|31","Buffalo|US|42.88645|-78.87837|America/New_York|191","Chicago|US|41.85003|-87.65005|America/Chicago|180","Cincinnati|US|39.162|-84.45689|America/New_York|267","Cleveland|US|41.4995|-81.69541|America/New_York|204","Dallas|US|32.78306|-96.80667|America/Chicago|139","Denver|US|39.73915|-104.9847|America/Denver|1636","Detroit|US|42.33143|-83.04575|America/Detroit|192","Eilat|IL|29.55805|34.94821|Asia/Jerusalem|63","Gibraltar|GI|36.14474|-5.35257|Europe/Gibraltar|11","Haifa|IL|32.81841|34.9885|Asia/Jerusalem|40","Hawaii|US|21.30694|-157.85833|Pacific/Honolulu|18","Helsinki|FI|60.16952|24.93545|Europe/Helsinki|26","Houston|US|29.76328|-95.36327|America/Chicago|30","Jerusalem|IL|31.76904|35.21633|Asia/Jerusalem|786","Johannesburg|ZA|-26.20227|28.04363|Africa/Johannesburg|1767","Kiev|UA|50.45466|30.5238|Europe/Kiev|187","La Paz|BO|-16.5|-68.15|America/La_Paz|3782","Livingston|US|40.79593|-74.31487|America/New_York|98","Las Vegas|US|36.17497|-115.13722|America/Los_Angeles|613","London|GB|51.50853|-0.12574|Europe/London|25","Los Angeles|US|34.05223|-118.24368|America/Los_Angeles|96","Marseilles|FR|43.29695|5.38107|Europe/Paris|28","Miami|US|25.77427|-80.19366|America/New_York|25","Minneapolis|US|44.97997|-93.26384|America/Chicago|262","Melbourne|AU|-37.814|144.96332|Australia/Melbourne|25","Mexico City|MX|19.42847|-99.12766|America/Mexico_City|2240","Montreal|CA|45.50884|-73.58781|America/Toronto|216","Moscow|RU|55.75222|37.61556|Europe/Moscow|144","New York|US|40.71427|-74.00597|America/New_York|57","Omaha|US|41.25861|-95.93779|America/Chicago|315","Ottawa|CA|45.41117|-75.69812|America/Toronto|71","Panama City|PA|8.9936|-79.51973|America/Panama|17","Paris|FR|48.85341|2.3488|Europe/Paris|42","Pawtucket|US|41.87871|-71.38256|America/New_York|0","Petach Tikvah|IL|32.08707|34.88747|Asia/Jerusalem|54","Philadelphia|US|39.95233|-75.16379|America/New_York|8","Phoenix|US|33.44838|-112.07404|America/Phoenix|366","Pittsburgh|US|40.44062|-79.99589|America/New_York|239","Providence|US|41.82399|-71.41283|America/New_York|0","Portland|US|45.52345|-122.67621|America/Los_Angeles|15","Saint Louis|US|38.62727|-90.19789|America/Chicago|149","Saint Petersburg|RU|59.93863|30.31413|Europe/Moscow|11","San Diego|US|32.71533|-117.15726|America/Los_Angeles|20","San Francisco|US|37.77493|-122.41942|America/Los_Angeles|28","Sao Paulo|BR|-23.5475|-46.63611|America/Sao_Paulo|769","Seattle|US|47.60621|-122.33207|America/Los_Angeles|56","Sydney|AU|-33.86785|151.20732|Australia/Sydney|58","Tel Aviv|IL|32.08088|34.78057|Asia/Jerusalem|15","Tiberias|IL|32.79221|35.53124|Asia/Jerusalem|0","Toronto|CA|43.70011|-79.4163|America/Toronto|175","Vancouver|CA|49.24966|-123.11934|America/Vancouver|70","White Plains|US|41.03399|-73.76291|America/New_York|82","Washington DC|US|38.89511|-77.03637|America/New_York|6","Worcester|US|42.26259|-71.80229|America/New_York|164"];
+var citiesJson = [
+    "Ashdod|IL|31.79213|34.64966|Asia/Jerusalem|27",
+    "Atlanta|US|33.749|-84.38798|America/New_York|336",
+    "Austin|US|30.26715|-97.74306|America/Chicago|165",
+    "Baghdad|IQ|33.34058|44.40088|Asia/Baghdad|41",
+    "Beer Sheva|IL|31.25181|34.7913|Asia/Jerusalem|285",
+    "Berlin|DE|52.52437|13.41053|Europe/Berlin|43",
+    "Baltimore|US|39.29038|-76.61219|America/New_York|35",
+    "Bogota|CO|4.60971|-74.08175|America/Bogota|2582",
+    "Boston|US|42.35843|-71.05977|America/New_York|38",
+    "Budapest|HU|47.49801|19.03991|Europe/Budapest|104",
+    "Buenos Aires|AR|-34.61315|-58.37723|America/Argentina/Buenos_Aires|31",
+    "Buffalo|US|42.88645|-78.87837|America/New_York|191",
+    "Chicago|US|41.85003|-87.65005|America/Chicago|180",
+    "Cincinnati|US|39.162|-84.45689|America/New_York|267",
+    "Cleveland|US|41.4995|-81.69541|America/New_York|204",
+    "Dallas|US|32.78306|-96.80667|America/Chicago|139",
+    "Denver|US|39.73915|-104.9847|America/Denver|1636",
+    "Detroit|US|42.33143|-83.04575|America/Detroit|192",
+    "Eilat|IL|29.55805|34.94821|Asia/Jerusalem|63",
+    "Gibraltar|GI|36.14474|-5.35257|Europe/Gibraltar|11",
+    "Haifa|IL|32.81841|34.9885|Asia/Jerusalem|40",
+    "Hawaii|US|21.30694|-157.85833|Pacific/Honolulu|18",
+    "Helsinki|FI|60.16952|24.93545|Europe/Helsinki|26",
+    "Houston|US|29.76328|-95.36327|America/Chicago|30",
+    "Jerusalem|IL|31.76904|35.21633|Asia/Jerusalem|786",
+    "Johannesburg|ZA|-26.20227|28.04363|Africa/Johannesburg|1767",
+    "Kiev|UA|50.45466|30.5238|Europe/Kiev|187",
+    "La Paz|BO|-16.5|-68.15|America/La_Paz|3782",
+    "Livingston|US|40.79593|-74.31487|America/New_York|98",
+    "Las Vegas|US|36.17497|-115.13722|America/Los_Angeles|613",
+    "London|GB|51.50853|-0.12574|Europe/London|25",
+    "Los Angeles|US|34.05223|-118.24368|America/Los_Angeles|96",
+    "Marseilles|FR|43.29695|5.38107|Europe/Paris|28",
+    "Miami|US|25.77427|-80.19366|America/New_York|25",
+    "Minneapolis|US|44.97997|-93.26384|America/Chicago|262",
+    "Melbourne|AU|-37.814|144.96332|Australia/Melbourne|25",
+    "Mexico City|MX|19.42847|-99.12766|America/Mexico_City|2240",
+    "Montreal|CA|45.50884|-73.58781|America/Toronto|216",
+    "Moscow|RU|55.75222|37.61556|Europe/Moscow|144",
+    "New York|US|40.71427|-74.00597|America/New_York|57",
+    "Omaha|US|41.25861|-95.93779|America/Chicago|315",
+    "Ottawa|CA|45.41117|-75.69812|America/Toronto|71",
+    "Panama City|PA|8.9936|-79.51973|America/Panama|17",
+    "Paris|FR|48.85341|2.3488|Europe/Paris|42",
+    "Pawtucket|US|41.87871|-71.38256|America/New_York|0",
+    "Petach Tikvah|IL|32.08707|34.88747|Asia/Jerusalem|54",
+    "Philadelphia|US|39.95233|-75.16379|America/New_York|8",
+    "Phoenix|US|33.44838|-112.07404|America/Phoenix|366",
+    "Pittsburgh|US|40.44062|-79.99589|America/New_York|239",
+    "Providence|US|41.82399|-71.41283|America/New_York|0",
+    "Portland|US|45.52345|-122.67621|America/Los_Angeles|15",
+    "Saint Louis|US|38.62727|-90.19789|America/Chicago|149",
+    "Saint Petersburg|RU|59.93863|30.31413|Europe/Moscow|11",
+    "San Diego|US|32.71533|-117.15726|America/Los_Angeles|20",
+    "San Francisco|US|37.77493|-122.41942|America/Los_Angeles|28",
+    "Sao Paulo|BR|-23.5475|-46.63611|America/Sao_Paulo|769",
+    "Seattle|US|47.60621|-122.33207|America/Los_Angeles|56",
+    "Sydney|AU|-33.86785|151.20732|Australia/Sydney|58",
+    "Tel Aviv|IL|32.08088|34.78057|Asia/Jerusalem|15",
+    "Tiberias|IL|32.79221|35.53124|Asia/Jerusalem|0",
+    "Toronto|CA|43.70011|-79.4163|America/Toronto|175",
+    "Vancouver|CA|49.24966|-123.11934|America/Vancouver|70",
+    "White Plains|US|41.03399|-73.76291|America/New_York|82",
+    "Washington DC|US|38.89511|-77.03637|America/New_York|6",
+    "Worcester|US|42.26259|-71.80229|America/New_York|164"
+];
 
 class QuickLRU extends Map {
 	#size = 0;
@@ -8526,7 +8944,7 @@ function initClassicCities() {
  *
  * Extends {@link GeoLocation} from `@hebcal/noaa` with Jewish-calendar
  * specific data: an Israel/Diaspora flag, ISO country code, and an optional
- * geographic identifier. Also provides {@link Location.lookup} for ~60
+ * geographic identifier. Also provides {@link Location.lookup} for the 65
  * built-in "classic" Hebcal cities.
  *
  * @example
@@ -8591,8 +9009,14 @@ class Location extends GeoLocation {
     /**
      * Returns the full descriptive location name passed to the constructor,
      * or `null` if no name was provided.
+     *
+     * Note that the built-in classic cities are named by city alone, so
+     * `getName()` and {@link getShortName} return the same string for them.
      * @example
-     * Location.lookup('San Francisco')?.getName(); // 'San Francisco, California, USA'
+     * const loc = new Location(41.85003, -87.65005, false,
+     *   'America/Chicago', 'Chicago, Illinois, USA', 'US');
+     * loc.getName(); // 'Chicago, Illinois, USA'
+     * Location.lookup('San Francisco')?.getName(); // 'San Francisco'
      */
     getName() {
         return this.getLocationName();
@@ -8601,11 +9025,15 @@ class Location extends GeoLocation {
      * Returns the location name truncated at the first comma. Useful for
      * compact display where only the city name is desired.
      *
-     * Special-cased so that US locations of the form `"Washington, DC"` or
+     * Special-cased so that US locations of the form `"Washington, DC ..."` or
      * `"Washington, D.C., ..."` keep the `DC` / `D.C.` suffix attached.
      * @example
-     * Location.lookup('San Francisco')?.getShortName(); // 'San Francisco'
-     * Location.lookup('Washington DC')?.getShortName(); // 'Washington, DC'
+     * const chi = new Location(41.85003, -87.65005, false,
+     *   'America/Chicago', 'Chicago, Illinois, USA', 'US');
+     * chi.getShortName(); // 'Chicago'
+     * const dc = new Location(38.89511, -77.03637, false,
+     *   'America/New_York', 'Washington, D.C., USA', 'US');
+     * dc.getShortName(); // 'Washington, D.C.'
      */
     getShortName() {
         const name = this.getLocationName();
@@ -8659,7 +9087,7 @@ class Location extends GeoLocation {
         return this.geoid;
     }
     /**
-     * Creates a location object from one of 60 "classic" Hebcal city names.
+     * Creates a location object from one of 65 "classic" Hebcal city names.
      * The following city names are supported:
      * 'Ashdod', 'Atlanta', 'Austin', 'Baghdad', 'Beer Sheva',
      * 'Berlin', 'Baltimore', 'Bogota', 'Boston', 'Budapest',
@@ -8764,13 +9192,15 @@ class Location extends GeoLocation {
      * location with the same (lower-cased) name is already registered, and
      * `true` if successfully added.
      *
-     * Use this to extend the built-in set of ~60 classic Hebcal cities with
+     * Use this to extend the built-in set of 65 classic Hebcal cities with
      * your own custom locations.
      * @example
      * const tlv = new Location(32.0853, 34.7818, true,
-     *   'Asia/Tel_Aviv', 'My Office, Tel Aviv', 'IL');
+     *   'Asia/Jerusalem', 'My Office, Tel Aviv', 'IL');
      * Location.addLocation('My Office', tlv);   // true
-     * Location.lookup('my office')?.getTzid();  // 'Asia/Tel_Aviv'
+     * Location.lookup('my office')?.getTzid();  // 'Asia/Jerusalem'
+     * @param cityName name to register the location under (case insensitive)
+     * @param location the `Location` instance to register
      */
     static addLocation(cityName, location) {
         const name = cityName.toLowerCase();
@@ -8797,10 +9227,22 @@ const hour12cc = {
     ZA: 1,
 };
 /**
- * @private
+ * Helper function to format a 24-hour (00:00-23:59) time string in either
+ * 12-hour US format (e.g. `"8:13pm"`) or keep it in 24-hour format (e.g.
+ * `"20:13"`) for any other locale or country.
+ *
+ * The locale (and therefore default behavior) is derived from
+ * `options.location` / `options.locale`. The `options.hour12` override
+ * takes precedence: if `false`, locale is ignored and the result is always
+ * 24-hour; if `true`, locale is ignored and the result is always 12-hour.
+ * @example
+ * import {reformatTimeStr, Location} from '@hebcal/core';
+ * const opts = {location: Location.lookup('Chicago')};
+ * reformatTimeStr('20:30', 'pm', opts);          // '8:30pm'
+ * reformatTimeStr('20:30', 'pm', {hour12: false}); // '20:30'
  * @param timeStr - original time like "20:30"
  * @param suffix - "p" or "pm" or " P.M.". Add leading space if you want it
- * @param options
+ * @param options optional; `location`, `locale` and `hour12` are consulted
  */
 function reformatTimeStr(timeStr, suffix, options) {
     if (typeof timeStr !== 'string')
@@ -8885,6 +9327,17 @@ function getChalakimSinceMoladTohu(year, month) {
 function moladToAbsDate(chalakim) {
     return Math.trunc(chalakim / CHALAKIM_PER_DAY) + JEWISH_EPOCH;
 }
+/**
+ * Calculates the molad (birth of the new moon) for a Hebrew month using
+ * traditional chalakim arithmetic.
+ *
+ * Returns the raw components — day of week, hour, minutes and chalakim. Use
+ * {@link Molad} for a higher-level interface with rendering and Kiddush Levana
+ * times.
+ * @param year Hebrew year
+ * @param month Hebrew month (see `months` from `@hebcal/hdate`)
+ * @return the components of the molad for that month
+ */
 function calculateMolad(year, month) {
     const chalakim = getChalakimSinceMoladTohu(year, month);
     const absDate = moladToAbsDate(chalakim);
@@ -8911,20 +9364,23 @@ function calculateMolad(year, month) {
 /** constant for milliseconds in a minute (60,000) */
 const MINUTE_MILLIS = 60 * 1000;
 /**
- * A method that will return the location's local mean time offset in milliseconds from local <a
- * href="https://en.wikipedia.org/wiki/Standard_time">standard time</a>. 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 {@link com.kosherjava.zmanim.AstronomicalCalendar#getSunTransit() noon} (with adjustment for the <a
- * href="https://en.wikipedia.org/wiki/Equation_of_time">equation of time</a>) 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. Lakewood, N.J., whose longitude is
- * -74.222, is 0.778 away from the closest multiple of 15 at -75&deg;. This is multiplied by 4 to yield 3 minutes
- * and 10 seconds earlier than standard time. The offset returned does not account for the <a
- * href="https://en.wikipedia.org/wiki/Daylight_saving_time">Daylight saving time</a> offset since this class is
+ * 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°, with
+ * 15° per hour of the day. For a locale 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° west of this will have noon at 4 minutes after standard time noon, and conversely, a user
+ * who is 1° east of the 15° longitude will have noon at 11:56 AM. Lakewood, N.J., whose longitude is
+ * -74.222, is 0.778 away from the closest multiple of 15 at -75°. This is multiplied by 4 to yield 3 minutes
+ * and 10 seconds earlier than standard time. The offset returned does not account for the
+ * [Daylight saving time](https://en.wikipedia.org/wiki/Daylight_saving_time) offset since this function is
  * unaware of dates.
  *
+ * @param dt the date used to resolve the timezone offset
+ * @param longitude the location's longitude
+ * @param tzid IANA timezone identifier
  * @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.
+ *         East of the 15° timezone line, and a negative value West of it.
  */
 function getLocalMeanTimeOffset(dt, longitude, tzid) {
     const offset = -1 * getTimezoneOffset(tzid, dt);
@@ -8932,13 +9388,17 @@ function getLocalMeanTimeOffset(dt, longitude, tzid) {
     return Math.trunc(d);
 }
 /**
- * Returns the molad in UTC as a Temporal.ZonedDateTime.
- * This method subtracts 20.94 minutes (20 minutes and 56.496 seconds) from the computed time (Har Habayis with a longitude
- * of 35.2354&deg; is 5.2354&deg; away from the %15 timezone longitude) to get to standard time. This method
- * intentionally uses standard time and not daylight savings time.
+ * Returns the moment of the molad as a `Temporal.ZonedDateTime` in the `UTC` zone.
  *
- * @return the ZonedDateTime representing the moment of the molad in UTC
-
+ * The molad is computed in Jerusalem *standard* time and then converted, so the
+ * returned instant is correct year-round; only the zone of the returned object
+ * is `UTC`. This method subtracts 20.94 minutes (20 minutes and 56.496 seconds)
+ * from the computed time — Har Habayis, at longitude 35.2354°, is 5.2354° away
+ * from the multiple-of-15 timezone longitude — to get to standard time. Daylight
+ * savings time is intentionally not applied; adjust when formatting for display.
+ *
+ * @param molad the molad to convert
+ * @return the `Temporal.ZonedDateTime` representing the moment of the molad
  */
 function getMoladAsDate(molad) {
     const moladSeconds = (molad.chalakim * 10) / 3;
@@ -9033,8 +9493,8 @@ function getHebrewTimeOfDay(hour) {
  * import {Molad, months} from '@hebcal/core';
  * const m = new Molad(5784, months.NISAN);
  * console.log(m.getMonthName()); // 'Nisan'
- * console.log(m.getHour(), m.getMinutes(), m.getChalakim()); // e.g. 1 31 12
- * console.log(m.render('en')); // 'Molad Nisan: Mon, 1:31am and 12 chalakim'
+ * console.log(m.getHour(), m.getMinutes(), m.getChalakim()); // 22 57 7
+ * console.log(m.render('en')); // 'Molad Nisan: Monday, 10:57pm and 7 chalakim'
  */
 class Molad {
     /**
@@ -9102,17 +9562,21 @@ class Molad {
         return this.m.chalakim;
     }
     /**
-     * Returns the molad in Standard Time in Yerushalayim as a `Temporal.ZonedDateTime`.
-     * This method subtracts 20.94 minutes (20 minutes and 56.496 seconds) from the computed time (Har Habayis with a longitude
-     * of 35.2354&deg; is 5.2354&deg; away from the %15 timezone longitude) to get to standard time. This method
-     * intentionally uses standard time and not daylight savings time.
+     * Returns the moment of the molad as a `Temporal.ZonedDateTime` in the `UTC` zone.
+     *
+     * The molad is computed in Jerusalem *standard* time and then converted, so the
+     * returned instant is correct year-round; only the zone of the returned object
+     * is `UTC`. This method subtracts 20.94 minutes (20 minutes and 56.496 seconds)
+     * from the computed time — Har Habayis, at longitude 35.2354°, is 5.2354° away
+     * from the multiple-of-15 timezone longitude — to get to standard time. Daylight
+     * savings time is intentionally not applied; adjust when formatting for display.
      *
      * The returned value is cached after the first call.
      * @example
      * import {Molad, months} from '@hebcal/core';
      * const m = new Molad(5784, months.NISAN);
      * const zdt = m.getInstant();
-     * console.log(zdt.toString()); // e.g. '2024-04-08T17:21:13.333+00:00[UTC]'
+     * console.log(zdt.toString()); // '2024-04-08T20:36:26.837+00:00[UTC]'
      * @return the `Temporal.ZonedDateTime` representing the moment of the molad
      */
     getInstant() {
@@ -9131,9 +9595,9 @@ class Molad {
         return zdt.add({ hours: 72 });
     }
     /**
-     * Returns the earliest time of Kiddush Levana calculated as 7 days after the molad as mentioned by the <a
-     * href="https://en.wikipedia.org/wiki/Yosef_Karo">Mechaber</a>. See the <a
-     * href="https://en.wikipedia.org/wiki/Yoel_Sirkis">Bach's</a> opinion on this time. This method returns the time
+     * Returns the earliest time of Kiddush Levana calculated as 7 days after the molad as mentioned by the
+     * [Mechaber](https://en.wikipedia.org/wiki/Yosef_Karo). See the
+     * [Bach's](https://en.wikipedia.org/wiki/Yoel_Sirkis) opinion on this time. This method returns the time
      * even if it is during the day when _Kiddush Levana_ can't be said. Callers of this method should consider
      * displaying the next _tzais_ if the zman is between _alos_ and _tzais_.
      *
@@ -9144,8 +9608,8 @@ class Molad {
         return zdt.add({ hours: 168 });
     }
     /**
-     * Returns the latest time of Kiddush Levana according to the <a
-     * href="https://en.wikipedia.org/wiki/Yaakov_ben_Moshe_Levi_Moelin">Maharil's</a> opinion that it is calculated as
+     * Returns the latest time of Kiddush Levana according to the
+     * [Maharil's](https://en.wikipedia.org/wiki/Yaakov_ben_Moshe_Levi_Moelin) opinion that it is calculated as
      * halfway between molad and molad. This adds half the 29 days, 12 hours and 793 chalakim time between molad and
      * molad (14 days, 18 hours, 22 minutes and 666 milliseconds) to the month's molad. This method returns the time
      * even if it is during the day when _Kiddush Levana_ can't be said. Callers of this method should consider
@@ -9168,12 +9632,12 @@ class Molad {
     /**
      * Returns the latest time of Kiddush Levana calculated as 15 days after the molad. This is the opinion brought down
      * in the Shulchan Aruch (Orach Chaim 426). It should be noted that some opinions hold that the
-     * <a href="https://en.wikipedia.org/wiki/Moses_Isserles">Rema</a> who brings down the opinion of the <a
-     * href="https://en.wikipedia.org/wiki/Yaakov_ben_Moshe_Levi_Moelin">Maharil's</a> of calculating
-     * {@link Molad.getSofZmanKidushLevanaBetweenMoldos() half way between molad and mold} is of the opinion that Mechaber
+     * [Rema](https://en.wikipedia.org/wiki/Moses_Isserles) who brings down the opinion of the
+     * [Maharil's](https://en.wikipedia.org/wiki/Yaakov_ben_Moshe_Levi_Moelin) of calculating
+     * {@link Molad.getSofZmanKidushLevanaBetweenMoldos | half way between molad and molad} is of the opinion that Mechaber
      * agrees to his opinion. Also see the Aruch Hashulchan. For additional details on the subject, See Rabbi Dovid
-     * Heber's very detailed writeup in Siman Daled (chapter 4) of <a
-     * href="https://www.worldcat.org/oclc/461326125">Shaarei Zmanim</a>. This method returns the time even if it is during
+     * Heber's very detailed writeup in Siman Daled (chapter 4) of
+     * [Shaarei Zmanim](https://www.worldcat.org/oclc/461326125). This method returns the time even if it is during
      * the day when _Kiddush Levana_ can't be said. Callers of this method should consider displaying _alos_
      * before this time if the zman is between _alos_ and _tzais_.
      *
@@ -9190,14 +9654,16 @@ class Molad {
      * month name, day of week, hour : minute, and chalakim if non-zero.
      *
      * Time format honors `options.hour12` and `options.location` (12-hour vs.
-     * 24-hour); see {@link HebrewCalendar.reformatTimeStr}.
+     * 24-hour); see {@link reformatTimeStr}.
      * @example
      * import {Molad, months} from '@hebcal/core';
      * const m = new Molad(5784, months.NISAN);
      * m.render('en', {hour12: true});
-     * // => 'Molad Nisan: Mon, 7:21pm and 6 chalakim'
+     * // => 'Molad Nisan: Monday, 10:57pm and 7 chalakim'
+     * m.render('en', {hour12: false});
+     * // => 'Molad Nisan: Monday, 22:57 and 7 chalakim'
      * m.render('he');
-     * // => 'מוֹלָד נִיסָן יִהְיֶה בַּיּוֹם שֵׁנִי בשָׁבוּעַ, …'
+     * // => 'מוֹלָד הָלְּבָנָה נִיסָן יִהְיֶה בַּיּוֹם שֵׁנִי בשָׁבוּעַ, …'
      * @param [locale] Optional locale name (defaults to empty locale)
      * @param options used for time formatting (12-hour vs 24-hour)
      */
@@ -9269,16 +9735,16 @@ function zdtToDate(zdt) {
     return res;
 }
 /**
- * The zenith of astronomical sunrise and sunset. The sun is 90&deg; from the vertical 0&deg;
+ * The zenith of astronomical sunrise and sunset. The sun is 90° from the vertical 0°
  */
 const GEOMETRIC_ZENITH = 90;
 /**
- * The zenith of 1.583&deg; below {@link GEOMETRIC_ZENITH geometric zenith} (90&deg;). This calculation is used for
+ * The zenith of 1.583° below geometric zenith (90°). This calculation is used for
  * calculating _netz amiti_ (sunrise) and _shkiah amiti_ (sunset) based on the opinion of the
- * <a href="https://en.wikipedia.org/wiki/Shneur_Zalman_of_Liadi">Baal Hatanya</a>.
+ * [Baal Hatanya](https://en.wikipedia.org/wiki/Shneur_Zalman_of_Liadi).
  *
- * @see Zmanim.sunriseBaalHatanya()
- * @see Zmanim.sunsetBaalHatanya()
+ * @see Zmanim.sunriseBaalHatanya
+ * @see Zmanim.sunsetBaalHatanya
  */
 const ZENITH_1_POINT_583 = GEOMETRIC_ZENITH + 1.583;
 /**
@@ -9297,7 +9763,7 @@ const ZENITH_1_POINT_583 = GEOMETRIC_ZENITH + 1.583;
  * https://gml.noaa.gov/grad/solcalc/calcdetails.html
  *
  * @example
- * const {GeoLocation, Zmanim} = require('@hebcal/core');
+ * import {GeoLocation, Zmanim} from '@hebcal/core';
  * const latitude = 41.822232;
  * const longitude = -71.448292;
  * const tzid = 'America/New_York';
@@ -9306,6 +9772,7 @@ const ZENITH_1_POINT_583 = GEOMETRIC_ZENITH + 1.583;
  * const zmanim = new Zmanim(gloc, friday, false);
  * const candleLighting = zmanim.sunsetOffset(-18, true);
  * const timeStr = Zmanim.formatISOWithTimeZone(tzid, candleLighting);
+ * // '2023-09-08T18:49:00-04:00'
  */
 class Zmanim {
     /**
@@ -9332,15 +9799,19 @@ class Zmanim {
         this.useElevation = Boolean(useElevation);
     }
     /**
-     * Returns `true` if elevation adjustment is enabled
-     * for zmanim support elevation adjustment
+     * Returns `true` if this instance uses the location's elevation when
+     * calculating sunrise/sunset-based zmanim.
      */
     getUseElevation() {
         return this.useElevation;
     }
     /**
-     * Enables or disables elevation adjustment for zmanim support elevation adjustment
-     * @param useElevation
+     * Enables or disables elevation adjustment for sunrise/sunset-based zmanim.
+     *
+     * Degree-based zmanim (such as {@link alotHaShachar} or {@link tzeit})
+     * estimate the amount of light in the sky and are never affected by this
+     * setting.
+     * @param useElevation `true` to include the location's elevation
      */
     setUseElevation(useElevation) {
         this.useElevation = useElevation;
@@ -9349,8 +9820,10 @@ class Zmanim {
      * Convenience function to get the time when sun is above or below the horizon
      * for a certain angle (in degrees).
      * This function does not support elevation adjustment.
-     * @param angle
-     * @param rising
+     * @param angle degrees of solar depression below the horizon; for example
+     *  `8.5` means the center of the sun is 8.5° below the horizon
+     * @param rising `true` for the morning (before sunrise), `false` for the
+     *  evening (after sunset)
      */
     timeAtAngle(angle, rising) {
         const offsetZenith = GEOMETRIC_ZENITH + angle;
@@ -9424,13 +9897,19 @@ class Zmanim {
         return zman.sunset();
     }
     /**
-     * @private
+     * Length in milliseconds of one halachic hour of the night, calculated as
+     * one twelfth of the time between the previous day's sunset and this
+     * day's sunrise. Used internally by {@link chatzotNight}.
      */
     nightHour() {
         return (this.sunrise().getTime() - this.gregEve().getTime()) / 12; // ms in hour
     }
     /**
-     * Midday – Chatzot; Sunrise plus 6 halachic hours
+     * Midday – Chatzot; Sunrise plus 6 halachic hours.
+     *
+     * Unlike most sunrise/sunset-based zmanim, this is always computed from
+     * sea-level sunrise and sunset, so it is not affected by the
+     * `useElevation` setting.
      */
     chatzot() {
         const startOfDay = this.noaa.getSeaLevelSunrise();
@@ -9460,6 +9939,11 @@ class Zmanim {
     alotHaShachar72() {
         return this.sunriseOffset(-72, false, false);
     }
+    /**
+     * Same as {@link alotHaShachar72}, but returns a `Temporal.ZonedDateTime`
+     * with seconds precision (instead of a `Date` rounded to the minute), or
+     * `null` if sunrise cannot be calculated for this date and location.
+     */
     alotHaShachar72zdt() {
         const zdt = this.useElevation
             ? this.noaa.getSunrise()
@@ -9493,8 +9977,7 @@ class Zmanim {
     }
     /**
      * Utility method for using elevation-aware sunrise/sunset
-     * @private
-     * @param hours
+     * @param hours number of _shaos zmaniyos_ (solar hours) after sunrise
      */
     getShaahZmanisBasedZman(hours) {
         const startOfDay = this.useElevation
@@ -9517,7 +10000,7 @@ class Zmanim {
     /**
      * Latest Shacharit (Gra); Sunrise plus 4 halachic hours, according to the Gra.
      *
-     * This method returns the latest *zman tfila* (time to recite shema in the morning)
+     * This method returns the latest *zman tfila* (time to recite the morning prayers)
      * that is 4 *shaos zmaniyos* (solar hours) after sunrise or sea level sunrise
      * (depending on the `useElevation` setting), according
      * to the [GRA](https://en.wikipedia.org/wiki/Vilna_Gaon).
@@ -9530,21 +10013,23 @@ class Zmanim {
     }
     /**
      * This method returns the latest time for burning _chametz_ on _Erev Pesach_ according to the opinion
-     * of the <a href="https://en.wikipedia.org/wiki/Vilna_Gaon">GRA</a>. This time is 5 hours into the day based on the
-     * opinion of the <a href="https://en.wikipedia.org/wiki/Vilna_Gaon">GRA</a> that the day is calculated from
-     * sunrise to sunset. This returns the time 5 * {@link #getShaahZmanisGra()} after {@link #getSeaLevelSunrise() sea
-     * level sunrise}.
-     * @return the <code>Date</code> of the latest time for burning _chametz_ on _Erev Pesach_. If it is not
-     *         _erev Pesach_ or the calculation can't be computed such as in the Arctic Circle where there is at least
-     *         one day a year where the sun does not rise, and one where it does not set, a <code>null</code> will be
-     *         returned.
+     * of the [GRA](https://en.wikipedia.org/wiki/Vilna_Gaon). This time is 5 halachic hours into the day, based on
+     * the opinion of the GRA that the day is calculated from sunrise to sunset.
+     *
+     * If elevation is enabled, this function will include elevation in the calculation.
+     * @return the `Date` of the latest time for burning _chametz_ on _Erev Pesach_. If the calculation can't be
+     *         computed, such as in the Arctic Circle where there is at least one day a year where the sun does not
+     *         rise and one where it does not set, an `Invalid Date` will be returned.
      */
     sofZmanBiurChametzGRA() {
         return this.getShaahZmanisBasedZman(5);
     }
     /**
-     * Returns an array with alot (Date) and ms in hour (number)
-     * @private
+     * Returns a 2-element array with alot (a `Date`, 72 minutes before sunrise)
+     * and the length in milliseconds of one halachic hour of the resulting day.
+     * Used internally by the Magen Avraham zmanim.
+     * @param forceSeaLevel ignore the `useElevation` setting and use sea-level
+     *  sunrise and sunset
      */
     getTemporalHour72(forceSeaLevel) {
         const alot72 = this.sunriseOffset(-72, false, forceSeaLevel);
@@ -9553,8 +10038,11 @@ class Zmanim {
         return [alot72, temporalHour];
     }
     /**
-     * Returns an array with alot (Date) and ms in hour (number)
-     * @private
+     * Returns a 2-element array with alot (a `Date`, when the sun is `angle`
+     * degrees below the horizon in the morning) and the length in milliseconds
+     * of one halachic hour of the resulting day. Used internally by the
+     * degree-based Magen Avraham zmanim.
+     * @param angle degrees of solar depression below the horizon
      */
     getTemporalHourByDeg(angle) {
         const alot = this.timeAtAngle(angle, true);
@@ -9635,7 +10123,7 @@ class Zmanim {
      * Earliest Mincha – Mincha Gedola (GRA); Sunrise plus 6.5 halachic hours.
      * If elevation is enabled, this function will include elevation in the calculation.
      *
-     * This method returns the latest mincha gedola, the earliest time one can pray mincha
+     * This method returns *mincha gedola*, the earliest time one can pray mincha,
      * that is 6.5 shaos zmaniyos (solar hours) after sunrise or sea level sunrise
      * (depending on the `useElevation` setting), according
      * to the [GRA](https://en.wikipedia.org/wiki/Vilna_Gaon).
@@ -9693,14 +10181,24 @@ class Zmanim {
         return this.getShaahZmanisBasedZman(10.75);
     }
     /**
-     * @param [angle=8.5] optional time for solar depression.
-     *   Default is 8.5 degrees for 3 small stars, use 7.083 degrees for 3 medium-sized stars.
+     * Nightfall – Tzeit HaKochavim; the sun is `angle` degrees below the
+     * horizon in the evening.
+     *
      * Because degree-based functions estimate the amount of light in the sky,
      * the result is not impacted by elevation.
+     * @param [angle=8.5] optional time for solar depression.
+     *   Default is 8.5 degrees for 3 small stars, use 7.083 degrees for 3 medium-sized stars.
      */
     tzeit(angle = 8.5) {
         return this.timeAtAngle(angle, false);
     }
+    /**
+     * Nightfall – Tzeit HaKochavim; calculated as 72 minutes after sunset
+     * (or sea-level sunset, depending on the `useElevation` setting).
+     *
+     * Returns a `Temporal.ZonedDateTime` with seconds precision, or `null` if
+     * sunset cannot be calculated for this date and location.
+     */
     tzeit72() {
         const zdt = this.useElevation
             ? this.noaa.getSunset()
@@ -9797,12 +10295,13 @@ class Zmanim {
         return moladBasedTime.withTimeZone(this.gloc.getTimeZone());
     }
     /**
-     * Returns the latest time of Kiddush Levana according to the <a
-     * href="https://en.wikipedia.org/wiki/Yaakov_ben_Moshe_Levi_Moelin">Maharil's</a> opinion that it is calculated as
+     * Returns the latest time of Kiddush Levana according to the
+     * [Maharil's](https://en.wikipedia.org/wiki/Yaakov_ben_Moshe_Levi_Moelin) opinion that it is calculated as
      * halfway between _molad_ and _molad_. This adds half the 29 days, 12 hours and 793 chalakim time between
      * _molad_ and _molad_ (14 days, 18 hours, 22 minutes and 666 milliseconds) to the month's _molad_.
-     * The _sof zman Kiddush Levana_ will be returned even if it occurs during the day. To limit the time to between
-     * _tzais_ and _alos_, see {@link getSofZmanKidushLevanaBetweenMoldos}.
+     *
+     * The _sof zman Kiddush Levana_ will be returned even if it occurs during the day, unless both `alos` and
+     * `tzais` are supplied.
      *
      * @param alos
      *            the beginning of the Jewish day. If _Kidush Levana_ occurs during the day (starting at _alos_ and
@@ -9812,9 +10311,9 @@ class Zmanim {
      *            the end of the Jewish day. If Kidush Levana occurs during the day (starting at alos and ending at
      *            tzais), the time returned will be alos. If either the alos or tzais parameters are null, no daytime
      *            adjustment will be made.
-     * @return the Date representing the moment halfway between molad and molad. If the time occurs between
-     *         _alos_ and _tzais_, _alos_ will be returned. If the _zman_ will not occur on this
-     *         day, a `null` will be returned.
+     * @return the `Temporal.ZonedDateTime` representing the moment halfway between molad and molad. If the time
+     *         occurs between _alos_ and _tzais_, _alos_ will be returned. If the _zman_ will not occur on this
+     *         day, `null` will be returned.
      */
     getSofZmanKidushLevanaBetweenMoldos(alos = null, tzais = null) {
         const hd = this.hdate;
@@ -9831,19 +10330,25 @@ class Zmanim {
     /**
      * Returns the latest time of _Kiddush Levana_ calculated as 15 days after the molad. This is the opinion of
      * the Shulchan Aruch (Orach Chaim 426). It should be noted that some opinions hold that the
-     * <a href="https://en.wikipedia.org/wiki/Moses_Isserles">Rema</a> who brings down the opinion of the <a
-     * href="https://en.wikipedia.org/wiki/Yaakov_ben_Moshe_Levi_Moelin">Maharil's</a> of calculating
-     * {@link getSofZmanKidushLevanaBetweenMoldos half way between _molad_ and _molad_} is of
-     * the opinion that the Mechaber agrees to his opinion. Also see the Aruch Hashulchan. For additional details on the subject,
-     * See Rabbi Dovid Heber's very detailed write-up in Siman Daled (chapter 4) of <a href="https://hebrewbooks.org/53000">Shaarei
-     * Zmanim</a>. The _sof zman Kiddush Levana_ will be returned even if it occurs during the day. To limit the time to
-     * between _tzais_ and _alos_, see {@link getSofZmanKidushLevana15Days}.
-     *
-     * @return the Date representing the moment 15 days after the _molad_. If the time occurs between
-     *         _alos_ and _tzais_, _alos_ will be returned. If the _zman_ will not occur on this day, a
-     *         `null` will be returned.
+     * [Rema](https://en.wikipedia.org/wiki/Moses_Isserles), who brings down the opinion of the
+     * [Maharil](https://en.wikipedia.org/wiki/Yaakov_ben_Moshe_Levi_Moelin) of calculating
+     * {@link getSofZmanKidushLevanaBetweenMoldos half way between _molad_ and _molad_}, is of
+     * the opinion that the Mechaber agrees to his opinion. Also see the Aruch Hashulchan. For additional details on
+     * the subject, see Rabbi Dovid Heber's very detailed write-up in Siman Daled (chapter 4) of
+     * [Shaarei Zmanim](https://hebrewbooks.org/53000).
      *
+     * The _sof zman Kiddush Levana_ will be returned even if it occurs during the day, unless both `alos` and
+     * `tzais` are supplied.
      *
+     * @param alos
+     *            the beginning of the Jewish day. If either the _alos_ or _tzais_ parameters are null, no daytime
+     *            adjustment will be made.
+     * @param tzais
+     *            the end of the Jewish day. If either the _alos_ or _tzais_ parameters are null, no daytime
+     *            adjustment will be made.
+     * @return the `Temporal.ZonedDateTime` representing the moment 15 days after the _molad_. If the time occurs
+     *         between _alos_ and _tzais_, _alos_ will be returned. If the _zman_ will not occur on this day,
+     *         `null` will be returned.
      */
     getSofZmanKidushLevana15Days(alos = null, tzais = null) {
         const hd = this.hdate;
@@ -9858,8 +10363,8 @@ class Zmanim {
         return this.getMoladBasedTime(molad.getSofZmanKidushLevana15Days(), alos, tzais, false);
     }
     /**
-     * Returns the earliest time of _Kiddush Levana_ according to <a href=
-     * "https://en.wikipedia.org/wiki/Yonah_Gerondi">Rabbeinu Yonah</a>'s opinion that it can be said 3 days after the _molad_.
+     * Returns the earliest time of _Kiddush Levana_ according to
+     * [Rabbeinu Yonah](https://en.wikipedia.org/wiki/Yonah_Gerondi)'s opinion that it can be said 3 days after the _molad_.
      * If the time of _tchilas zman Kiddush Levana_ occurs during the day (between _alos_ and _tzais_ passed to
      * this method) it will return the following _tzais_. If null is passed for either _alos_ or _tzais_, the actual
      * _tchilas zman Kiddush Levana_ will be returned, regardless of if it is during the day or not.
@@ -9873,8 +10378,8 @@ class Zmanim {
      *            _tzais_), the time returned will be _tzais_. If either the _alos_ or _tzais_ parameters
      *            are null, no daytime adjustment will be made.
      *
-     * @return the Date representing the moment 3 days after the molad. If the time occurs between _alos_ and
-     *         _tzais_, _tzais_ will be returned. If the _zman_ will not occur on this day, a
+     * @return the `Temporal.ZonedDateTime` representing the moment 3 days after the molad. If the time occurs
+     *         between _alos_ and _tzais_, _tzais_ will be returned. If the _zman_ will not occur on this day,
      *         `null` will be returned.
      */
     getTchilasZmanKidushLevana3Days(alos = null, tzais = null) {
@@ -9899,13 +10404,11 @@ class Zmanim {
         return zman;
     }
     /**
-     * Returns the point in time of _Molad_ as a <code>Date</code> Object. For the traditional day of week, hour,
-     * minute and chalakim, {@link Molad.getInstant()} and the not yet completed
-     * {@link HebrewDateFormatter} that will have formatting for this.
-     *
-     * @return the Date representing the moment of the molad. If the _molad_ does not occur on this day, a
-     *         `null` will be returned.
+     * Returns the point in time of the _Molad_, if it occurs on this date. For the traditional day of week, hour,
+     * minute and chalakim, see {@link Molad} and its {@link Molad.render} method.
      *
+     * @return the `Temporal.ZonedDateTime` representing the moment of the molad. If the _molad_ does not occur on
+     *         this day, `null` will be returned.
      */
     getZmanMolad() {
         const hd = this.hdate;
@@ -9928,10 +10431,17 @@ class Zmanim {
     /**
      * Returns the earliest time of _Kiddush Levana_ according to the opinions that it should not be said until 7
      * days after the _molad_. The time will be returned even if it occurs during the day when _Kiddush Levana_
-     * can't be recited. Use {@link getTchilasZmanKidushLevana7Days} if you want to limit the time to night hours.
+     * can't be recited, unless both `alos` and `tzais` are supplied.
      *
-     * @return the Date representing the moment 7 days after the molad regardless of it is day or night. If the _zman_
-     *         will not occur on this day, a `null` will be returned.
+     * @param alos
+     *            the beginning of the Jewish day. If _Kidush Levana_ occurs during the day (starting at _alos_ and
+     *            ending at _tzais_), the time returned will be _tzais_. If either the _alos_ or _tzais_ parameters
+     *            are null, no daytime adjustment will be made.
+     * @param tzais
+     *            the end of the Jewish day. If either the _alos_ or _tzais_ parameters are null, no daytime
+     *            adjustment will be made.
+     * @return the `Temporal.ZonedDateTime` representing the moment 7 days after the molad. If the _zman_
+     *         will not occur on this day, `null` will be returned.
      */
     getTchilasZmanKidushLevana7Days(alos = null, tzais = null) {
         const hd = this.hdate;
@@ -9947,41 +10457,38 @@ class Zmanim {
         return this.getMoladBasedTime(molad.getTchilasZmanKidushLevana7Days(), alos, tzais, true);
     }
     /**
-     * A method that returns the <a href="https://en.wikipedia.org/wiki/Shneur_Zalman_of_Liadi">Baal Hatanya</a>'s
+     * A method that returns the [Baal Hatanya](https://en.wikipedia.org/wiki/Shneur_Zalman_of_Liadi)'s
      * _netz amiti_ (sunrise) without
      * elevation adjustment. This forms the base for the Baal Hatanya's dawn-based calculations that are
      * calculated as a dip below the horizon before sunrise.
      *
      * According to the Baal Hatanya, _netz amiti_, or true (halachic) sunrise, is when the top of the sun's
      * disk is visible at an elevation similar to the mountains of Eretz Yisrael. The time is calculated as the point at which
-     * the center of the sun's disk is 1.583&deg; below the horizon. This degree-based calculation can be found in Rabbi Shalom
-     * DovBer Levine's commentary on The <a href="https://www.chabadlibrary.org/books/pdf/Seder-Hachnosas-Shabbos.pdf">Baal
-     * Hatanya's Seder Hachnasas Shabbos</a>. From an elevation of 546 meters, the top of <a href=
-     * "https://en.wikipedia.org/wiki/Mount_Carmel">Har Hacarmel</a>, the sun disappears when it is 1&deg; 35' or 1.583&deg;
-     * below the sea level horizon. This in turn is based on the Gemara <a href=
-     * "https://hebrewbooks.org/shas.aspx?mesechta=2&daf=35">Shabbos 35a</a>. There are other opinions brought down by
+     * the center of the sun's disk is 1.583° below the horizon. This degree-based calculation can be found in Rabbi Shalom
+     * DovBer Levine's commentary on
+     * [The Baal Hatanya's Seder Hachnasas Shabbos](https://www.chabadlibrary.org/books/pdf/Seder-Hachnosas-Shabbos.pdf).
+     * From an elevation of 546 meters, the top of [Har Hacarmel](https://en.wikipedia.org/wiki/Mount_Carmel),
+     * the sun disappears when it is 1° 35' or 1.583° below the sea level horizon. This in turn is based on the Gemara
+     * [Shabbos 35a](https://hebrewbooks.org/shas.aspx?mesechta=2&daf=35). There are other opinions brought down by
      * Rabbi Levine, including Rabbi Yosef Yitzchok Feigelstock who calculates it as the degrees below the horizon 4 minutes after
-     * sunset in Yerushalayim (on the equinox). That is brought down as 1.583&deg;. This is identical to the 1&deg; 35' _zman_
-     * and is probably a typo and should be 1.683&deg;. These calculations are used by most <a href=
-     * "https://en.wikipedia.org/wiki/Chabad">Chabad</a> calendars that use the Baal Hatanya's _zmanim_. See
-     * <a href="https://www.chabad.org/library/article_cdo/aid/3209349/jewish/About-Our-Zmanim-Calculations.htm">About Our
-     * _Zmanim_ Calculations @ Chabad.org</a>.
+     * sunset in Yerushalayim (on the equinox). That is brought down as 1.583°. This is identical to the 1° 35' _zman_
+     * and is probably a typo and should be 1.683°. These calculations are used by most
+     * [Chabad](https://en.wikipedia.org/wiki/Chabad) calendars that use the Baal Hatanya's _zmanim_. See
+     * [About Our Zmanim Calculations @ Chabad.org](https://www.chabad.org/library/article_cdo/aid/3209349/jewish/About-Our-Zmanim-Calculations.htm).
      *
      * Note: _netz amiti_ is used only for calculating certain _zmanim_, and is intentionally unpublished. For
      * practical purposes, daytime _mitzvos_ like _shofar_ and _lulav_ should not be done until after the
      * published time for _netz_ / sunrise.
      *
-     * @return the <code>Date</code> representing the exact sea level _netz amiti_ (sunrise) time. If the calculation can't be
-     *         computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one
-     *         where it does not set, a `null` will be returned. See detailed explanation on top of the page.
-     *
-     * @see ZENITH_1_POINT_583
+     * @return the exact sea level _netz amiti_ (sunrise) time. If the calculation can't be
+     *         computed, such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one
+     *         where it does not set, `null` will be returned.
      */
     getSunriseBaalHatanya() {
         return this.noaa.getSunriseOffsetByDegrees(ZENITH_1_POINT_583);
     }
     /**
-     * A method that returns the <a href="https://en.wikipedia.org/wiki/Shneur_Zalman_of_Liadi">Baal Hatanya</a>'s
+     * A method that returns the [Baal Hatanya](https://en.wikipedia.org/wiki/Shneur_Zalman_of_Liadi)'s
      * _shkiah amiti_ (sunset) without
      * elevation adjustment. This forms the base for the Baal Hatanya's dusk-based calculations that are calculated
      * as a dip below the horizon after sunset.
@@ -9994,33 +10501,31 @@ class Zmanim {
      * practical purposes, all daytime mitzvos should be completed before the published time for _shkiah_ / sunset.
      *
      * For further explanation of the calculations used for the Baal Hatanya's _zmanim_ in this library, see
-     * <a href="https://www.chabad.org/library/article_cdo/aid/3209349/jewish/About-Our-Zmanim-Calculations.htm">About Our
-     * _Zmanim_ Calculations @ Chabad.org</a>.
-     *
-     * @return the <code>Date</code> representing the exact sea level _shkiah amiti_ (sunset) time. If the calculation
-     *         can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not
-     *         rise, and one where it does not set, a `null` will be returned.
+     * [About Our Zmanim Calculations @ Chabad.org](https://www.chabad.org/library/article_cdo/aid/3209349/jewish/About-Our-Zmanim-Calculations.htm).
      *
-     * @see ZENITH_1_POINT_583
+     * @return the exact sea level _shkiah amiti_ (sunset) time. If the calculation
+     *         can't be computed, such as in the Arctic Circle where there is at least one day a year where the sun does not
+     *         rise, and one where it does not set, `null` will be returned.
      */
     getSunsetBaalHatanya() {
         return this.noaa.getSunsetOffsetByDegrees(ZENITH_1_POINT_583);
     }
     /**
-     * Returns the <a href="https://en.wikipedia.org/wiki/Shneur_Zalman_of_Liadi">Baal Hatanya</a>'s _alos_
-     * (dawn) calculated as the time when the sun is 16.9&deg; below the eastern {@link GEOMETRIC_ZENITH geometric horizon}
-     * before {@link getSunrise() sunrise}.
+     * Returns the [Baal Hatanya](https://en.wikipedia.org/wiki/Shneur_Zalman_of_Liadi)'s _alos_
+     * (dawn) calculated as the time when the sun is 16.9° below the eastern geometric horizon
+     * before {@link sunrise}.
      *
-     * The zenith of 16.9&deg; below is based on the calculation that the time between dawn
-     * and _netz amiti_ (sunrise) is 72 minutes, the time that is takes to walk 4 mil at 18 minutes
-     * a mil (<a href="https://en.wikipedia.org/wiki/Maimonides">Rambam</a> and others). The sun's position at 72
-     * minutes before {@link getSunriseBaalHatanya _netz amiti_ (sunrise)} in Jerusalem <a href=
-     * "https://kosherjava.com/2022/01/12/equinox-vs-equilux-zmanim-calculations/">around the equinox / equilux</a> is
-     * 16.9&deg; below {@link GEOMETRIC_ZENITH geometric zenith}.
+     * The zenith of 16.9° below is based on the calculation that the time between dawn
+     * and _netz amiti_ (sunrise) is 72 minutes, the time that it takes to walk 4 mil at 18 minutes
+     * a mil ([Rambam](https://en.wikipedia.org/wiki/Maimonides) and others). The sun's position at 72
+     * minutes before _netz amiti_ (sunrise) in Jerusalem
+     * [around the equinox / equilux](https://kosherjava.com/2022/01/12/equinox-vs-equilux-zmanim-calculations/)
+     * is 16.9° below geometric zenith.
      *
-     * @return The <code>Date</code> of dawn. If the calculation can't be computed such as northern and southern
+     * @return the `Date` of dawn. If the calculation can't be computed, such as in northern and southern
      *         locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach
-     *         low enough below the horizon for this calculation, a `null` will be returned.   */
+     *         low enough below the horizon for this calculation, an `Invalid Date` will be returned.
+     */
     alosBaalHatanya() {
         return this.timeAtAngle(16.9, true);
     }
@@ -10030,86 +10535,79 @@ class Zmanim {
     }
     /**
      * This method returns the latest _zman krias shema_ (time to recite Shema in the morning). This time is 3
-     * {@link shaahZmanisBaalHatanya() _shaos zmaniyos_} (solar hours) after {@link getSunriseBaalHatanya()
-     * _netz amiti_ (sunrise)} based on the opinion of the Baal Hatanya that the day is calculated from
-     * sunrise to sunset. This returns the time 3 * {@link getShaahZmanisBaalHatanya()} after {@link getSunriseBaalHatanya()
-     * _netz amiti_ (sunrise)}.
+     * _shaos zmaniyos_ (solar hours) after _netz amiti_ (sunrise), based on the opinion of the Baal Hatanya
+     * that the day is calculated from _netz amiti_ (sunrise) to _shkiah amiti_ (sunset).
      *
-     * @return the <code>Date</code> of the latest _zman shema_ according to the Baal Hatanya. If the calculation
-     *         can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does
-     *         not rise, and one where it does not set, a `null` will be returned.
+     * @return the `Date` of the latest _zman shema_ according to the Baal Hatanya. If the calculation
+     *         can't be computed, such as in the Arctic Circle where there is at least one day a year where the sun does
+     *         not rise and one where it does not set, an `Invalid Date` will be returned.
      */
     sofZmanShmaBaalHatanya() {
         return this.getShaahZmanisBaalHatanya(3);
     }
     /**
      * This method returns the latest _zman tfilah_ (time to recite the morning prayers). This time is 4
-     * hours into the day based on the opinion of the Baal Hatanya that the day is
-     * calculated from sunrise to sunset. This returns the time 4 * {@link getShaahZmanisBaalHatanya()} after
-     * {@link getSunriseBaalHatanya() _netz amiti_ (sunrise)}.
+     * halachic hours into the day, based on the opinion of the Baal Hatanya that the day is
+     * calculated from _netz amiti_ (sunrise) to _shkiah amiti_ (sunset).
      *
-     * @return the <code>Date</code> of the latest _zman tfilah_. If the calculation can't be computed such as in
-     *         the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does
-     *         not set, a `null` will be returned.
+     * @return the `Date` of the latest _zman tfilah_. If the calculation can't be computed, such as in
+     *         the Arctic Circle where there is at least one day a year where the sun does not rise and one where it does
+     *         not set, an `Invalid Date` will be returned.
      */
     sofZmanTfilaBaalHatanya() {
         return this.getShaahZmanisBaalHatanya(4);
     }
     /**
      * This method returns the time of _mincha gedola_. _Mincha gedola_ is the earliest time one can pray
-     * _mincha_. The <a href="https://en.wikipedia.org/wiki/Maimonides">Rambam</a> is of the opinion that it is
-     * better to delay _mincha_ until {@link minchaKetanaBaalHatanya() _mincha ketana_} while the
-     * <a href="https://en.wikipedia.org/wiki/Asher_ben_Jehiel">Ra"sh</a>,
-     * <a href="https://en.wikipedia.org/wiki/Jacob_ben_Asher">Tur</a>, <a href=
-     * "https://en.wikipedia.org/wiki/Vilna_Gaon">GRA</a> and others are of the opinion that _mincha_ can be prayed
-     * _lechatchila_ starting at _mincha gedola_. This is calculated as 6.5 {@link getShaahZmanisBaalHatanya()
-     * sea level solar hours} after {@link getSunriseBaalHatanya() _netz amiti_ (sunrise)}. This calculation is based
-     * on the opinion of the Baal Hatanya that the day is calculated from sunrise to sunset. This returns the time 6.5
-     * * {@link getShaahZmanisBaalHatanya()} after {@link getSunriseBaalHatanya() _netz amiti_ ("real" sunrise)}.
-     * @return the <code>Date</code> of the time of _mincha gedola_ according to the Baal Hatanya. If the calculation
-     *         can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does not rise,
-     *         and one where it does not set, a `null` will be returned.
+     * _mincha_. The [Rambam](https://en.wikipedia.org/wiki/Maimonides) is of the opinion that it is
+     * better to delay _mincha_ until {@link minchaKetanaBaalHatanya | _mincha ketana_} while the
+     * [Ra"sh](https://en.wikipedia.org/wiki/Asher_ben_Jehiel),
+     * [Tur](https://en.wikipedia.org/wiki/Jacob_ben_Asher),
+     * [GRA](https://en.wikipedia.org/wiki/Vilna_Gaon) and others are of the opinion that _mincha_ can be prayed
+     * _lechatchila_ starting at _mincha gedola_. This is calculated as 6.5 sea level solar hours after
+     * _netz amiti_ (sunrise), based on the opinion of the Baal Hatanya that the day is calculated from
+     * _netz amiti_ (sunrise) to _shkiah amiti_ (sunset).
+     * @return the `Date` of the time of _mincha gedola_ according to the Baal Hatanya. If the calculation
+     *         can't be computed, such as in the Arctic Circle where there is at least one day a year where the sun does not rise
+     *         and one where it does not set, an `Invalid Date` will be returned.
      */
     minchaGedolaBaalHatanya() {
         return this.getShaahZmanisBaalHatanya(6.5);
     }
     /**
      * This method returns the time of _mincha ketana_. This is the preferred earliest time to pray
-     * _mincha_ in the opinion of the <a href="https://en.wikipedia.org/wiki/Maimonides">Rambam</a> and others.
-     * For more information on this see the documentation on {@link minchaGedolaBaalHatanya() _mincha gedola_}.
-     * This is calculated as 9.5 sea level solar hours after {@link getSunriseBaalHatanya
-     * _netz amiti_ (sunrise)}. This calculation is calculated based on the opinion of the Baal Hatanya that the
-     * day is calculated from sunrise to sunset. This returns the time 9.5 * after
-     * _netz amiti_ (sunrise).
-     *
-     * @return the <code>Date</code> of the time of _mincha ketana_. If the calculation can't be computed such as
-     *         in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it
-     *         does not set, a `null` will be returned.
+     * _mincha_ in the opinion of the [Rambam](https://en.wikipedia.org/wiki/Maimonides) and others.
+     * For more information on this see the documentation on {@link minchaGedolaBaalHatanya | _mincha gedola_}.
+     * This is calculated as 9.5 sea level solar hours after _netz amiti_ (sunrise), based on the opinion of
+     * the Baal Hatanya that the day is calculated from _netz amiti_ (sunrise) to _shkiah amiti_ (sunset).
+     *
+     * @return the `Date` of the time of _mincha ketana_. If the calculation can't be computed, such as
+     *         in the Arctic Circle where there is at least one day a year where the sun does not rise and one where it
+     *         does not set, an `Invalid Date` will be returned.
      */
     minchaKetanaBaalHatanya() {
         return this.getShaahZmanisBaalHatanya(9.5);
     }
     /**
-     * This method returns the time of _plag hamincha_. This is calculated as 10.75 hours after sunrise. This
-     * calculation is based on the opinion of the Baal Hatanya that the day is calculated
-     * from sunrise to sunset. This returns the time 10.75 * {@link getShaahZmanisBaalHatanya()} after
-     * {@link getSunriseBaalHatanya() _netz amiti_ (sunrise)}.
+     * This method returns the time of _plag hamincha_. This is calculated as 10.75 sea level solar hours
+     * after _netz amiti_ (sunrise), based on the opinion of the Baal Hatanya that the day is calculated
+     * from _netz amiti_ (sunrise) to _shkiah amiti_ (sunset).
      *
-     * @return the <code>Date</code> of the time of _plag hamincha_. If the calculation can't be computed such as
-     *         in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it
-     *         does not set, a `null` will be returned.
+     * @return the `Date` of the time of _plag hamincha_ according to the Baal Hatanya. If the calculation
+     *         can't be computed, such as in the Arctic Circle where there is at least one day a year where the sun does
+     *         not rise and one where it does not set, an `Invalid Date` will be returned.
      */
     plagHaminchaBaalHatanya() {
         return this.getShaahZmanisBaalHatanya(10.75);
     }
     /**
-     * A method that returns _tzais_ (nightfall) when the sun is 6&deg; below the western geometric horizon
-     * (90&deg;) after {@link getSunset() sunset}. For information on the source of this calculation see
-     * {@link ZENITH_6_DEGREES}.
+     * A method that returns _tzais_ (nightfall) when the sun is 6° below the western geometric horizon
+     * (90°) after {@link sunset}. This is the time the Baal Hatanya calls _shkiah amiti_ plus the
+     * interval it takes the sun to descend a further 6°.
      *
-     * @return The <code>Date</code> of nightfall. If the calculation can't be computed such as northern and southern
-     *         locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach
-     *         low enough below the horizon for this calculation, a `null` will be returned.   * @see ZENITH_6_DEGREES
+     * @return the `Date` of nightfall. If the calculation can't be computed, such as in northern and southern
+     *         locations — even south of the Arctic Circle and north of the Antarctic Circle — where the sun may not
+     *         reach low enough below the horizon for this calculation, an `Invalid Date` will be returned.
      */
     tzaisBaalHatanya() {
         return this.timeAtAngle(6, false);
@@ -10117,6 +10615,9 @@ class Zmanim {
     /**
      * Uses timeFormat to return a date like '20:34'.
      * Returns `XX:XX` if the date is invalid.
+     * @param dt the time to format
+     * @param timeFormat formatter to use, e.g. from
+     *   {@link Location.getTimeFormatter}
      */
     static formatTime(dt, timeFormat) {
         if (isNaN(dt.getTime())) {
@@ -10226,7 +10727,7 @@ class Zmanim {
      * (for example `2024-09-22T20:07`), this function would return a
      * Hebrew date of `20th of Elul, 5784`.
      * @example
-     * const {GeoLocation, Zmanim, HDate} = require('@hebcal/core');
+     * import {GeoLocation, Zmanim, HDate} from '@hebcal/core';
      * const latitude = 48.85341;
      * const longitude = 2.3488;
      * const timezone = 'Europe/Paris';
@@ -10365,14 +10866,14 @@ function yearType(hyear) {
  * Israel and the Diaspora diverge in some years when the 8th day of Pesach
  * or the 2nd day of Shavuot fall on Shabbat).
  *
- * Prefer {@link getSedra} (or {@link HebrewCalendar.getSedra}) over
+ * Prefer {@link getSedra} over
  * calling this constructor directly, since both cache their results.
  *
  * @example
  * import {Sedra, HDate, months} from '@hebcal/core';
  * const sedra = new Sedra(5784, false);
  * const result = sedra.lookup(new HDate(15, months.CHESHVAN, 5784));
- * console.log(result.parsha); // ['Lech-Lecha']
+ * console.log(result.parsha); // ['Vayera']
  */
 class Sedra {
     /**
@@ -10419,15 +10920,20 @@ class Sedra {
      * @example
      * import {Sedra} from '@hebcal/core';
      * const sedra = new Sedra(5784, false);
-     * sedra.find('Noach')?.toString();         // '15 Cheshvan 5784'
-     * sedra.find(1)?.toString();                // same, by 0-based index
-     * sedra.find('Matot-Masei')?.toString();   // null in 5784 — read separately
-     * sedra.find(['Matot', 'Masei']);          // also null in 5784
+     * sedra.find('Noach')?.toString();        // '6 Cheshvan 5784'
+     * sedra.find(1)?.toString();              // '6 Cheshvan 5784', by 0-based index
+     * // Matot and Masei are doubled in 5784, so the pair has a date...
+     * sedra.find('Matot-Masei')?.toString();  // '28 Tamuz 5784'
+     * sedra.find(['Matot', 'Masei'])?.toString(); // '28 Tamuz 5784'
+     * // ...but neither half is read on its own that year:
+     * sedra.find('Matot');                    // null
      * @param parsha if a `string`, specified with Sephardic transliterations
      *  like `'Noach'` or `'Matot-Masei'`. If an array, must be a 1- or 2-element
      *  array such as `['Noach']` or `['Matot', 'Masei']`. If a `number`, should
      *  be a 0-based parsha index (`0` for Bereshit, `1` for Noach) or a negative
-     *  number for a doubled parsha (e.g. `-21` for Vayakhel-Pekudei)
+     *  number for a doubled parsha (e.g. `-21` for Vayakhel-Pekudei).
+     *  Note that this index is 0-based, unlike {@link SedraResult.num} which
+     *  is 1-based.
      */
     find(parsha) {
         if (typeof parsha === 'number') {
@@ -10490,12 +10996,19 @@ class Sedra {
      * will return the date of `'Matot'` alone.
      * @example
      * import {Sedra} from '@hebcal/core';
+     * // Matot and Masei are doubled in 5784, so each half resolves to the
+     * // date of the combined reading:
      * const sedra = new Sedra(5784, false);
-     * // Matot-Masei is split in 5784; both individual halves resolve:
-     * sedra.findContaining('Matot')?.toString();        // '22 Tamuz 5784'
-     * sedra.findContaining('Masei')?.toString();        // '29 Tamuz 5784'
-     * // Asking for the doubled name returns the date of the first half:
-     * sedra.findContaining('Matot-Masei')?.toString();  // '22 Tamuz 5784'
+     * sedra.findContaining('Matot')?.toString();        // '28 Tamuz 5784'
+     * sedra.findContaining('Masei')?.toString();        // '28 Tamuz 5784'
+     * @example
+     * import {Sedra} from '@hebcal/core';
+     * // They are read separately in 5795, so each half has its own date, and
+     * // asking for the doubled name returns the date of the first half:
+     * const sedra = new Sedra(5795, false);
+     * sedra.findContaining('Matot')?.toString();        // '21 Tamuz 5795'
+     * sedra.findContaining('Masei')?.toString();        // '28 Tamuz 5795'
+     * sedra.findContaining('Matot-Masei')?.toString();  // '21 Tamuz 5795'
      */
     findContaining(parsha) {
         const hdate = this.find(parsha);
@@ -10577,11 +11090,11 @@ class Sedra {
      * @example
      * import {Sedra, HDate, months} from '@hebcal/core';
      * const sedra = new Sedra(5784, false);
-     * // A weekday — returns the upcoming Shabbat's reading
-     * const result = sedra.lookup(new HDate(13, months.CHESHVAN, 5784));
+     * // A Friday — returns the upcoming Shabbat's reading
+     * const result = sedra.lookup(new HDate(12, months.CHESHVAN, 5784));
      * console.log(result.parsha); // ['Lech-Lecha']
      * console.log(result.chag);   // false
-     * console.log(result.hdate.toString()); // '15 Cheshvan 5784' (Saturday)
+     * console.log(result.hdate.toString()); // '13 Cheshvan 5784' (Saturday)
      * @param hd Hebrew date or R.D. days
      */
     lookup(hd) {
@@ -10633,6 +11146,16 @@ class Sedra {
      *
      * For the Tishrei weekdays before Sukkot or Simchat Torah, the weekday
      * reading is *Vezot Haberakhah* even though it is not read on Shabbat.
+     * @example
+     * import {Sedra, HDate, months} from '@hebcal/core';
+     * const sedra = new Sedra(5784, false);
+     * // Monday 8 Cheshvan — begins the upcoming Shabbat's parsha
+     * sedra.lookupWeekday(new HDate(8, months.CHESHVAN, 5784))?.parsha; // ['Lech-Lecha']
+     * // Tuesday is neither Monday nor Thursday
+     * sedra.lookupWeekday(new HDate(9, months.CHESHVAN, 5784)); // undefined
+     * // Thursday 17 Nisan — the upcoming Shabbat is Chol ha-Moed Pesach,
+     * // so the next regular parsha is returned instead
+     * sedra.lookupWeekday(new HDate(17, months.NISAN, 5784))?.parsha; // ['Achrei Mot']
      * @param hd Hebrew date or R.D. days
      */
     lookupWeekday(hd) {
@@ -10908,7 +11431,7 @@ const sedraCache = new QuickLRU({ maxSize: 120 });
  * 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); // ['Lech-Lecha']
+ * console.log(parsha); // ['Vayera']
  * @param hyear Hebrew year
  * @param il Use Israel sedra schedule (`false` for Diaspora)
  */
@@ -11002,8 +11525,6 @@ const SOF_ZMAN_ACHILAT_CHAMETZ = 'Finish eating chametz';
 const YIZKOR$1 = 'Yizkor';
 /**
  * Transliterated names of holidays, used by `Event.getDesc()`
- * @readonly
- * @enum {string}
  */
 const holidayDesc = {
     /** Asara B'Tevet */
@@ -11561,7 +12082,7 @@ const staticModernHolidays = [
 /**
  * Represents a built-in holiday like Pesach, Purim or Tu BiShvat.
  *
- * Most holiday-related events emitted by {@link HebrewCalendar.calendar}
+ * Most holiday-related events emitted by {@link calendar}
  * are instances of `HolidayEvent` or one of its subclasses
  * ({@link ChanukahEvent}, {@link AsaraBTevetEvent},
  * {@link RoshHashanaEvent}, {@link RoshChodeshEvent}).
@@ -11621,6 +12142,10 @@ class HolidayEvent extends Event {
             this.urlDateSuffix();
         return this.getFlags() & flags.IL_ONLY ? url + '?i=on' : url;
     }
+    /**
+     * The date portion of {@link url}. For most holidays this is just the
+     * Gregorian year; subclasses override it when a year alone is ambiguous.
+     */
     urlDateSuffix() {
         const year = this.greg().getFullYear();
         return String(year);
@@ -11682,6 +12207,7 @@ class HolidayEvent extends Event {
  * we subclass HolidayEvent to generate the correct URL.
  */
 class AsaraBTevetEvent extends HolidayEvent {
+    /** Full `YYYYMMDD` date, since the Gregorian year alone is ambiguous here */
     urlDateSuffix() {
         const isoDate = isoDateString(this.greg());
         return isoDate.replaceAll('-', '');
@@ -11729,7 +12255,7 @@ class ChanukahEvent extends HolidayEvent {
 /** Represents Rosh Hashana, the Jewish New Year */
 class RoshHashanaEvent extends HolidayEvent {
     /**
-     * @private
+     * Normally created by {@link calendar} rather than directly.
      * @param date Hebrew date event occurs
      * @param hyear Hebrew year
      * @param mask optional holiday flags
@@ -11782,7 +12308,8 @@ const ykk = 'Yom Kippur Katan';
 /** YKK is minor day of atonement on the day preceeding each Rosh Chodesh */
 class YomKippurKatanEvent extends HolidayEvent {
     /**
-     * @private
+     * Normally created by {@link calendar} (via
+     * `options.yomKippurKatan`) rather than directly.
      * @param date Hebrew date event occurs
      * @param nextMonthName name of the upcoming month
      */
@@ -12107,7 +12634,7 @@ function getBirkatHaChama(year) {
  *
  * Includes Rosh Chodesh, fasts, special Shabbatot, modern holidays, etc.,
  * but does not generate candle-lighting times, Torah readings, or Omer days.
- * Use {@link HebrewCalendar.calendar} for those.
+ * Use {@link calendar} for those.
  * @example
  * import {getHolidaysForYearArray} from '@hebcal/core';
  * const events = getHolidaysForYearArray(5784, false);
@@ -12143,9 +12670,12 @@ function isTomorrowShabbosOrYomTov(dow, events) {
     return false;
 }
 /**
- * Returns true if it is <em>Shabbos</em> or if it is a <em>Yom Tov</em> day that has a <em>melacha</em> (work)  prohibition.
+ * Returns true if it is _Shabbos_ or if it is a _Yom Tov_ day that has a
+ * _melacha_ (work) prohibition.
  *
- * @return if the day is a <em>Yom Tov</em> that is <em>assur bemlacha</em> or <em>Shabbos</em>
+ * @param dow day of week, where `6` is Shabbos
+ * @param events events occurring on the day
+ * @return `true` if the day is a _Yom Tov_ that is _assur bemlacha_, or _Shabbos_
  */
 function isTodayAssurBemelacha(dow, events) {
     if (dow === 6) {
@@ -12284,7 +12814,7 @@ const EREV$1 = flags.EREV;
  * isFastDay(new HDate(10, months.TISHREI, 5784)); // true  (Yom Kippur)
  * isFastDay(new HDate(11, months.TISHREI, 5784)); // false
  * @param date Hebrew Date, Gregorian date, or absolute R.D. day number
- * @param il use the Israeli schedule for holidays
+ * @param il optional; use the Israeli schedule for holidays (default Diaspora)
  * @return `true` if the date is a major or minor fast day
  */
 function isFastDay(date, il) {
@@ -12310,7 +12840,14 @@ const CANDLE_LIGHTING = holidayDesc.CANDLE_LIGHTING;
  */
 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);
@@ -12362,10 +12899,11 @@ class TimedEvent extends Event {
 /**
  * Candle-lighting event for the eve of Shabbat or a Yom Tov.
  *
- * Generated by {@link HebrewCalendar.calendar} when `options.candlelighting`
+ * Generated by {@link calendar} when `options.candlelighting`
  * is `true` and `options.location` is provided. By default candle lighting
- * occurs 18 minutes before sundown (40 minutes in Jerusalem; 30 minutes in
- * Haifa and Zikhron Ya'akov), configurable via `options.candleLightingMins`.
+ * 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) {
@@ -12378,7 +12916,7 @@ class CandleLightingEvent extends TimedEvent {
 /**
  * Havdalah event marking the end of Shabbat or a Yom Tov.
  *
- * Generated by {@link HebrewCalendar.calendar} when `options.candlelighting`
+ * 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
@@ -12517,7 +13055,7 @@ function makeFastEndTime(zmanim, isTishaBav, options) {
  *
  * Wraps an underlying fast-day {@link HolidayEvent} and (when computable
  * for the given location) exposes a "Fast begins" and "Fast ends"
- * {@link TimedEvent}. Generated by {@link HebrewCalendar.calendar} when
+ * {@link TimedEvent}. Generated by {@link calendar} when
  * `options.candlelighting` is `true` and `options.location` is provided.
  *
  * - Minor fasts (including Yom Kippur Katan) begin at *Alot HaShachar*
@@ -12611,7 +13149,22 @@ function makeTimedEvent(ev, time, desc, options) {
     const hd = ev.getDate();
     return new TimedEvent(hd, desc, ev.getFlags(), time, location, ev, options);
 }
+/**
+ * A Chanukah candle-lighting event that carries a specific time of day.
+ *
+ * Generated by {@link calendar} when both `options.candlelighting`
+ * and `options.location` are set. On weekdays the time is Bein HaShmashos
+ * (13.5 minutes before the sun is 7.083° below the horizon in the evening);
+ * on Friday it is regular candle-lighting time, and on Saturday night it is
+ * regular Havdalah time.
+ */
 class TimedChanukahEvent extends ChanukahEvent {
+    /**
+     * Normally created by {@link calendar} rather than directly.
+     * @param ev the untimed Chanukah event this is derived from
+     * @param eventTime time at which candles are lit
+     * @param location location used to format the time
+     */
     constructor(ev, eventTime, location) {
         super(ev.getDate(), ev.getDesc(), ev.getFlags(), ev.chanukahDay);
         this.eventTime = Zmanim.roundTime(eventTime);
@@ -12639,7 +13192,69 @@ function makeWeekdayChanukahCandleLighting(ev, options) {
     return new TimedChanukahEvent(ev, candleLightingTime, location);
 }
 
-const ps67lines$1=["אֱלֹהִים יְחָנֵּנוּ וִיבָרְכֵנוּ יָאֵר־פָּנָיו אִתָּנוּ סֶלָה","לָדַעַת בָּאָרֶץ דַּרְכֶּךָ בְּכָל־גּוֹיִם יְשׁוּעָתֶךָ","יוֹדוּךָ עַמִּים אֱלֹהִים יוֹדוּךָ עַמִּים כֻּלָּם","יִשְׂמְחוּ וִירַנְּנוּ לְאֻמִּים כִּי־תִשְׁפֹּט עַמִּים מִישׁוֹר וּלְאֻמִּים בָּאָרֶץ תַּנחֵם סֶלָה","יוֹדוּךָ עַמִּים אֱלֹהִים יוֹדוּךָ עַמִּים כֻּלָּם","אֶרֶץ נָתְנָה יְבוּלָהּ יְבָרְכֵנוּ אֱלֹהִים אֱלֹהֵינוּ","יְבָרְכֵנוּ אֱלֹהִים וְיִירְאוּ אוֹתוֹ כָּל־אַפְסֵי־אָרֶץ"];const lamnatzeachLetters$1="ישמחווירננולאמיםכיתשפוטעמיםמישורולאמיםבארץתנחםסלה";const anaBekoach$1=["אָנָּא","בְּכֹחַ","גְּדֻלַּת","יְמִינְךָ","תַּתִּיר","צְרוּרָה","אב״ג ית״ץ","קַבֵּל","רִנַּת","עַמְּךָ","שַׂגְּבֵנוּ","טַהֲרֵנוּ","נוֹרָא","קר״ע שט״ן","נָא","גִבּוֹר","דּוֹרְשֵׁי","יִחוּדְךָ","כְּבָבַת","שָׁמְרֵם","נג״ד יכ״ש","בָּרְכֵם","טַהֲרֵם","רַחֲמֵי","צִדְקָתְךָ","תָּמִיד","גָּמְלֵם","בט״ר צת״ג","חֲסִין","קָדוֹשׁ","בְּרֹב","טוּבְךָ","נַהֵל","עֲדָתֶךָ","חק״ב תנ״ע","יָחִיד","גֵּאֶה","לְעַמְּךָ","פְּנֵה","זוֹכְרֵי","קְדֻשָּׁתֶךָ","יג״ל פז״ק","שַׁוְעָתֵנוּ","קַבֵּל","וּשְׁמַע","צַעֲקָתֵנוּ","יוֹדֵעַ","תַּעֲלוּמוֹת","שק״ו צי״ת"];var sefira = {ps67lines:ps67lines$1,lamnatzeachLetters:lamnatzeachLetters$1,anaBekoach:anaBekoach$1};
+var sefira = {
+    "ps67lines": [
+        "אֱלֹהִים יְחָנֵּנוּ וִיבָרְכֵנוּ יָאֵר־פָּנָיו אִתָּנוּ סֶלָה",
+        "לָדַעַת בָּאָרֶץ דַּרְכֶּךָ בְּכָל־גּוֹיִם יְשׁוּעָתֶךָ",
+        "יוֹדוּךָ עַמִּים אֱלֹהִים יוֹדוּךָ עַמִּים כֻּלָּם",
+        "יִשְׂמְחוּ וִירַנְּנוּ לְאֻמִּים כִּי־תִשְׁפֹּט עַמִּים מִישׁוֹר וּלְאֻמִּים בָּאָרֶץ תַּנחֵם סֶלָה",
+        "יוֹדוּךָ עַמִּים אֱלֹהִים יוֹדוּךָ עַמִּים כֻּלָּם",
+        "אֶרֶץ נָתְנָה יְבוּלָהּ יְבָרְכֵנוּ אֱלֹהִים אֱלֹהֵינוּ",
+        "יְבָרְכֵנוּ אֱלֹהִים וְיִירְאוּ אוֹתוֹ כָּל־אַפְסֵי־אָרֶץ"
+    ],
+    "lamnatzeachLetters": "ישמחווירננולאמיםכיתשפוטעמיםמישורולאמיםבארץתנחםסלה",
+    "anaBekoach": [
+        "אָנָּא",
+        "בְּכֹחַ",
+        "גְּדֻלַּת",
+        "יְמִינְךָ",
+        "תַּתִּיר",
+        "צְרוּרָה",
+        "אב״ג ית״ץ",
+        "קַבֵּל",
+        "רִנַּת",
+        "עַמְּךָ",
+        "שַׂגְּבֵנוּ",
+        "טַהֲרֵנוּ",
+        "נוֹרָא",
+        "קר״ע שט״ן",
+        "נָא",
+        "גִבּוֹר",
+        "דּוֹרְשֵׁי",
+        "יִחוּדְךָ",
+        "כְּבָבַת",
+        "שָׁמְרֵם",
+        "נג״ד יכ״ש",
+        "בָּרְכֵם",
+        "טַהֲרֵם",
+        "רַחֲמֵי",
+        "צִדְקָתְךָ",
+        "תָּמִיד",
+        "גָּמְלֵם",
+        "בט״ר צת״ג",
+        "חֲסִין",
+        "קָדוֹשׁ",
+        "בְּרֹב",
+        "טוּבְךָ",
+        "נַהֵל",
+        "עֲדָתֶךָ",
+        "חק״ב תנ״ע",
+        "יָחִיד",
+        "גֵּאֶה",
+        "לְעַמְּךָ",
+        "פְּנֵה",
+        "זוֹכְרֵי",
+        "קְדֻשָּׁתֶךָ",
+        "יג״ל פז״ק",
+        "שַׁוְעָתֵנוּ",
+        "קַבֵּל",
+        "וּשְׁמַע",
+        "צַעֲקָתֵנוּ",
+        "יוֹדֵעַ",
+        "תַּעֲלוּמוֹת",
+        "שק״ו צי״ת"
+    ]
+};
 
 const sefirot = {
     en: {
@@ -12841,7 +13456,7 @@ const lamnatzeachLetters = sefira.lamnatzeachLetters.split('');
  * const ev = new OmerEvent(new HDate(16, months.NISAN, 5784), 1);
  * ev.render('en');        // '1st day of the Omer'
  * ev.render('he');        // 'א׳ בָּעוֹמֶר'
- * ev.sefira('translit');  // 'Chesed shebChesed'
+ * ev.sefira('translit');  // "Chesed sheb'Chesed"
  * ev.getTodayIs('en');    // 'Today is 1 day of the Omer'
  */
 class OmerEvent extends Event {
@@ -12936,17 +13551,33 @@ class OmerEvent extends Event {
         }
         return String.fromCodePoint(codePoint);
     }
+    /**
+     * Number of *completed* weeks of the Omer. On day 7 this returns `1`; on
+     * day 8 it also returns `1`, because the second week is still in progress.
+     * Pair with {@link getDaysWithinWeeks} to render "N weeks and M days".
+     */
     getWeeks() {
         const day7 = this.daysWithinWeeks === 7;
         return day7 ? this.weekNumber : this.weekNumber - 1;
     }
+    /**
+     * Day within the current week, from `1` through `7`.
+     */
     getDaysWithinWeeks() {
         return this.daysWithinWeeks;
     }
     /**
      * Returns a sentence with that evening's omer count
-     * @returns a string such as `Today is 10 days, which is 1 week and 3 days of the Omer`
-     *  or `הַיוֹם עֲשָׂרָה יָמִים, שְׁהֵם שָׁבוּעַ אֶחָד וְשְׁלוֹשָׁה יָמִים לָעוֹמֶר`
+     * @example
+     * import {OmerEvent, HDate, months} from '@hebcal/core';
+     * const ev = new OmerEvent(new HDate(25, months.NISAN, 5784), 10);
+     * ev.getTodayIs('en');
+     * // => 'Today is 10 days, which are 1 week and 3 days of the Omer'
+     * ev.getTodayIs('he');
+     * // => 'הַיּוֹם עֲשָׂרָה יָמִים, שֶׁהֵם שָׁבֽוּעַ אֶחָד וּשְׁלוֹשָׁה יָמִים לָעֽוֹמֶר'
+     * @param locale locale name; Hebrew locales (`he`, `he-x-NoNikud`) produce
+     *  the Hebrew formula, anything else produces English. Defaults to `en`
+     *  when empty.
      */
     getTodayIs(locale) {
         locale = (locale || 'en').toLowerCase();
@@ -13160,6 +13791,14 @@ function renderParshaName(parsha, locale) {
  * `@hebcal/leyning` when the display title and exact Torah readings are needed.
  */
 class ParshaEvent extends Event {
+    /**
+     * Normally created by {@link calendar} (via `options.sedrot`)
+     * rather than directly.
+     * @param parsha result from {@link Sedra.lookup}
+     * @throws {TypeError} if called with anything other than exactly one argument
+     * @throws {TypeError} if `parsha` is not a valid {@link SedraResult} — it must
+     *   have an `HDate` and one or two parsha names
+     */
     constructor(parsha) {
         // eslint-disable-next-line prefer-rest-params
         if (arguments.length !== 1) {
@@ -13196,6 +13835,10 @@ class ParshaEvent extends Event {
         const url = 'https://www.hebcal.com/sedrot/' + urlFriendly(this.basename()) + '-' + dt;
         return this.p.il ? url + '?i=on' : url;
     }
+    /**
+     * The date portion of {@link url}, as `YYYYMMDD` — a parsha name recurs every
+     * year, so the full date is needed to identify the reading.
+     */
     urlDateSuffix() {
         const isoDate = isoDateString(this.greg());
         return isoDate.replaceAll('-', '');
@@ -13217,8 +13860,8 @@ class ParshaEvent extends Event {
  * @example
  * import {parshaYear} from '@hebcal/core';
  * const events = parshaYear(5784, false);
- * events[0].render('en'); // 'Parashat Vayeilech'
- * events[0].getDate().toString(); // '4 Tishrei 5784'
+ * events[0].render('en'); // 'Parashat Ha’azinu'
+ * events[0].getDate().toString(); // '8 Tishrei 5784'
  * @param year Hebrew year
  * @param il Israel (false for Diaspora)
  * @returns an array of `ParshaEvent` occurring on Saturdays that contain a regular
@@ -13239,183 +13882,6 @@ function parshaYear(year, il) {
     return events;
 }
 
-const mevarchimChodeshStr = 'Shabbat Mevarchim Chodesh';
-/** Represents Mevarchim haChodesh, the announcement of the new month */
-class MevarchimChodeshEvent extends Event {
-    /**
-     * Constructs Mevarchim haChodesh event
-     * @param date Hebrew date event occurs
-     * @param monthName Hebrew month name (not translated)
-     * @param [memo]
-     * @param locale Optional locale name
-     */
-    constructor(date, monthName, memo, locale) {
-        super(date, `${mevarchimChodeshStr} ${monthName}`, flags.SHABBAT_MEVARCHIM);
-        this.monthName = Locale.gettext(monthName, locale);
-        if (memo) {
-            this.memo = memo;
-        }
-        else {
-            const hyear = date.getFullYear();
-            const hmonth = date.getMonth();
-            const monNext = hmonth === HDate.monthsInYear(hyear) ? months.NISAN : hmonth + 1;
-            const molad = new Molad(hyear, monNext);
-            this.memo = molad.render('en', { hour12: false });
-        }
-    }
-    basename() {
-        return this.getDesc();
-    }
-    /**
-     * Returns (translated) description of this event
-     * @param [locale] Optional locale name (defaults to empty locale)
-     */
-    render(locale) {
-        const monthName0 = Locale.gettext(this.monthName, locale);
-        const monthName = smartApostrophe(monthName0);
-        return Locale.gettext(mevarchimChodeshStr, locale) + ' ' + monthName;
-    }
-    /**
-     * Returns (translated) description of this event
-     * @param [locale] Optional locale name (defaults to empty locale)
-     */
-    renderBrief(locale) {
-        const str = this.render(locale);
-        const space = str.indexOf(' ');
-        return str.substring(space + 1);
-    }
-}
-
-const cals = new Map();
-/**
- * Plug-in registry for daily learning calendars such as Daf Yomi (Bavli),
- * Yerushalmi Yomi, Mishna Yomi, Nach Yomi, etc.
- *
- * `@hebcal/core` itself contains no learning schedules — they are provided
- * by the {@link https://github.com/hebcal/hebcal-learning @hebcal/learning}
- * package, which calls {@link DailyLearning.addCalendar} on import. After
- * `@hebcal/learning` is loaded, `HebrewCalendar.calendar()` will emit
- * learning events when the corresponding `options.dailyLearning` flag is set.
- *
- * @example
- * import '@hebcal/learning';
- * import {DailyLearning, HDate} from '@hebcal/core';
- *
- * const ev = DailyLearning.lookup('dafYomi', new HDate(), false);
- * console.log(ev?.render('en')); // e.g. 'Berakhot 2'
- */
-class DailyLearning {
-    /**
-     * Registers a new learning calendar.
-     *
-     * The provided function is called whenever a caller asks for an event
-     * from this calendar; if no learning occurs that day (e.g. the date is
-     * before the cycle's start) it should return `null`.
-     * @example
-     * DailyLearning.addCalendar(
-     *   'myCalendar',
-     *   (hd, il) => new Event(hd, 'Today\'s learning', 0),
-     *   new HDate(1, 'Tishrei', 5780),
-     * );
-     * @param name case insensitive
-     * @param calendar a function that returns an `Event` or `null`
-     * @param startDate the first date for which this calendar is valid
-     */
-    static addCalendar(name, calendar, startDate) {
-        if (typeof calendar !== 'function') {
-            throw new TypeError(`Invalid calendar function: ${calendar}`);
-        }
-        cals.set(name.toLowerCase(), {
-            fn: calendar,
-            startDate: startDate,
-        });
-    }
-    /**
-     * Returns the learning event for the given date from the named calendar,
-     * or `null` if there is no learning that day (or the named calendar is
-     * not registered).
-     * @example
-     * import '@hebcal/learning';
-     * import {DailyLearning, HDate} from '@hebcal/core';
-     * DailyLearning.lookup('dafYomi', new HDate(2024, 1, 15), false);
-     * @param name case insensitive
-     * @param hd Hebrew Date
-     * @param il true for Israel, false for Diaspora
-     */
-    static lookup(name, hd, il) {
-        const cal = cals.get(name.toLowerCase());
-        if (typeof cal === 'object') {
-            return cal.fn(hd, il);
-        }
-        return null;
-    }
-    /**
-     * Returns the first Hebrew date for which the named learning calendar
-     * is valid (as registered by {@link addCalendar}), or `undefined` if the
-     * calendar was not registered with a start date or is not registered at all.
-     * @param name case insensitive
-     */
-    static getStartDate(name) {
-        const cal = cals.get(name.toLowerCase());
-        if (typeof cal === 'object') {
-            return cal.startDate;
-        }
-        return undefined;
-    }
-    /**
-     * Returns `true` if a learning calendar with the given name has been
-     * registered via {@link addCalendar}.
-     * @param name case insensitive
-     */
-    static has(name) {
-        return cals.has(name.toLowerCase());
-    }
-    /**
-     * Returns the (lower-cased) names of all currently-registered learning
-     * calendars.
-     */
-    static getCalendars() {
-        return Array.from(cals.keys());
-    }
-}
-
-const NONE = 0;
-const HALF = 1;
-const WHOLE = 2;
-/**
- * @private
- */
-function hallel_(events, hdate) {
-    const abs = hdate.abs();
-    for (const ev of events) {
-        const hd = ev.getDate();
-        if (hd.abs() !== abs) {
-            continue;
-        }
-        const desc = ev.getDesc();
-        const month = hd.getMonth();
-        const mday = hd.getDate();
-        const mask = ev.getFlags();
-        if (desc.startsWith('Chanukah') ||
-            desc.startsWith('Shavuot') ||
-            desc.startsWith('Sukkot') ||
-            (month === months.NISAN &&
-                (mday === 15 || mday === 16) &&
-                mask & flags.CHAG) || // Pesach
-            desc === holidayDesc.YOM_HAATZMA_UT ||
-            desc === holidayDesc.YOM_YERUSHALAYIM) {
-            return WHOLE;
-        }
-        if (mask & flags.ROSH_CHODESH ||
-            (desc.startsWith('Pesach') &&
-                desc !== holidayDesc.PESACH_I &&
-                desc !== holidayDesc.PESACH_II)) {
-            return HALF;
-        }
-    }
-    return NONE;
-}
-
 const TISHREI = months.TISHREI;
 /**
  * Gets the R.D. days for a number, Date, or HDate
@@ -13523,6 +13989,147 @@ function startEndHebrew(theMonth, theYear, numYears) {
     return [startAbs, endAbs];
 }
 
+const cals = new Map();
+/**
+ * Plug-in registry for daily learning calendars such as Daf Yomi (Bavli),
+ * Yerushalmi Yomi, Mishna Yomi, Nach Yomi, etc.
+ *
+ * `@hebcal/core` itself contains no learning schedules — they are provided
+ * by the {@link https://github.com/hebcal/hebcal-learning @hebcal/learning}
+ * package, which calls {@link DailyLearning.addCalendar} on import. After
+ * `@hebcal/learning` is loaded, `calendar()` will emit
+ * learning events when the corresponding `options.dailyLearning` flag is set.
+ *
+ * @example
+ * import '@hebcal/learning';
+ * import {DailyLearning, HDate} from '@hebcal/core';
+ *
+ * const ev = DailyLearning.lookup('dafYomi', new HDate(), false);
+ * console.log(ev?.render('en')); // e.g. 'Daf Yomi: Berakhot 2'
+ */
+class DailyLearning {
+    /**
+     * Registers a new learning calendar.
+     *
+     * The provided function is called whenever a caller asks for an event
+     * from this calendar; if no learning occurs that day (e.g. the date is
+     * before the cycle's start) it should return `null`.
+     * @example
+     * DailyLearning.addCalendar(
+     *   'myCalendar',
+     *   (hd, il) => new Event(hd, 'Today\'s learning', 0),
+     *   new HDate(1, 'Tishrei', 5780),
+     * );
+     * @param name case insensitive
+     * @param calendar a function that returns an `Event` or `null`
+     * @param startDate the first date for which this calendar is valid
+     */
+    static addCalendar(name, calendar, startDate) {
+        if (typeof calendar !== 'function') {
+            throw new TypeError(`Invalid calendar function: ${calendar}`);
+        }
+        cals.set(name.toLowerCase(), {
+            fn: calendar,
+            startDate: startDate,
+        });
+    }
+    /**
+     * Returns the learning event for the given date from the named calendar,
+     * or `null` if there is no learning that day (or the named calendar is
+     * not registered).
+     * @example
+     * import '@hebcal/learning';
+     * import {DailyLearning, HDate, months} from '@hebcal/core';
+     * DailyLearning.lookup('dafYomi', new HDate(15, months.CHESHVAN, 5784), false);
+     * @param name case insensitive
+     * @param hd Hebrew Date
+     * @param il true for Israel, false for Diaspora
+     */
+    static lookup(name, hd, il) {
+        const cal = cals.get(name.toLowerCase());
+        if (typeof cal === 'object') {
+            return cal.fn(hd, il);
+        }
+        return null;
+    }
+    /**
+     * Returns the first Hebrew date for which the named learning calendar
+     * is valid (as registered by {@link addCalendar}), or `undefined` if the
+     * calendar was not registered with a start date or is not registered at all.
+     * @param name case insensitive
+     */
+    static getStartDate(name) {
+        const cal = cals.get(name.toLowerCase());
+        if (typeof cal === 'object') {
+            return cal.startDate;
+        }
+        return undefined;
+    }
+    /**
+     * Returns `true` if a learning calendar with the given name has been
+     * registered via {@link addCalendar}.
+     * @param name case insensitive
+     */
+    static has(name) {
+        return cals.has(name.toLowerCase());
+    }
+    /**
+     * Returns the (lower-cased) names of all currently-registered learning
+     * calendars.
+     */
+    static getCalendars() {
+        return Array.from(cals.keys());
+    }
+}
+
+const mevarchimChodeshStr = 'Shabbat Mevarchim Chodesh';
+/** Represents Mevarchim haChodesh, the announcement of the new month */
+class MevarchimChodeshEvent extends Event {
+    /**
+     * Constructs Mevarchim haChodesh event
+     * @param date Hebrew date event occurs
+     * @param monthName Hebrew month name (not translated)
+     * @param memo text for the event memo. When falsy, a memo announcing the
+     *   molad of the upcoming month is generated automatically
+     * @param locale Optional locale name
+     */
+    constructor(date, monthName, memo, locale) {
+        super(date, `${mevarchimChodeshStr} ${monthName}`, flags.SHABBAT_MEVARCHIM);
+        this.monthName = Locale.gettext(monthName, locale);
+        if (memo) {
+            this.memo = memo;
+        }
+        else {
+            const hyear = date.getFullYear();
+            const hmonth = date.getMonth();
+            const monNext = hmonth === HDate.monthsInYear(hyear) ? months.NISAN : hmonth + 1;
+            const molad = new Molad(hyear, monNext);
+            this.memo = molad.render('en', { hour12: false });
+        }
+    }
+    basename() {
+        return this.getDesc();
+    }
+    /**
+     * Returns (translated) description of this event
+     * @param [locale] Optional locale name (defaults to empty locale)
+     */
+    render(locale) {
+        const monthName0 = Locale.gettext(this.monthName, locale);
+        const monthName = smartApostrophe(monthName0);
+        return Locale.gettext(mevarchimChodeshStr, locale) + ' ' + monthName;
+    }
+    /**
+     * Returns (translated) description of this event
+     * @param [locale] Optional locale name (defaults to empty locale)
+     */
+    renderBrief(locale) {
+        const str = this.render(locale);
+        const space = str.indexOf(' ');
+        return str.substring(space + 1);
+    }
+}
+
 /**
  * Calculates holidays and other Hebrew calendar events based on {@link CalOptions}.
  *
@@ -13533,7 +14140,7 @@ function startEndHebrew(theMonth, theYear, numYears) {
  * The date range returned by this function can be controlled by:
  * * `options.year` - Gregorian (e.g. 1993) or Hebrew year (e.g. 5749)
  * * `options.isHebrewYear` - to interpret `year` as Hebrew year
- * * `options.numYears` - generate calendar for multiple years (default 1)
+ * * `options.numYears` - generate calendar for multiple years (default 1, maximum 2000)
  * * `options.month` - Gregorian or Hebrew month (to filter results to a single month)
  *
  * Alternatively, specify start and end days with `Date` or {@link HDate} instances:
@@ -13577,7 +14184,8 @@ function startEndHebrew(theMonth, theYear, numYears) {
  *
  * To add candle-lighting options, set `options.candlelighting=true` and set
  * `options.location` to an instance of `Location`. By default, candle lighting
- * time is 18 minutes before sundown (40 minutes for Jerusalem,
+ * time is 18 minutes before sundown in the Diaspora and 20 minutes before
+ * sundown in Israel (40 minutes for Jerusalem,
  * 30 minutes for Haifa and Zikhron Ya'akov) and Havdalah is
  * calculated according to Tzeit Hakochavim - Nightfall (the point when 3 small stars
  * are observable in the night time sky with the naked eye). The default Havdalah
@@ -13597,9 +14205,18 @@ function startEndHebrew(theMonth, theYear, numYears) {
  * on weekdays, at regular candle-lighting time on Fridays, and at regular Havdalah time on
  * Saturday night (see above).
  *
- * Minor fasts begin at Alot HaShachar (sun is 16.1° below the horizon in the morning) and
- * end when 3 medium-sized stars are observable in the night sky (sun is 7.083° below the horizon
- * in the evening).
+ * Minor fasts begin at Alot HaShachar (sun is 16.1° below the horizon in the morning).
+ * They end when 3 medium-sized stars are observable in the night sky (sun is 7.083°
+ * below the horizon in the evening) in the Diaspora, or 15 minutes after sunset in
+ * Israel (Rabbi Deblitzky's practice). Override with:
+ * * `options.fastEndDeg` - degrees of solar depression for the end of a minor fast
+ * * `options.fastEndMins` - minutes after sunset for the end of a minor fast
+ *   (mutually exclusive with `options.fastEndDeg`)
+ *
+ * Tish'a B'Av is different: it begins at sunset on the previous day and always ends
+ * at tzeit 6.45° (Rabbi Yechiel Michel Tucazinsky), ignoring `options.fastEndDeg`
+ * and `options.fastEndMins`. When a minor fast falls on a Friday the end time is
+ * suppressed, because Shabbat begins before nightfall.
  *
  * Two options also exist for generating an Event with the Hebrew date:
  * * `options.addHebrewDates` - print the Hebrew date for the entire date range
@@ -13616,7 +14233,7 @@ function startEndHebrew(theMonth, theYear, numYears) {
  * {@link https://github.com/hebcal/hebcal-locales @hebcal/locales} package
  *
  * @example
- * import {HebrewCalendar, HDate, Location, Event} from '@hebcal/core';
+ * import {calendar, Location} from '@hebcal/core';
  * const options: CalOptions = {
  *   year: 1981,
  *   isHebrewYear: false,
@@ -13625,7 +14242,7 @@ function startEndHebrew(theMonth, theYear, numYears) {
  *   sedrot: true,
  *   omer: true,
  * };
- * const events = HebrewCalendar.calendar(options);
+ * const events = calendar(options);
  * for (const ev of events) {
  *   const hd = ev.getDate();
  *   const date = hd.greg();
@@ -13852,8 +14469,11 @@ function warnUnrecognizedOptions(options) {
         }
     }
     if (options.dailyLearning) {
-        for (const k of Object.keys(options.dailyLearning)) {
-            if (!unrecognizedAlreadyWarned.has(k) && !DailyLearning.has(k)) {
+        for (const [k, val] of Object.entries(options.dailyLearning)) {
+            // Resolve aliases (e.g. `yerushalmi` -> `yerushalmi-vilna`) the same way
+            // makeDailyLearning() does, so a valid option doesn't warn spuriously.
+            const name = dailyLearningName(k, val);
+            if (!unrecognizedAlreadyWarned.has(k) && !DailyLearning.has(name)) {
                 console.warn(`Ignoring unrecognized DailyLearning calendar: ${k}`);
                 unrecognizedAlreadyWarned.add(k);
             }
@@ -14222,6 +14842,43 @@ function makeBiurChametzEvent(hd, options) {
     return biurChametzEv;
 }
 
+const NONE = 0;
+const HALF = 1;
+const WHOLE = 2;
+/**
+ * @private
+ */
+function hallel_(events, hdate) {
+    const abs = hdate.abs();
+    for (const ev of events) {
+        const hd = ev.getDate();
+        if (hd.abs() !== abs) {
+            continue;
+        }
+        const desc = ev.getDesc();
+        const month = hd.getMonth();
+        const mday = hd.getDate();
+        const mask = ev.getFlags();
+        if (desc.startsWith('Chanukah') ||
+            desc.startsWith('Shavuot') ||
+            desc.startsWith('Sukkot') ||
+            (month === months.NISAN &&
+                (mday === 15 || mday === 16) &&
+                mask & flags.CHAG) || // Pesach
+            desc === holidayDesc.YOM_HAATZMA_UT ||
+            desc === holidayDesc.YOM_YERUSHALAYIM) {
+            return WHOLE;
+        }
+        if (mask & flags.ROSH_CHODESH ||
+            (desc.startsWith('Pesach') &&
+                desc !== holidayDesc.PESACH_I &&
+                desc !== holidayDesc.PESACH_II)) {
+            return HALF;
+        }
+    }
+    return NONE;
+}
+
 /*
     Hebcal - A Jewish Calendar Generator
     Copyright (c) 1994-2020 Danny Sadinoff
@@ -14257,92 +14914,12 @@ class HebrewCalendar {
      * a description, flags and optional attributes.
      * If given no options, returns holidays for the Diaspora for the current Gregorian year.
      *
-     * The date range returned by this function can be controlled by:
-     * * `options.year` - Gregorian (e.g. 1993) or Hebrew year (e.g. 5749)
-     * * `options.isHebrewYear` - to interpret `year` as Hebrew year
-     * * `options.numYears` - generate calendar for multiple years (default 1, maximum 2000)
-     * * `options.month` - Gregorian or Hebrew month (to filter results to a single month)
-     *
-     * Alternatively, specify start and end days with `Date` or {@link HDate} instances:
-     * * `options.start` - use specific start date (requires `end` date)
-     * * `options.end` - use specific end date (requires `start` date)
-     *
-     * Unless `options.noHolidays == true`, default holidays include:
-     * * Major holidays - Rosh Hashana, Yom Kippur, Pesach, Sukkot, etc.
-     * * Minor holidays - Purim, Chanukah, Tu BiShvat, Lag BaOmer, etc.
-     * * Minor fasts - Ta'anit Esther, Tzom Gedaliah, etc. (unless `options.noMinorFast`)
-     * * Special Shabbatot - Shabbat Shekalim, Zachor, etc. (unless `options.noSpecialShabbat`)
-     * * Modern Holidays - Yom HaShoah, Yom HaAtzma'ut, etc. (unless `options.noModern`)
-     * * Rosh Chodesh (unless `options.noRoshChodesh`)
-     *
-     * Holiday and Torah reading schedules differ between Israel and the Disapora.
-     * Set `options.il=true` to use the Israeli schedule.
-     *
-     * Additional non-default event types can be specified:
-     * * Parashat HaShavua - weekly Torah Reading on Saturdays (`options.sedrot`)
-     * * Counting of the Omer (`options.omer`)
-     * * Shabbat Mevarchim HaChodesh on Saturday before Rosh Chodesh (`options.shabbatMevarchim`)
-     * * Molad announcement on Saturday before Rosh Chodesh (`options.molad`)
-     * * Yom Kippur Katan (`options.yomKippurKatan`)
-     * * Yizkor (`options.yizkor`)
-     *
-     * Daily Study of texts are supported by the
-     * {@link https://github.com/hebcal/hebcal-learning @hebcal/learning} package,
-     * for example:
-     * * Babylonian Talmud Daf Yomi (`options.dailyLearning.dafYomi`)
-     * * Jerusalem Talmud (Yerushalmi) Yomi (`options.dailyLearning.yerushalmi`)
-     * * Mishna Yomi (`options.dailyLearning.mishnaYomi`)
-     * * Nach Yomi (`options.dailyLearning.nachYomi`)
-     *
-     * Candle-lighting and Havdalah times are approximated using latitude and longitude
-     * specified by the {@link Location} class. The `Location` class contains a small
-     * database of cities with their associated geographic information and time-zone information.
-     * If you ever have any doubts about Hebcal's times, consult your local halachic authority.
-     * If you enter geographic coordinates above the arctic circle or antarctic circle,
-     * the times are guaranteed to be wrong.
-     *
-     * To add candle-lighting options, set `options.candlelighting=true` and set
-     * `options.location` to an instance of `Location`. By default, candle lighting
-     * time is 18 minutes before sundown (40 minutes for Jerusalem,
-     * 30 minutes for Haifa and Zikhron Ya'akov) and Havdalah is
-     * calculated according to Tzeit Hakochavim - Nightfall (the point when 3 small stars
-     * are observable in the night time sky with the naked eye). The default Havdalah
-     * option (Tzeit Hakochavim) is calculated when the sun is 8.5° below the horizon.
-     * These defaults can be changed using these options:
-     * * `options.candleLightingMins` - minutes before sundown to light candles
-     * * `options.havdalahMins` - minutes after sundown for Havdalah (typical values are 42, 50, or 72).
-     *    Havdalah times are suppressed when `options.havdalahMins=0`.
-     * * `options.havdalahDeg` - degrees for solar depression for Havdalah.
-     *    Default is 8.5 degrees for 3 small stars. Use 7.083 degrees for 3 medium-sized stars.
-     *    Havdalah times are suppressed when `options.havdalahDeg=0`.
-     *
-     * If both `options.candlelighting=true` and `options.location` is specified,
-     * Chanukah candle-lighting times and minor fast start/end times will also be generated.
-     * Chanukah candle-lighting is at Bein HaShmashos (13.5 minutes before
-     * the sun is 7.083° below the horizon in the evening)
-     * on weekdays, at regular candle-lighting time on Fridays, and at regular Havdalah time on
-     * Saturday night (see above).
-     *
-     * Minor fasts begin at Alot HaShachar (sun is 16.1° below the horizon in the morning) and
-     * end when 3 medium-sized stars are observable in the night sky (sun is 7.083° below the horizon
-     * in the evening).
-     *
-     * Two options also exist for generating an Event with the Hebrew date:
-     * * `options.addHebrewDates` - print the Hebrew date for the entire date range
-     * * `options.addHebrewDatesForEvents` - print the Hebrew date for dates with some events
-     *
-     * Lastly, translation and transliteration of event titles is controlled by
-     * `options.locale` and the {@link Locale} API.
-     * `@hebcal/core` supports three locales by default:
-     * * `en` - default, Sephardic transliterations (e.g. "Shabbat")
-     * * `ashkenazi` - Ashkenazi transliterations (e.g. "Shabbos")
-     * * `he` - Hebrew (e.g. "שַׁבָּת")
-     *
-     * Additional locales (such as `ru` or `fr`) are supported by the
-     * {@link https://github.com/hebcal/hebcal-locales @hebcal/locales} package
+     * This is a convenience wrapper around the standalone {@link calendar} function.
+     * See {@link calendar} for the complete list of supported options, the
+     * candle-lighting and Havdalah defaults, and notes on locales.
      *
      * @example
-     * import {HebrewCalendar, HDate, Location, Event} from '@hebcal/core';
+     * import {HebrewCalendar, Location} from '@hebcal/core';
      * const options: CalOptions = {
      *   year: 1981,
      *   isHebrewYear: false,
@@ -14363,8 +14940,12 @@ class HebrewCalendar {
     }
     /**
      * Calculates a birthday or anniversary (non-yahrzeit).
-     * `hyear` must be after original `gdate` of anniversary.
-     * Returns `undefined` when requested year preceeds or is same as original year.
+     * Returns `undefined` when `hyear` precedes the original year of `gdate`.
+     *
+     * When `hyear` is the original year, the original date is returned unchanged —
+     * a "0th birthday" is a meaningful thing to ask for. This differs from
+     * {@link getYahrzeit}, which returns `undefined` for the original year,
+     * because a yahrzeit only has meaning from the first anniversary onward.
      *
      * Hebcal uses the algorithm defined in "Calendrical Calculations"
      * by Edward M. Reingold and Nachum Dershowitz.
@@ -14388,11 +14969,7 @@ class HebrewCalendar {
      * @returns anniversary occurring in `hyear`
      */
     static getBirthdayOrAnniversary(hyear, gdate) {
-        const dt = getBirthdayHD(hyear, gdate);
-        if (dt === undefined) {
-            return dt;
-        }
-        return new HDate(dt);
+        return birthdayOrAnniversary(hyear, gdate);
     }
     /**
      * Calculates yahrzeit.
@@ -14429,11 +15006,7 @@ class HebrewCalendar {
      * @returns anniversary occurring in hyear
      */
     static getYahrzeit(hyear, gdate) {
-        const dt = getYahrzeitHD(hyear, gdate);
-        if (dt === undefined) {
-            return dt;
-        }
-        return new HDate(dt);
+        return yahrzeit(hyear, gdate);
     }
     /**
      * Lower-level holidays interface, which returns a `Map` of `Event`s indexed by
@@ -14500,9 +15073,12 @@ class HebrewCalendar {
      * (Shabbat) to also be a sacred day.
      * @example
      * import {HebrewCalendar} from '@hebcal/core';
-     * // Thursday April 25, 2024 — first day of Pesach 5784, with Shabbat
-     * // chol ha-moed the next day, so Eruv Tavshilin is required:
-     * HebrewCalendar.eruvTavshilin(new Date(2024, 3, 25), false); // true
+     * // Wednesday October 16, 2024 is Erev Sukkot 5785. In the Diaspora,
+     * // Sukkot I falls on Thursday and Sukkot II on Friday, so Eruv
+     * // Tavshilin is prepared on Wednesday:
+     * HebrewCalendar.eruvTavshilin(new Date(2024, 9, 16), false); // true
+     * // In Israel there is only one day of Yom Tov, so Friday is a weekday:
+     * HebrewCalendar.eruvTavshilin(new Date(2024, 9, 16), true); // false
      * @param date Gregorian or Hebrew date to test
      * @param il use the Israeli holiday schedule
      */
@@ -14534,14 +15110,14 @@ class HebrewCalendar {
      * HebrewCalendar.reformatTimeStr('20:30', 'pm', {hour12: false}); // '20:30'
      * @param timeStr - original time like "20:30"
      * @param suffix - "p" or "pm" or " P.M.". Add leading space if you want it
-     * @param options
+     * @param options optional; `location`, `locale` and `hour12` are consulted
      */
     static reformatTimeStr(timeStr, suffix, options) {
         return reformatTimeStr(timeStr, suffix, options);
     }
     /**
      * Returns the semantic version string of the `@hebcal/core` package
-     * (e.g. `"5.10.0"`). Useful for logging or feature detection.
+     * (e.g. `"6.8.2"`). Useful for logging or feature detection.
      */
     static version() {
         return version;
@@ -14554,10 +15130,10 @@ class HebrewCalendar {
      * since an internal LRU cache (~120 entries) avoids recomputing the
      * keviyah-specific reading pattern.
      * @example
-     * import {HebrewCalendar} from '@hebcal/core';
+     * import {HebrewCalendar, HDate} from '@hebcal/core';
      * const sedra = HebrewCalendar.getSedra(5784, false);
      * const result = sedra.lookup(new HDate(15, 'Cheshvan', 5784));
-     * console.log(result.parsha); // ['Lech-Lecha']
+     * console.log(result.parsha); // ['Vayera']
      * @param hyear Hebrew year
      * @param il Use Israel sedra schedule (`false` for Diaspora)
      */
@@ -14574,12 +15150,14 @@ class HebrewCalendar {
      * Yom Ha'atzmaut, and Yom Yerushalayim.
      *
      * Half Hallel is said on Rosh Chodesh (not Rosh Hashanah), and the last 6 days of Pesach.
-     * @returns 0 for no Hallel, 1 for half Hallel, 2 for whole Hallel
      * @example
      * import {HebrewCalendar, HDate, months} from '@hebcal/core';
      * HebrewCalendar.hallel(new HDate(25, months.KISLEV, 5784), false); // 2 (Chanukah)
      * HebrewCalendar.hallel(new HDate(1, months.SHVAT, 5784), false);   // 1 (Rosh Chodesh)
      * HebrewCalendar.hallel(new HDate(2, months.SHVAT, 5784), false);   // 0
+     * @param hdate Hebrew date to test
+     * @param il use the Israeli holiday schedule
+     * @returns 0 for no Hallel, 1 for half Hallel, 2 for whole Hallel
      */
     static hallel(hdate, il) {
         const events = getHolidaysOnDate(hdate, il);
@@ -14606,12 +15184,18 @@ class HebrewCalendar {
      * @example
      * import {HebrewCalendar, HDate, months} from '@hebcal/core';
      * // Regular weekday — Tachanun is said at both services
-     * HebrewCalendar.tachanun(new HDate(2, months.SHVAT, 5784), false);
+     * HebrewCalendar.tachanun(new HDate(4, months.SHVAT, 5784), false);
      * // => { shacharit: true, mincha: true, allCongs: true }
      *
+     * // Friday 2 Sh'vat — said at Shacharit, but not at Mincha (erev Shabbat)
+     * HebrewCalendar.tachanun(new HDate(2, months.SHVAT, 5784), false);
+     * // => { shacharit: true, mincha: false, allCongs: true }
+     *
      * // Rosh Chodesh — no Tachanun
      * HebrewCalendar.tachanun(new HDate(1, months.SHVAT, 5784), false);
      * // => { shacharit: false, mincha: false, allCongs: false }
+     * @param hdate Hebrew date to test
+     * @param il use the Israeli holiday schedule
      */
     static tachanun(hdate, il) {
         return tachanun(hdate, il);
@@ -14654,6 +15238,7 @@ exports.TimedEvent = TimedEvent;
 exports.YomKippurKatanEvent = YomKippurKatanEvent;
 exports.Zmanim = Zmanim;
 exports.calculateMolad = calculateMolad;
+exports.calendar = calendar;
 exports.flags = flags;
 exports.gematriya = gematriya;
 exports.gematriyaStrToNum = gematriyaStrToNum;
@@ -14667,6 +15252,7 @@ exports.isFastDay = isFastDay;
 exports.months = months;
 exports.parshaYear = parshaYear;
 exports.parshiot = parshiot;
+exports.reformatTimeStr = reformatTimeStr;
 exports.tachanun = tachanun;
 exports.version = version;