@hebcal/core 5.3.2 → 5.3.4

package/dist/index.mjs

@@ -1,23 +1,37 @@
-/*! @hebcal/core v5.3.2 */
+/*! @hebcal/core v5.3.4 */
+/* eslint-disable @typescript-eslint/no-namespace, no-inner-declarations */
 /** @private */
 const lengths = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
 /** @private */
-const monthLengths = [
-    lengths,
-    lengths.slice(),
-];
+const monthLengths = [lengths, lengths.slice()];
 monthLengths[1][2] = 29;
 /**
  * @private
  */
 function mod$1(x, y) {
-    return x - y * Math.floor(x / y);
+  return x - y * Math.floor(x / y);
 }
 /**
  * @private
  */
 function quotient(x, y) {
-    return Math.floor(x / y);
+  return Math.floor(x / y);
+}
+/**
+ * @private
+ * @param abs - R.D. number of days
+ */
+function yearFromFixed(abs) {
+  const l0 = abs - 1;
+  const n400 = quotient(l0, 146097);
+  const d1 = mod$1(l0, 146097);
+  const n100 = quotient(d1, 36524);
+  const d2 = mod$1(d1, 36524);
+  const n4 = quotient(d2, 1461);
+  const d3 = mod$1(d2, 1461);
+  const n1 = quotient(d3, 365);
+  const year = 400 * n400 + 100 * n100 + 4 * n4 + n1;
+  return n100 !== 4 && n1 !== 4 ? year + 1 : year;
 }
 /*
 const ABS_14SEP1752 = 639797;
@@ -28,116 +42,95 @@ const ABS_2SEP1752 = 639785;
  */
 var greg;
 (function (greg) {
-    /**
-     * Returns true if the Gregorian year is a leap year
-     * @param {number} year Gregorian year
-     * @return {boolean}
-     */
-    function isLeapYear(year) {
-        return !(year % 4) && (!!(year % 100) || !(year % 400));
-    }
-    greg.isLeapYear = isLeapYear;
-    /**
-     * Number of days in the Gregorian month for given year
-     * @param {number} month Gregorian month (1=January, 12=December)
-     * @param {number} year Gregorian year
-     * @return {number}
-     */
-    function daysInMonth(month, year) {
-        // 1 based months
-        return monthLengths[+isLeapYear(year)][month];
-    }
-    greg.daysInMonth = daysInMonth;
-    /**
-     * Returns true if the object is a Javascript Date
-     * @param {Object} obj
-     * @return {boolean}
-     */
-    function isDate(obj) {
-        return typeof obj === 'object' && Date.prototype.isPrototypeOf(obj);
-    }
-    greg.isDate = isDate;
-    /**
-     * @private
-     * @param abs - R.D. number of days
-     */
-    function yearFromFixed(abs) {
-        const l0 = abs - 1;
-        const n400 = quotient(l0, 146097);
-        const d1 = mod$1(l0, 146097);
-        const n100 = quotient(d1, 36524);
-        const d2 = mod$1(d1, 36524);
-        const n4 = quotient(d2, 1461);
-        const d3 = mod$1(d2, 1461);
-        const n1 = quotient(d3, 365);
-        const year = 400 * n400 + 100 * n100 + 4 * n4 + n1;
-        return n100 != 4 && n1 != 4 ? year + 1 : year;
+  /**
+   * Returns true if the Gregorian year is a leap year
+   * @param {number} year Gregorian year
+   * @return {boolean}
+   */
+  function isLeapYear(year) {
+    return !(year % 4) && (!!(year % 100) || !(year % 400));
+  }
+  greg.isLeapYear = isLeapYear;
+  /**
+   * Number of days in the Gregorian month for given year
+   * @param {number} month Gregorian month (1=January, 12=December)
+   * @param {number} year Gregorian year
+   * @return {number}
+   */
+  function daysInMonth(month, year) {
+    // 1 based months
+    return monthLengths[+isLeapYear(year)][month];
+  }
+  greg.daysInMonth = daysInMonth;
+  /**
+   * Returns true if the object is a Javascript Date
+   * @param {Object} obj
+   * @return {boolean}
+   */
+  function isDate(obj) {
+    // eslint-disable-next-line no-prototype-builtins
+    return typeof obj === 'object' && Date.prototype.isPrototypeOf(obj);
+  }
+  greg.isDate = isDate;
+  /**
+   * @private
+   * @param year
+   * @param month (1-12)
+   * @param day (1-31)
+   */
+  function toFixed(year, month, day) {
+    const py = year - 1;
+    return 365 * py + quotient(py, 4) - quotient(py, 100) + quotient(py, 400) + quotient(367 * month - 362, 12) + (month <= 2 ? 0 : isLeapYear(year) ? -1 : -2) + day;
+  }
+  /**
+   * Converts Gregorian date to absolute R.D. (Rata Die) days
+   * @param {Date} date Gregorian date
+   * @return {number}
+   */
+  function greg2abs(date) {
+    if (!isDate(date)) {
+      throw new TypeError(`Argument not a Date: ${date}`);
     }
-    /**
-     * @private
-     * @param year
-     * @param month (1-12)
-     * @param day (1-31)
-     */
-    function toFixed(year, month, day) {
-        const py = year - 1;
-        return 365 * py +
-            quotient(py, 4) -
-            quotient(py, 100) +
-            quotient(py, 400) +
-            quotient((367 * month - 362), 12) +
-            (month <= 2 ? 0 : (isLeapYear(year) ? -1 : -2)) +
-            day;
+    const abs = toFixed(date.getFullYear(), date.getMonth() + 1, date.getDate());
+    /*
+    if (abs < ABS_14SEP1752 && abs > ABS_2SEP1752) {
+      throw new RangeError(`Invalid Date: ${date}`);
     }
-    /**
-     * Converts Gregorian date to absolute R.D. (Rata Die) days
-     * @param {Date} date Gregorian date
-     * @return {number}
-     */
-    function greg2abs(date) {
-        if (!isDate(date)) {
-            throw new TypeError(`Argument not a Date: ${date}`);
-        }
-        const abs = toFixed(date.getFullYear(), date.getMonth() + 1, date.getDate());
-        /*
-        if (abs < ABS_14SEP1752 && abs > ABS_2SEP1752) {
-          throw new RangeError(`Invalid Date: ${date}`);
-        }
-        */
-        return abs;
+    */
+    return abs;
+  }
+  greg.greg2abs = greg2abs;
+  /**
+   * Converts from Rata Die (R.D. number) to Gregorian date.
+   * See the footnote on page 384 of ``Calendrical Calculations, Part II:
+   * Three Historical Calendars'' by E. M. Reingold,  N. Dershowitz, and S. M.
+   * Clamen, Software--Practice and Experience, Volume 23, Number 4
+   * (April, 1993), pages 383-404 for an explanation.
+   * @param {number} abs - R.D. number of days
+   * @return {Date}
+   */
+  function abs2greg(abs) {
+    if (typeof abs !== 'number') {
+      throw new TypeError(`Argument not a Number: ${abs}`);
     }
-    greg.greg2abs = greg2abs;
-    /**
-     * Converts from Rata Die (R.D. number) to Gregorian date.
-     * See the footnote on page 384 of ``Calendrical Calculations, Part II:
-     * Three Historical Calendars'' by E. M. Reingold,  N. Dershowitz, and S. M.
-     * Clamen, Software--Practice and Experience, Volume 23, Number 4
-     * (April, 1993), pages 383-404 for an explanation.
-     * @param {number} abs - R.D. number of days
-     * @return {Date}
-     */
-    function abs2greg(abs) {
-        if (typeof abs !== 'number') {
-            throw new TypeError(`Argument not a Number: ${abs}`);
-        }
-        abs = Math.trunc(abs);
-        /*
-        if (abs < ABS_14SEP1752 && abs > ABS_2SEP1752) {
-          throw new RangeError(`Invalid Date: ${abs}`);
-        }
-        */
-        const year = yearFromFixed(abs);
-        const priorDays = abs - toFixed(year, 1, 1);
-        const correction = abs < toFixed(year, 3, 1) ? 0 : (isLeapYear(year) ? 1 : 2);
-        const month = quotient((12 * (priorDays + correction) + 373), 367);
-        const day = abs - toFixed(year, month, 1) + 1;
-        const dt = new Date(year, month - 1, day);
-        if (year < 100 && year >= 0) {
-            dt.setFullYear(year);
-        }
-        return dt;
+    abs = Math.trunc(abs);
+    /*
+    if (abs < ABS_14SEP1752 && abs > ABS_2SEP1752) {
+      throw new RangeError(`Invalid Date: ${abs}`);
     }
-    greg.abs2greg = abs2greg;
+    */
+    const year = yearFromFixed(abs);
+    const priorDays = abs - toFixed(year, 1, 1);
+    const correction = abs < toFixed(year, 3, 1) ? 0 : isLeapYear(year) ? 1 : 2;
+    const month = quotient(12 * (priorDays + correction) + 373, 367);
+    const day = abs - toFixed(year, month, 1) + 1;
+    const dt = new Date(year, month - 1, day);
+    if (year < 100 && year >= 0) {
+      dt.setFullYear(year);
+    }
+    return dt;
+  }
+  greg.abs2greg = abs2greg;
 })(greg || (greg = {}));
 
 /*
@@ -162,63 +155,40 @@ const ADAR_II$2 = 13;
  * @enum {number}
  */
 const months = {
-    /** Nissan / ניסן */
-    NISAN: 1,
-    /** Iyyar / אייר */
-    IYYAR: 2,
-    /** Sivan / סיון */
-    SIVAN: 3,
-    /** Tamuz (sometimes Tammuz) / תמוז */
-    TAMUZ: 4,
-    /** Av / אב */
-    AV: 5,
-    /** Elul / אלול */
-    ELUL: 6,
-    /** Tishrei / תִּשְׁרֵי */
-    TISHREI: 7,
-    /** Cheshvan / חשון */
-    CHESHVAN: 8,
-    /** Kislev / כסלו */
-    KISLEV: 9,
-    /** Tevet / טבת */
-    TEVET: 10,
-    /** Sh'vat / שבט */
-    SHVAT: 11,
-    /** Adar or Adar Rishon / אדר */
-    ADAR_I: 12,
-    /** Adar Sheini (only on leap years) / אדר ב׳ */
-    ADAR_II: 13,
+  /** Nissan / ניסן */
+  NISAN: 1,
+  /** Iyyar / אייר */
+  IYYAR: 2,
+  /** Sivan / סיון */
+  SIVAN: 3,
+  /** Tamuz (sometimes Tammuz) / תמוז */
+  TAMUZ: 4,
+  /** Av / אב */
+  AV: 5,
+  /** Elul / אלול */
+  ELUL: 6,
+  /** Tishrei / תִּשְׁרֵי */
+  TISHREI: 7,
+  /** Cheshvan / חשון */
+  CHESHVAN: 8,
+  /** Kislev / כסלו */
+  KISLEV: 9,
+  /** Tevet / טבת */
+  TEVET: 10,
+  /** Sh'vat / שבט */
+  SHVAT: 11,
+  /** Adar or Adar Rishon / אדר */
+  ADAR_I: 12,
+  /** Adar Sheini (only on leap years) / אדר ב׳ */
+  ADAR_II: 13
 };
-const monthNames0 = [
-    '',
-    'Nisan',
-    'Iyyar',
-    'Sivan',
-    'Tamuz',
-    'Av',
-    'Elul',
-    'Tishrei',
-    'Cheshvan',
-    'Kislev',
-    'Tevet',
-    'Sh\'vat',
-];
+const monthNames0 = ['', 'Nisan', 'Iyyar', 'Sivan', 'Tamuz', 'Av', 'Elul', 'Tishrei', 'Cheshvan', 'Kislev', 'Tevet', "Sh'vat"];
 /**
  * Transliterations of Hebrew month names.
  * Regular years are index 0 and leap years are index 1.
  * @private
  */
-const monthNames = [
-    monthNames0.concat([
-        'Adar',
-        'Nisan',
-    ]),
-    monthNames0.concat([
-        'Adar I',
-        'Adar II',
-        'Nisan',
-    ]),
-];
+const monthNames = [monthNames0.concat(['Adar', 'Nisan']), monthNames0.concat(['Adar I', 'Adar II', 'Nisan'])];
 const edCache = new Map();
 const EPOCH = -1373428;
 // Avg year length in the cycle (19 solar years with 235 lunar months)
@@ -227,9 +197,9 @@ const AVG_HEBYEAR_DAYS = 365.24682220597794;
  * @private
  */
 function assertNumber(n, name) {
-    if (typeof n !== 'number' || isNaN(n)) {
-        throw new TypeError(`invalid parameter '${name}' not a number: ${n}`);
-    }
+  if (typeof n !== 'number' || isNaN(n)) {
+    throw new TypeError(`invalid parameter '${name}' not a number: ${n}`);
+  }
 }
 /**
  * Converts Hebrew date to R.D. (Rata Die) fixed days.
@@ -241,33 +211,32 @@ function assertNumber(n, name) {
  * @return {number}
  */
 function hebrew2abs(year, month, day) {
-    assertNumber(year, 'year');
-    assertNumber(month, 'month');
-    assertNumber(day, 'day');
-    if (year < 1) {
-        throw new RangeError(`hebrew2abs: invalid year ${year}`);
-    }
-    let tempabs = day;
-    if (month < TISHREI$2) {
-        for (let m = TISHREI$2; m <= monthsInYear(year); m++) {
-            tempabs += daysInMonth(m, year);
-        }
-        for (let m = NISAN$4; m < month; m++) {
-            tempabs += daysInMonth(m, year);
-        }
+  assertNumber(year, 'year');
+  assertNumber(month, 'month');
+  assertNumber(day, 'day');
+  if (year < 1) {
+    throw new RangeError(`hebrew2abs: invalid year ${year}`);
+  }
+  let tempabs = day;
+  if (month < TISHREI$2) {
+    for (let m = TISHREI$2; m <= monthsInYear(year); m++) {
+      tempabs += daysInMonth(m, year);
     }
-    else {
-        for (let m = TISHREI$2; m < month; m++) {
-            tempabs += daysInMonth(m, year);
-        }
+    for (let m = NISAN$4; m < month; m++) {
+      tempabs += daysInMonth(m, year);
+    }
+  } else {
+    for (let m = TISHREI$2; m < month; m++) {
+      tempabs += daysInMonth(m, year);
     }
-    return EPOCH + elapsedDays(year) + tempabs - 1;
+  }
+  return EPOCH + elapsedDays(year) + tempabs - 1;
 }
 /**
  * @private
  */
 function newYear(year) {
-    return EPOCH + elapsedDays(year);
+  return EPOCH + elapsedDays(year);
 }
 /**
  * Converts absolute R.D. days to Hebrew date
@@ -275,23 +244,27 @@ function newYear(year) {
  * @return {SimpleHebrewDate}
  */
 function abs2hebrew(abs) {
-    assertNumber(abs, 'abs');
-    abs = Math.trunc(abs);
-    if (abs <= EPOCH) {
-        throw new RangeError(`abs2hebrew: ${abs} is before epoch`);
-    }
-    // first, quickly approximate year
-    let year = Math.floor((abs - EPOCH) / AVG_HEBYEAR_DAYS);
-    while (newYear(year) <= abs) {
-        ++year;
-    }
-    --year;
-    let month = abs < hebrew2abs(year, 1, 1) ? 7 : 1;
-    while (abs > hebrew2abs(year, month, daysInMonth(month, year))) {
-        ++month;
-    }
-    const day = 1 + abs - hebrew2abs(year, month, 1);
-    return { yy: year, mm: month, dd: day };
+  assertNumber(abs, 'abs');
+  abs = Math.trunc(abs);
+  if (abs <= EPOCH) {
+    throw new RangeError(`abs2hebrew: ${abs} is before epoch`);
+  }
+  // first, quickly approximate year
+  let year = Math.floor((abs - EPOCH) / AVG_HEBYEAR_DAYS);
+  while (newYear(year) <= abs) {
+    ++year;
+  }
+  --year;
+  let month = abs < hebrew2abs(year, 1, 1) ? 7 : 1;
+  while (abs > hebrew2abs(year, month, daysInMonth(month, year))) {
+    ++month;
+  }
+  const day = 1 + abs - hebrew2abs(year, month, 1);
+  return {
+    yy: year,
+    mm: month,
+    dd: day
+  };
 }
 /**
  * Returns true if Hebrew year is a leap year
@@ -299,7 +272,7 @@ function abs2hebrew(abs) {
  * @return {boolean}
  */
 function isLeapYear(year) {
-    return (1 + year * 7) % 19 < 7;
+  return (1 + year * 7) % 19 < 7;
 }
 /**
  * Number of months in this Hebrew year (either 12 or 13 depending on leap year)
@@ -307,7 +280,7 @@ function isLeapYear(year) {
  * @return {number}
  */
 function monthsInYear(year) {
-    return 12 + +(isLeapYear(year)); // boolean is cast to 1 or 0
+  return 12 + +isLeapYear(year); // boolean is cast to 1 or 0
 }
 /**
  * Number of days in Hebrew month in a given year (29 or 30)
@@ -316,22 +289,19 @@ function monthsInYear(year) {
  * @return {number}
  */
 function daysInMonth(month, year) {
-    switch (month) {
-        case IYYAR$1:
-        case TAMUZ$1:
-        case ELUL$1:
-        case TEVET$2:
-        case ADAR_II$2:
-            return 29;
-    }
-    if ((month === ADAR_I$2 && !isLeapYear(year)) ||
-        (month === CHESHVAN$1 && !longCheshvan(year)) ||
-        (month === KISLEV$2 && shortKislev(year))) {
-        return 29;
-    }
-    else {
-        return 30;
-    }
+  switch (month) {
+    case IYYAR$1:
+    case TAMUZ$1:
+    case ELUL$1:
+    case TEVET$2:
+    case ADAR_II$2:
+      return 29;
+  }
+  if (month === ADAR_I$2 && !isLeapYear(year) || month === CHESHVAN$1 && !longCheshvan(year) || month === KISLEV$2 && shortKislev(year)) {
+    return 29;
+  } else {
+    return 30;
+  }
 }
 /**
  * Returns a transliterated string name of Hebrew month in year,
@@ -340,12 +310,12 @@ function daysInMonth(month, year) {
  * @param {number} year Hebrew year
  */
 function getMonthName(month, year) {
-    assertNumber(month, 'month');
-    assertNumber(year, 'year');
-    if (month < 1 || month > 14) {
-        throw new TypeError(`bad month argument ${month}`);
-    }
-    return monthNames[+isLeapYear(year)][month];
+  assertNumber(month, 'month');
+  assertNumber(year, 'year');
+  if (month < 1 || month > 14) {
+    throw new TypeError(`bad month argument ${month}`);
+  }
+  return monthNames[+isLeapYear(year)][month];
 }
 /**
  * Days from sunday prior to start of Hebrew calendar to mean
@@ -354,13 +324,13 @@ function getMonthName(month, year) {
  * @return {number}
  */
 function elapsedDays(year) {
-    const n = edCache.get(year);
-    if (typeof n === 'number') {
-        return n;
-    }
-    const elapsed = elapsedDays0(year);
-    edCache.set(year, elapsed);
-    return elapsed;
+  const n = edCache.get(year);
+  if (typeof n === 'number') {
+    return n;
+  }
+  const elapsed = elapsedDays0(year);
+  edCache.set(year, elapsed);
+  return elapsed;
 }
 /**
  * Days from sunday prior to start of Hebrew calendar to mean
@@ -369,29 +339,25 @@ function elapsedDays(year) {
  * @param year Hebrew year
  */
 function elapsedDays0(year) {
-    const prevYear = year - 1;
-    const mElapsed = 235 * Math.floor(prevYear / 19) + // Months in complete 19 year lunar (Metonic) cycles so far
-        12 * (prevYear % 19) + // Regular months in this cycle
-        Math.floor(((prevYear % 19) * 7 + 1) / 19); // Leap months this cycle
-    const pElapsed = 204 + 793 * (mElapsed % 1080);
-    const hElapsed = 5 +
-        12 * mElapsed +
-        793 * Math.floor(mElapsed / 1080) +
-        Math.floor(pElapsed / 1080);
-    const parts = (pElapsed % 1080) + 1080 * (hElapsed % 24);
-    const day = 1 + 29 * mElapsed + Math.floor(hElapsed / 24);
-    let altDay = day;
-    if (parts >= 19440 ||
-        (2 === day % 7 && parts >= 9924 && !isLeapYear(year)) ||
-        (1 === day % 7 && parts >= 16789 && isLeapYear(prevYear))) {
-        altDay++;
-    }
-    if (altDay % 7 === 0 || altDay % 7 === 3 || altDay % 7 === 5) {
-        return altDay + 1;
-    }
-    else {
-        return altDay;
-    }
+  const prevYear = year - 1;
+  const mElapsed = 235 * Math.floor(prevYear / 19) +
+  // Months in complete 19 year lunar (Metonic) cycles so far
+  12 * (prevYear % 19) +
+  // Regular months in this cycle
+  Math.floor((prevYear % 19 * 7 + 1) / 19); // Leap months this cycle
+  const pElapsed = 204 + 793 * (mElapsed % 1080);
+  const hElapsed = 5 + 12 * mElapsed + 793 * Math.floor(mElapsed / 1080) + Math.floor(pElapsed / 1080);
+  const parts = pElapsed % 1080 + 1080 * (hElapsed % 24);
+  const day = 1 + 29 * mElapsed + Math.floor(hElapsed / 24);
+  let altDay = day;
+  if (parts >= 19440 || 2 === day % 7 && parts >= 9924 && !isLeapYear(year) || 1 === day % 7 && parts >= 16789 && isLeapYear(prevYear)) {
+    altDay++;
+  }
+  if (altDay % 7 === 0 || altDay % 7 === 3 || altDay % 7 === 5) {
+    return altDay + 1;
+  } else {
+    return altDay;
+  }
 }
 /**
  * Number of days in the hebrew YEAR.
@@ -401,7 +367,7 @@ function elapsedDays0(year) {
  * @return {number}
  */
 function daysInYear(year) {
-    return elapsedDays(year + 1) - elapsedDays(year);
+  return elapsedDays(year + 1) - elapsedDays(year);
 }
 /**
  * true if Cheshvan is long in Hebrew year
@@ -409,7 +375,7 @@ function daysInYear(year) {
  * @return {boolean}
  */
 function longCheshvan(year) {
-    return daysInYear(year) % 10 === 5;
+  return daysInYear(year) % 10 === 5;
 }
 /**
  * true if Kislev is short in Hebrew year
@@ -417,7 +383,7 @@ function longCheshvan(year) {
  * @return {boolean}
  */
 function shortKislev(year) {
-    return daysInYear(year) % 10 === 3;
+  return daysInYear(year) % 10 === 3;
 }
 /**
  * Converts Hebrew month string name to numeric
@@ -425,116 +391,116 @@ function shortKislev(year) {
  * @return {number}
  */
 function monthFromName(monthName) {
-    if (typeof monthName === 'number') {
-        if (isNaN(monthName) || monthName < 1 || monthName > 14) {
-            throw new RangeError(`Invalid month name: ${monthName}`);
-        }
-        return monthName;
-    }
-    let c = monthName.trim().toLowerCase();
-    // If Hebrew month starts with a bet (for example `בתמוז`) then ignore it
-    if (c[0] === 'ב') {
-        c = c.substring(1);
-    }
-    /*
-    the Hebrew months are unique to their second letter
-    N         Nisan  (November?)
-    I         Iyyar
-    E        Elul
-    C        Cheshvan
-    K        Kislev
-    1        1Adar
-    2        2Adar
-    Si Sh     Sivan, Shvat
-    Ta Ti Te Tamuz, Tishrei, Tevet
-    Av Ad    Av, Adar
-  
-    אב אד אי אל   אב אדר אייר אלול
-    ח            חשון
-    ט            טבת
-    כ            כסלו
-    נ            ניסן
-    ס            סיון
-    ש            שבט
-    תמ תש        תמוז תשרי
-    */
-    switch (c[0]) {
-        case 'n':
-        case 'נ':
-            if (c[1] == 'o') {
-                break; /* this catches "november" */
-            }
-            return months.NISAN;
+  if (typeof monthName === 'number') {
+    if (isNaN(monthName) || monthName < 1 || monthName > 14) {
+      throw new RangeError(`Invalid month name: ${monthName}`);
+    }
+    return monthName;
+  }
+  let c = monthName.trim().toLowerCase();
+  // If Hebrew month starts with a bet (for example `בתמוז`) then ignore it
+  if (c[0] === 'ב') {
+    c = c.substring(1);
+  }
+  /*
+  the Hebrew months are unique to their second letter
+  N         Nisan  (November?)
+  I         Iyyar
+  E        Elul
+  C        Cheshvan
+  K        Kislev
+  1        1Adar
+  2        2Adar
+  Si Sh     Sivan, Shvat
+  Ta Ti Te Tamuz, Tishrei, Tevet
+  Av Ad    Av, Adar
+     אב אד אי אל   אב אדר אייר אלול
+  ח            חשון
+  ט            טבת
+  כ            כסלו
+  נ            ניסן
+  ס            סיון
+  ש            שבט
+  תמ תש        תמוז תשרי
+  */
+  switch (c[0]) {
+    case 'n':
+    case 'נ':
+      if (c[1] === 'o') {
+        break; /* this catches "november" */
+      }
+      return months.NISAN;
+    case 'i':
+      return months.IYYAR;
+    case 'e':
+      return months.ELUL;
+    case 'c':
+    case 'ח':
+      return months.CHESHVAN;
+    case 'k':
+    case 'כ':
+      return months.KISLEV;
+    case 's':
+      switch (c[1]) {
         case 'i':
-            return months.IYYAR;
-        case 'e':
-            return months.ELUL;
-        case 'c':
-        case 'ח':
-            return months.CHESHVAN;
-        case 'k':
-        case 'כ':
-            return months.KISLEV;
-        case 's':
-            switch (c[1]) {
-                case 'i':
-                    return months.SIVAN;
-                case 'h':
-                    return months.SHVAT;
-            }
-            break;
-        case 't':
-            switch (c[1]) {
-                case 'a':
-                    return months.TAMUZ;
-                case 'i':
-                    return months.TISHREI;
-                case 'e':
-                    return months.TEVET;
-            }
-            break;
+          return months.SIVAN;
+        case 'h':
+          return months.SHVAT;
+      }
+      break;
+    case 't':
+      switch (c[1]) {
         case 'a':
-            switch (c[1]) {
-                case 'v':
-                    return months.AV;
-                case 'd':
-                    if (/(1|[^i]i|a|א)$/i.test(monthName)) {
-                        return months.ADAR_I;
-                    }
-                    return months.ADAR_II; // else assume sheini
-            }
-            break;
-        case 'ס':
-            return months.SIVAN;
-        case 'ט':
-            return months.TEVET;
+          return months.TAMUZ;
+        case 'i':
+          return months.TISHREI;
+        case 'e':
+          return months.TEVET;
+      }
+      break;
+    case 'a':
+      switch (c[1]) {
+        case 'v':
+          return months.AV;
+        case 'd':
+          if (/(1|[^i]i|a|א)$/i.test(monthName)) {
+            return months.ADAR_I;
+          }
+          return months.ADAR_II;
+      }
+      break;
+    case 'ס':
+      return months.SIVAN;
+    case 'ט':
+      return months.TEVET;
+    case 'ש':
+      return months.SHVAT;
+    case 'א':
+      switch (c[1]) {
+        case 'ב':
+          return months.AV;
+        case 'ד':
+          if (/(1|[^i]i|a|א)$/i.test(monthName)) {
+            return months.ADAR_I;
+          }
+          return months.ADAR_II;
+        // else assume sheini
+        case 'י':
+          return months.IYYAR;
+        case 'ל':
+          return months.ELUL;
+      }
+      break;
+    case 'ת':
+      switch (c[1]) {
+        case 'מ':
+          return months.TAMUZ;
         case 'ש':
-            return months.SHVAT;
-        case 'א':
-            switch (c[1]) {
-                case 'ב':
-                    return months.AV;
-                case 'ד':
-                    if (/(1|[^i]i|a|א)$/i.test(monthName)) {
-                        return months.ADAR_I;
-                    }
-                    return months.ADAR_II; // else assume sheini
-                case 'י':
-                    return months.IYYAR;
-                case 'ל':
-                    return months.ELUL;
-            }
-            break;
-        case 'ת':
-            switch (c[1]) {
-                case 'מ':
-                    return months.TAMUZ;
-                case 'ש':
-                    return months.TISHREI;
-            }
-            break;
-    }
-    throw new RangeError(`Unable to parse month name: ${monthName}`);
+          return months.TISHREI;
+      }
+      break;
+  }
+  throw new RangeError(`Unable to parse month name: ${monthName}`);
 }
 
 const NISAN$3 = months.NISAN;
@@ -545,155 +511,145 @@ const SHVAT = months.SHVAT;
 const ADAR_I$1 = months.ADAR_I;
 const ADAR_II$1 = months.ADAR_II;
 /**
- * Returns true if the object is a Javascript Date
+ * Returns true if the object is a SimpleHebrewDate
  * @private
  * @param {Object} obj
  */
 function isSimpleHebrewDate(obj) {
-    return typeof obj === 'object' && obj !== null &&
-        typeof obj.yy === 'number' &&
-        typeof obj.mm === 'number' &&
-        typeof obj.dd === 'number';
+  return typeof obj === 'object' && obj !== null && typeof obj.yy === 'number' && typeof obj.mm === 'number' && typeof obj.dd === 'number';
 }
 /**
  * @private
  */
 function toSimpleHebrewDate(obj) {
-    if (isSimpleHebrewDate(obj)) {
-        return obj;
-    }
-    else if (typeof obj === 'number') {
-        return abs2hebrew(obj);
-    }
-    else if (greg.isDate(obj)) {
-        const abs = greg.greg2abs(obj);
-        return abs2hebrew(abs);
-    }
-    else {
-        throw new TypeError(`Argument not a Date: ${obj}`);
-    }
+  if (isSimpleHebrewDate(obj)) {
+    return obj;
+  } else if (typeof obj === 'number') {
+    return abs2hebrew(obj);
+  } else if (greg.isDate(obj)) {
+    const abs = greg.greg2abs(obj);
+    return abs2hebrew(abs);
+  } else {
+    throw new TypeError(`Argument not a Date: ${obj}`);
+  }
 }
 function getYahrzeitHD(hyear, date) {
-    let hDeath = toSimpleHebrewDate(date);
-    if (hyear <= hDeath.yy) {
-        // Hebrew year ${hyear} occurs on or before original date in ${hDeath.yy}
-        return undefined;
-    }
-    if (hDeath.mm == CHESHVAN && hDeath.dd == 30 && !longCheshvan(hDeath.yy + 1)) {
-        // If it's Heshvan 30 it depends on the first anniversary;
-        // if that was not Heshvan 30, use the day before Kislev 1.
-        hDeath = abs2hebrew(hebrew2abs(hyear, KISLEV$1, 1) - 1);
-    }
-    else if (hDeath.mm == KISLEV$1 && hDeath.dd == 30 && shortKislev(hDeath.yy + 1)) {
-        // If it's Kislev 30 it depends on the first anniversary;
-        // if that was not Kislev 30, use the day before Teveth 1.
-        hDeath = abs2hebrew(hebrew2abs(hyear, TEVET$1, 1) - 1);
-    }
-    else if (hDeath.mm == ADAR_II$1) {
-        // If it's Adar II, use the same day in last month of year (Adar or Adar II).
-        hDeath.mm = monthsInYear(hyear);
-    }
-    else if (hDeath.mm == ADAR_I$1 && hDeath.dd == 30 && !isLeapYear(hyear)) {
-        // If it's the 30th in Adar I and year is not a leap year
-        // (so Adar has only 29 days), use the last day in Shevat.
-        hDeath.dd = 30;
-        hDeath.mm = SHVAT;
-    }
-    // In all other cases, use the normal anniversary of the date of death.
-    // advance day to rosh chodesh if needed
-    if (hDeath.mm == CHESHVAN && hDeath.dd == 30 && !longCheshvan(hyear)) {
-        hDeath.mm = KISLEV$1;
-        hDeath.dd = 1;
-    }
-    else if (hDeath.mm == KISLEV$1 && hDeath.dd == 30 && shortKislev(hyear)) {
-        hDeath.mm = TEVET$1;
-        hDeath.dd = 1;
-    }
-    hDeath.yy = hyear;
-    return hDeath;
+  let hDeath = toSimpleHebrewDate(date);
+  if (hyear <= hDeath.yy) {
+    // Hebrew year ${hyear} occurs on or before original date in ${hDeath.yy}
+    return undefined;
+  }
+  if (hDeath.mm === CHESHVAN && hDeath.dd === 30 && !longCheshvan(hDeath.yy + 1)) {
+    // If it's Heshvan 30 it depends on the first anniversary;
+    // if that was not Heshvan 30, use the day before Kislev 1.
+    hDeath = abs2hebrew(hebrew2abs(hyear, KISLEV$1, 1) - 1);
+  } else if (hDeath.mm === KISLEV$1 && hDeath.dd === 30 && shortKislev(hDeath.yy + 1)) {
+    // If it's Kislev 30 it depends on the first anniversary;
+    // if that was not Kislev 30, use the day before Teveth 1.
+    hDeath = abs2hebrew(hebrew2abs(hyear, TEVET$1, 1) - 1);
+  } else if (hDeath.mm === ADAR_II$1) {
+    // If it's Adar II, use the same day in last month of year (Adar or Adar II).
+    hDeath.mm = monthsInYear(hyear);
+  } else if (hDeath.mm === ADAR_I$1 && hDeath.dd === 30 && !isLeapYear(hyear)) {
+    // If it's the 30th in Adar I and year is not a leap year
+    // (so Adar has only 29 days), use the last day in Shevat.
+    hDeath.dd = 30;
+    hDeath.mm = SHVAT;
+  }
+  // In all other cases, use the normal anniversary of the date of death.
+  // advance day to rosh chodesh if needed
+  if (hDeath.mm === CHESHVAN && hDeath.dd === 30 && !longCheshvan(hyear)) {
+    hDeath.mm = KISLEV$1;
+    hDeath.dd = 1;
+  } else if (hDeath.mm === KISLEV$1 && hDeath.dd === 30 && shortKislev(hyear)) {
+    hDeath.mm = TEVET$1;
+    hDeath.dd = 1;
+  }
+  hDeath.yy = hyear;
+  return hDeath;
 }
 function getBirthdayHD(hyear, date) {
-    const orig = toSimpleHebrewDate(date);
-    const origYear = orig.yy;
-    if (hyear === origYear) {
-        return orig;
-    }
-    else if (hyear < origYear) {
-        // Hebrew year ${hyear} occurs on or before original date in ${origYear}
-        return undefined;
-    }
-    const isOrigLeap = isLeapYear(origYear);
-    let month = orig.mm;
-    let day = orig.dd;
-    if ((month == ADAR_I$1 && !isOrigLeap) || (month == ADAR_II$1 && isOrigLeap)) {
-        month = monthsInYear(hyear);
-    }
-    else if (month == CHESHVAN && day == 30 && !longCheshvan(hyear)) {
-        month = KISLEV$1;
-        day = 1;
-    }
-    else if (month == KISLEV$1 && day == 30 && shortKislev(hyear)) {
-        month = TEVET$1;
-        day = 1;
-    }
-    else if (month == ADAR_I$1 && day == 30 && isOrigLeap && !isLeapYear(hyear)) {
-        month = NISAN$3;
-        day = 1;
-    }
-    return { yy: hyear, mm: month, dd: day };
+  const orig = toSimpleHebrewDate(date);
+  const origYear = orig.yy;
+  if (hyear === origYear) {
+    return orig;
+  } else if (hyear < origYear) {
+    // Hebrew year ${hyear} occurs on or before original date in ${origYear}
+    return undefined;
+  }
+  const isOrigLeap = isLeapYear(origYear);
+  let month = orig.mm;
+  let day = orig.dd;
+  if (month === ADAR_I$1 && !isOrigLeap || month === ADAR_II$1 && isOrigLeap) {
+    month = monthsInYear(hyear);
+  } else if (month === CHESHVAN && day === 30 && !longCheshvan(hyear)) {
+    month = KISLEV$1;
+    day = 1;
+  } else if (month === KISLEV$1 && day === 30 && shortKislev(hyear)) {
+    month = TEVET$1;
+    day = 1;
+  } else if (month === ADAR_I$1 && day === 30 && isOrigLeap && !isLeapYear(hyear)) {
+    month = NISAN$3;
+    day = 1;
+  }
+  return {
+    yy: hyear,
+    mm: month,
+    dd: day
+  };
 }
 
 const GERESH = '׳';
 const GERSHAYIM = '״';
 const alefbet = {
-    'א': 1,
-    'ב': 2,
-    'ג': 3,
-    'ד': 4,
-    'ה': 5,
-    'ו': 6,
-    'ז': 7,
-    'ח': 8,
-    'ט': 9,
-    'י': 10,
-    'כ': 20,
-    'ל': 30,
-    'מ': 40,
-    'נ': 50,
-    'ס': 60,
-    'ע': 70,
-    'פ': 80,
-    'צ': 90,
-    'ק': 100,
-    'ר': 200,
-    'ש': 300,
-    'ת': 400,
+  א: 1,
+  ב: 2,
+  ג: 3,
+  ד: 4,
+  ה: 5,
+  ו: 6,
+  ז: 7,
+  ח: 8,
+  ט: 9,
+  י: 10,
+  כ: 20,
+  ל: 30,
+  מ: 40,
+  נ: 50,
+  ס: 60,
+  ע: 70,
+  פ: 80,
+  צ: 90,
+  ק: 100,
+  ר: 200,
+  ש: 300,
+  ת: 400
 };
 const heb2num = new Map();
 const num2heb = new Map();
 for (const [key, val] of Object.entries(alefbet)) {
-    heb2num.set(key, val);
-    num2heb.set(val, key);
+  heb2num.set(key, val);
+  num2heb.set(val, key);
 }
 function num2digits(num) {
-    const digits = [];
-    while (num > 0) {
-        if (num === 15 || num === 16) {
-            digits.push(9);
-            digits.push(num - 9);
-            break;
-        }
-        let incr = 100;
-        let i;
-        for (i = 400; i > num; i -= incr) {
-            if (i === incr) {
-                incr = incr / 10;
-            }
-        }
-        digits.push(i);
-        num -= i;
+  const digits = [];
+  while (num > 0) {
+    if (num === 15 || num === 16) {
+      digits.push(9);
+      digits.push(num - 9);
+      break;
+    }
+    let incr = 100;
+    let i;
+    for (i = 400; i > num; i -= incr) {
+      if (i === incr) {
+        incr = incr / 10;
+      }
     }
-    return digits;
+    digits.push(i);
+    num -= i;
+  }
+  return digits;
 }
 /**
  * Converts a numerical value to a string of Hebrew letters.
@@ -710,31 +666,31 @@ function num2digits(num) {
  * @return {string}
  */
 function gematriya(num) {
-    const num0 = num;
-    const num1 = parseInt(num0, 10);
-    if (!num1) {
-        throw new TypeError(`invalid parameter to gematriya ${num}`);
-    }
-    let str = '';
-    const thousands = Math.floor(num1 / 1000);
-    if (thousands > 0 && thousands !== 5) {
-        const tdigits = num2digits(thousands);
-        for (const tdig of tdigits) {
-            str += num2heb.get(tdig);
-        }
-        str += GERESH;
-    }
-    const digits = num2digits(num1 % 1000);
-    if (digits.length == 1) {
-        return str + num2heb.get(digits[0]) + GERESH;
+  const num0 = num;
+  const num1 = parseInt(num0, 10);
+  if (!num1) {
+    throw new TypeError(`invalid parameter to gematriya ${num}`);
+  }
+  let str = '';
+  const thousands = Math.floor(num1 / 1000);
+  if (thousands > 0 && thousands !== 5) {
+    const tdigits = num2digits(thousands);
+    for (const tdig of tdigits) {
+      str += num2heb.get(tdig);
     }
-    for (let i = 0; i < digits.length; i++) {
-        if (i + 1 === digits.length) {
-            str += GERSHAYIM;
-        }
-        str += num2heb.get(digits[i]);
+    str += GERESH;
+  }
+  const digits = num2digits(num1 % 1000);
+  if (digits.length === 1) {
+    return str + num2heb.get(digits[0]) + GERESH;
+  }
+  for (let i = 0; i < digits.length; i++) {
+    if (i + 1 === digits.length) {
+      str += GERSHAYIM;
     }
-    return str;
+    str += num2heb.get(digits[i]);
+  }
+  return str;
 }
 /**
  * Converts a string of Hebrew letters to a numerical value.
@@ -747,20 +703,189 @@ function gematriya(num) {
  * @return {number}
  */
 function gematriyaStrToNum(str) {
-    let num = 0;
-    const gereshIdx = str.indexOf(GERESH);
-    if (gereshIdx !== -1 && gereshIdx !== str.length - 1) {
-        const thousands = str.substring(0, gereshIdx);
-        num += gematriyaStrToNum(thousands) * 1000;
-        str = str.substring(gereshIdx);
-    }
-    for (const ch of str) {
-        const n = heb2num.get(ch);
-        if (typeof n === 'number') {
-            num += n;
-        }
+  let num = 0;
+  const gereshIdx = str.indexOf(GERESH);
+  if (gereshIdx !== -1 && gereshIdx !== str.length - 1) {
+    const thousands = str.substring(0, gereshIdx);
+    num += gematriyaStrToNum(thousands) * 1000;
+    str = str.substring(gereshIdx);
+  }
+  for (const ch of str) {
+    const n = heb2num.get(ch);
+    if (typeof n === 'number') {
+      num += n;
+    }
+  }
+  return num;
+}
+
+const sefirot = {
+  en: {
+    infix: 'within ',
+    infix26: 'within ',
+    words: ['', 'Lovingkindness', 'Might', 'Beauty', 'Eternity', 'Splendor', 'Foundation', 'Majesty']
+  },
+  he: {
+    infix: 'שֶׁבְּ',
+    infix26: 'שֶׁבִּ',
+    words: ['', 'חֶֽסֶד', 'גְבוּרָה', 'תִּפאֶרֶת', 'נֶּֽצַח', 'הוֹד', 'יְּסוֹד', 'מַּלְכוּת']
+  },
+  translit: {
+    infix: "sheb'",
+    infix26: 'shebi',
+    words: ['', 'Chesed', 'Gevurah', 'Tiferet', 'Netzach', 'Hod', 'Yesod', 'Malkhut']
+  }
+};
+function checkDay(omerDay) {
+  if (omerDay < 1 || omerDay > 49) {
+    throw new RangeError(`Invalid Omer day ${omerDay}`);
+  }
+}
+function getWeeks(omerDay) {
+  const weekNum = Math.floor((omerDay - 1) / 7) + 1;
+  const daysWithinWeeks = omerDay % 7 || 7;
+  return [weekNum, daysWithinWeeks];
+}
+/**
+ * Returns the sefira. For example, on day 8
+ *  חֶֽסֶד שֶׁבִּגְבוּרָה
+ *  Chesed shebiGevurah
+ *  Lovingkindness within Might
+ * @param omerDay the day of the omer, 1-49 inclusive
+ * @param lang `en` (English), `he` (Hebrew with nikud), or `translit` (Hebrew in Sephardic transliteration)
+ * @returns a string such as `Lovingkindness within Might` or `חֶֽסֶד שֶׁבִּגְבוּרָה`
+ */
+function omerSefira(omerDay, lang) {
+  checkDay(omerDay);
+  const [weekNum, daysWithinWeeks] = getWeeks(omerDay);
+  const config = sefirot[lang];
+  const week = config.words[weekNum];
+  const dayWithinWeek = config.words[daysWithinWeeks];
+  const infix = weekNum === 2 || weekNum === 6 ? config.infix26 : config.infix;
+  return (dayWithinWeek + ' ' + infix + week).normalize();
+}
+/**
+ * Returns a sentence with that evening's omer count
+ * @param omerDay the day of the omer, 1-49 inclusive
+ * @param lang `en` (English), `he` (Hebrew with nikud)
+ * @returns a string such as `Today is 10 days, which is 1 week and 3 days of the Omer`
+ *  or `הַיוֹם עֲשָׂרָה יָמִים, שְׁהֵם שָׁבוּעַ אֶחָד וְשְׁלוֹשָׁה יָמִים לָעוֹמֶר`
+ */
+function omerTodayIs(omerDay, lang) {
+  checkDay(omerDay);
+  if (lang === 'en') {
+    return omerTodayIsEn(omerDay);
+  } else if (lang === 'he') {
+    return omerTodayIsHe(omerDay);
+  } else {
+    return undefined;
+  }
+}
+function omerTodayIsEn(omerDay) {
+  const [weekNumber, daysWithinWeeks] = getWeeks(omerDay);
+  const totalDaysStr = omerDay === 1 ? 'day' : 'days';
+  let str = `Today is ${omerDay} ${totalDaysStr}`;
+  if (weekNumber > 1 || omerDay === 7) {
+    const day7 = daysWithinWeeks === 7;
+    const numWeeks = day7 ? weekNumber : weekNumber - 1;
+    const weeksStr = numWeeks === 1 ? 'week' : 'weeks';
+    str += `, which is ${numWeeks} ${weeksStr}`;
+    if (!day7) {
+      const daysStr = daysWithinWeeks === 1 ? 'day' : 'days';
+      str += ` and ${daysWithinWeeks} ${daysStr}`;
+    }
+  }
+  return str + ' of the Omer';
+}
+// adapted from pip hdate package (GPL)
+// https://github.com/py-libhdate/py-libhdate/blob/master/hdate/date.py
+const tens = ['', 'עֲשָׂרָה', 'עֶשְׂרִים', 'שְׁלוֹשִׁים', 'אַרְבָּעִים'];
+const ones = ['', 'אֶחָד', 'שְׁנַיִם', 'שְׁלוֹשָׁה', 'אַרְבָּעָה', 'חֲמִשָּׁה', 'שִׁשָּׁה', 'שִׁבְעָה', 'שְׁמוֹנָה', 'תִּשְׁעָה'];
+const shnei = 'שְׁנֵי';
+const yamim = 'יָמִים';
+const shneiYamim = shnei + ' ' + yamim;
+const shavuot = 'שָׁבוּעוֹת';
+const yom = 'יוֹם';
+const yomEchad = yom + ' ' + ones[1];
+function omerTodayIsHe(omerDay) {
+  const ten = Math.floor(omerDay / 10);
+  const one = omerDay % 10;
+  let str = 'הַיּוֹם ';
+  if (10 < omerDay && omerDay < 20) {
+    str += ones[one] + ' עָשָׂר';
+  } else if (omerDay > 9) {
+    str += ones[one];
+    if (one) {
+      str += ' ';
+      str += ten === 3 ? 'וּ' : 'וְ';
+    }
+  }
+  if (omerDay > 2) {
+    if (omerDay > 20 || omerDay === 10 || omerDay === 20) {
+      str += tens[ten];
+    }
+    if (omerDay < 11) {
+      str += ones[one] + ' ' + yamim + ' ';
+    } else {
+      str += ' ' + yom + ' ';
+    }
+  } else if (omerDay === 1) {
+    str += yomEchad + ' ';
+  } else {
+    // omer == 2
+    str += shneiYamim + ' ';
+  }
+  if (omerDay > 6) {
+    str = str.trim(); // remove trailing space before comma
+    str += ', שְׁהֵם ';
+    const weeks = Math.floor(omerDay / 7);
+    const days = omerDay % 7;
+    if (weeks > 2) {
+      str += ones[weeks] + ' ' + shavuot + ' ';
+    } else if (weeks === 1) {
+      str += 'שָׁבֽוּעַ' + ' ' + ones[1] + ' ';
+    } else {
+      // weeks == 2
+      str += shnei + ' ' + shavuot + ' ';
+    }
+    if (days) {
+      if (days === 2 || days === 3) {
+        str += 'וּ';
+      } else if (days === 5) {
+        str += 'וַ';
+      } else {
+        str += 'וְ';
+      }
+      if (days > 2) {
+        str += ones[days] + ' ' + yamim + ' ';
+      } else if (days === 1) {
+        str += yomEchad + ' ';
+      } else {
+        // days == 2
+        str += shneiYamim + ' ';
+      }
     }
-    return num;
+  }
+  str += 'לָעֽוֹמֶר';
+  return str.normalize();
+}
+/**
+ * Returns an emoji number symbol with a circle, for example `㊲`
+ *  from the “Enclosed CJK Letters and Months” block of the Unicode standard
+ * @param omerDay the day of the omer, 1-49 inclusive
+ * @returns a single Unicode character from `①` through `㊾`
+ */
+function omerEmoji(omerDay) {
+  checkDay(omerDay);
+  if (omerDay <= 20) {
+    return String.fromCodePoint(9312 + omerDay - 1);
+  } else if (omerDay <= 35) {
+    // between 21 and 35 inclusive
+    return String.fromCodePoint(12881 + omerDay - 21);
+  } else {
+    // between 36 and 49 inclusive
+    return String.fromCodePoint(12977 + omerDay - 36);
+  }
 }
 
 const noopLocale = {
@@ -6108,32 +6233,16 @@ class GeoLocation {
      *            the <code>TimeZone</code> for the location.
      */
     constructor(name, latitude, longitude, elevation, timeZoneId) {
+        /**
+         * @private
+         */
+        this.locationName = null;
         this.setLocationName(name);
         this.setLatitude(latitude);
         this.setLongitude(longitude);
         this.setElevation(elevation);
         this.setTimeZone(timeZoneId);
     }
-    /**
-     * @private
-     */
-    latitude;
-    /**
-     * @private
-     */
-    longitude;
-    /**
-     * @private
-     */
-    locationName = null;
-    /**
-     * @private
-     */
-    timeZoneId;
-    /**
-     * @private
-     */
-    elevation;
     /**
      * Method to get the elevation in Meters.
      *
@@ -6256,39 +6365,6 @@ class NOAACalculator {
         this.date = date;
         this.geoLocation = geoLocation;
     }
-    /**
-     * The zenith of astronomical sunrise and sunset. The sun is 90&deg; from the vertical 0&deg;
-     * @private
-     */
-    static GEOMETRIC_ZENITH = 90;
-    /**
-     * Default value for Sun's zenith and true rise/set Zenith (used in this class and subclasses) is the angle that the
-     * center of the Sun makes to a line perpendicular to the Earth's surface. If the Sun were a point and the Earth
-     * were without an atmosphere, true sunset and sunrise would correspond to a 90&deg; zenith. Because the Sun is not
-     * a point, and because the atmosphere refracts light, this 90&deg; zenith does not, in fact, correspond to true
-     * sunset or sunrise, instead the center of the Sun's disk must lie just below the horizon for the upper edge to be
-     * obscured. This means that a zenith of just above 90&deg; must be used. The Sun subtends an angle of 16 minutes of
-     * arc, and atmospheric refraction accounts for
-     * 34 minutes or so, giving a total of 50
-     * arcminutes. The total value for ZENITH is 90+(5/6) or 90.8333333&deg; for true sunrise/sunset.
-     */
-    // const ZENITH: number = GEOMETRIC_ZENITH + 5.0 / 6.0;
-    /** Sun's zenith at civil twilight (96&deg;). */
-    static CIVIL_ZENITH = 96;
-    /** Sun's zenith at nautical twilight (102&deg;). */
-    static NAUTICAL_ZENITH = 102;
-    /** Sun's zenith at astronomical twilight (108&deg;). */
-    static ASTRONOMICAL_ZENITH = 108;
-    /**
-     * The Java Calendar encapsulated by this class to track the current date used by the class
-     * @private
-     */
-    date;
-    /**
-     * the {@link GeoLocation} used for calculations.
-     * @private
-     */
-    geoLocation;
     /**
      * The getSunrise method Returns a `Date` representing the
      * {@link getElevationAdjustment elevation adjusted} sunrise time. The zenith used
@@ -6638,16 +6714,6 @@ class NOAACalculator {
         }
         return adjustedZenith;
     }
-    /**
-     * The <a href="http://en.wikipedia.org/wiki/Julian_day">Julian day</a> of January 1, 2000
-     * @private
-     */
-    static JULIAN_DAY_JAN_1_2000 = 2451545;
-    /**
-     * Julian days per century
-     * @private
-     */
-    static JULIAN_DAYS_PER_CENTURY = 36525;
     /**
      * A method that calculates UTC sunrise as well as any time based on an angle above or below sunrise.
      * @param date
@@ -7187,6 +7253,39 @@ class NOAACalculator {
         return timeUTC;
     }
 }
+/**
+ * The zenith of astronomical sunrise and sunset. The sun is 90&deg; from the vertical 0&deg;
+ * @private
+ */
+NOAACalculator.GEOMETRIC_ZENITH = 90;
+/**
+ * Default value for Sun's zenith and true rise/set Zenith (used in this class and subclasses) is the angle that the
+ * center of the Sun makes to a line perpendicular to the Earth's surface. If the Sun were a point and the Earth
+ * were without an atmosphere, true sunset and sunrise would correspond to a 90&deg; zenith. Because the Sun is not
+ * a point, and because the atmosphere refracts light, this 90&deg; zenith does not, in fact, correspond to true
+ * sunset or sunrise, instead the center of the Sun's disk must lie just below the horizon for the upper edge to be
+ * obscured. This means that a zenith of just above 90&deg; must be used. The Sun subtends an angle of 16 minutes of
+ * arc, and atmospheric refraction accounts for
+ * 34 minutes or so, giving a total of 50
+ * arcminutes. The total value for ZENITH is 90+(5/6) or 90.8333333&deg; for true sunrise/sunset.
+ */
+// const ZENITH: number = GEOMETRIC_ZENITH + 5.0 / 6.0;
+/** Sun's zenith at civil twilight (96&deg;). */
+NOAACalculator.CIVIL_ZENITH = 96;
+/** Sun's zenith at nautical twilight (102&deg;). */
+NOAACalculator.NAUTICAL_ZENITH = 102;
+/** Sun's zenith at astronomical twilight (108&deg;). */
+NOAACalculator.ASTRONOMICAL_ZENITH = 108;
+/**
+ * The <a href="http://en.wikipedia.org/wiki/Julian_day">Julian day</a> of January 1, 2000
+ * @private
+ */
+NOAACalculator.JULIAN_DAY_JAN_1_2000 = 2451545;
+/**
+ * Julian days per century
+ * @private
+ */
+NOAACalculator.JULIAN_DAYS_PER_CENTURY = 36525;
 
 /*
     Hebcal - A Jewish Calendar Generator
@@ -8400,9 +8499,6 @@ class MoladEvent extends Event {
   }
 }
 
-const sefirot = [null, 'Lovingkindness', 'Might', 'Beauty', 'Eternity', 'Splendor', 'Foundation', 'Majesty'];
-const sefirotTranslit = [null, 'Chesed', 'Gevurah', 'Tiferet', 'Netzach', 'Hod', 'Yesod', 'Malkhut'];
-
 /** Represents a day 1-49 of counting the Omer from Pesach to Shavuot */
 class OmerEvent extends Event {
   /**
@@ -8423,39 +8519,10 @@ class OmerEvent extends Event {
    * @return {string}
    */
   sefira(lang = 'en') {
-    if (lang === 'he') {
-      return this.sefiraHe();
-    } else if (lang === 'translit') {
-      return this.sefiraTranslit();
-    } else {
-      const week = sefirot[this.weekNumber];
-      const dayWithinWeek = sefirot[this.daysWithinWeeks];
-      return `${dayWithinWeek} within ${week}`;
+    if (lang !== 'he' && lang !== 'translit') {
+      lang = 'en';
     }
-  }
-  /**
-   * @private
-   * @return {string}
-   */
-  sefiraTranslit() {
-    const weekNum = this.weekNumber;
-    const translitWeek = sefirotTranslit[weekNum];
-    const translitDayWithinWeek = sefirotTranslit[this.daysWithinWeeks];
-    const translitPrefix = weekNum === 2 || weekNum === 6 ? 'shebi' : `sheb'`;
-    return `${translitDayWithinWeek} ${translitPrefix}${translitWeek}`;
-  }
-  /**
-   * @private
-   * @return {string}
-   */
-  sefiraHe() {
-    const weekNum = this.weekNumber;
-    const week = sefirot[weekNum];
-    const dayWithinWeek = sefirot[this.daysWithinWeeks];
-    const heWeek = Locale.gettext(week, 'he');
-    const heDayWithinWeek = Locale.gettext(dayWithinWeek, 'he');
-    const hePrefix = weekNum === 2 || weekNum === 6 ? 'שֶׁבִּ' : 'שֶׁבְּ';
-    return `${heDayWithinWeek} ${hePrefix}${heWeek}`.normalize();
+    return omerSefira(this.omer, lang);
   }
   /**
    * @todo use gettext()
@@ -8479,16 +8546,7 @@ class OmerEvent extends Event {
   /** @return {string} */
   getEmoji() {
     if (typeof this.emoji === 'string') return this.emoji;
-    const number = this.omer;
-    if (number <= 20) {
-      return String.fromCodePoint(9312 + number - 1);
-    } else if (number <= 35) {
-      // between 21 and 35 inclusive
-      return String.fromCodePoint(12881 + number - 21);
-    } else {
-      // between 36 and 49 inclusive
-      return String.fromCodePoint(12977 + number - 36);
-    }
+    return omerEmoji(this.omer);
   }
   /** @return {number} */
   getWeeks() {
@@ -8509,23 +8567,12 @@ class OmerEvent extends Event {
       locale = locale.toLowerCase();
     }
     if (locale === 'he') {
-      return getTodayIsHe(this.omer);
+      return omerTodayIs(this.omer, 'he');
     } else if (locale === 'he-x-nonikud') {
-      return Locale.hebrewStripNikkud(getTodayIsHe(this.omer));
-    }
-    const totalDaysStr = this.omer === 1 ? 'day' : 'days';
-    let str = `Today is ${this.omer} ${totalDaysStr}`;
-    if (this.weekNumber > 1 || this.omer === 7) {
-      const day7 = this.daysWithinWeeks === 7;
-      const numWeeks = day7 ? this.weekNumber : this.weekNumber - 1;
-      const weeksStr = numWeeks === 1 ? 'week' : 'weeks';
-      str += `, which is ${numWeeks} ${weeksStr}`;
-      if (!day7) {
-        const daysStr = this.daysWithinWeeks === 1 ? 'day' : 'days';
-        str += ` and ${this.daysWithinWeeks} ${daysStr}`;
-      }
+      const str = omerTodayIs(this.omer, 'he');
+      return Locale.hebrewStripNikkud(str);
     }
-    return str + ' of the Omer';
+    return omerTodayIs(this.omer, 'en');
   }
   /** @return {string} */
   url() {
@@ -8533,79 +8580,6 @@ class OmerEvent extends Event {
   }
 }
 
-// adapted from pip hdate package (GPL)
-// https://github.com/py-libhdate/py-libhdate/blob/master/hdate/date.py
-
-const tens = ['', 'עֲשָׂרָה', 'עֶשְׂרִים', 'שְׁלוֹשִׁים', 'אַרְבָּעִים'];
-const ones = ['', 'אֶחָד', 'שְׁנַיִם', 'שְׁלוֹשָׁה', 'אַרְבָּעָה', 'חֲמִשָׁה', 'שִׁשָׁה', 'שִׁבְעָה', 'שְׁמוֹנָה', 'תִּשְׁעָה'];
-const shnei = 'שְׁנֵי';
-const yamim = 'יָמִים';
-const shneiYamim = shnei + ' ' + yamim;
-const shavuot = 'שָׁבוּעוֹת';
-const yom = 'יוֹם';
-const yomEchad = yom + ' ' + ones[1];
-
-/**
- * @private
- * @param {number} omer
- * @return {string}
- */
-function getTodayIsHe(omer) {
-  const ten = Math.floor(omer / 10);
-  const one = omer % 10;
-  let str = 'הַיוֹם ';
-  if (10 < omer && omer < 20) {
-    str += ones[one] + ' עָשָׂר';
-  } else if (omer > 9) {
-    str += ones[one];
-    if (one) {
-      str += ' וְ';
-    }
-  }
-  if (omer > 2) {
-    if (omer > 20 || omer === 10 || omer === 20) {
-      str += tens[ten];
-    }
-    if (omer < 11) {
-      str += ones[one] + ' ' + yamim + ' ';
-    } else {
-      str += ' ' + yom + ' ';
-    }
-  } else if (omer === 1) {
-    str += yomEchad + ' ';
-  } else {
-    // omer == 2
-    str += shneiYamim + ' ';
-  }
-  if (omer > 6) {
-    str = str.trim(); // remove trailing space before comma
-    str += ', שְׁהֵם ';
-    const weeks = Math.floor(omer / 7);
-    const days = omer % 7;
-    if (weeks > 2) {
-      str += ones[weeks] + ' ' + shavuot + ' ';
-    } else if (weeks == 1) {
-      str += 'שָׁבוּעַ' + ' ' + ones[1] + ' ';
-    } else {
-      // weeks == 2
-      str += shnei + ' ' + shavuot + ' ';
-    }
-    if (days) {
-      str += 'וְ';
-      if (days > 2) {
-        str += ones[days] + ' ' + yamim + ' ';
-      } else if (days == 1) {
-        str += yomEchad + ' ';
-      } else {
-        // days == 2
-        str += shneiYamim + ' ';
-      }
-    }
-  }
-  str += 'לָעוֹמֶר';
-  return str.normalize();
-}
-
 class QuickLRU extends Map {
 	#size = 0;
 	#cache = new Map();
@@ -10379,7 +10353,7 @@ class DailyLearning {
 }
 
 // DO NOT EDIT THIS AUTO-GENERATED FILE!
-const version = '5.3.2';
+const version = '5.3.4';
 
 const NONE$1 = 0;
 const HALF = 1;