@hebcal/core 5.3.4 → 5.3.5

package/dist/index.cjs

@@ -1,4 +1,4 @@
-/*! @hebcal/core v5.3.4 */
+/*! @hebcal/core v5.3.5 */
 'use strict';
 
 /* eslint-disable @typescript-eslint/no-namespace, no-inner-declarations */
@@ -11,29 +11,29 @@ 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 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;
@@ -44,95 +44,101 @@ const ABS_2SEP1752 = 639785;
  */
 exports.greg = void 0;
 (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) {
-    // 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}`);
+    /**
+     * 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));
     }
-    const abs = toFixed(date.getFullYear(), date.getMonth() + 1, date.getDate());
-    /*
-    if (abs < ABS_14SEP1752 && abs > ABS_2SEP1752) {
-      throw new RangeError(`Invalid Date: ${date}`);
+    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];
     }
-    */
-    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.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);
     }
-    abs = Math.trunc(abs);
-    /*
-    if (abs < ABS_14SEP1752 && abs > ABS_2SEP1752) {
-      throw new RangeError(`Invalid Date: ${abs}`);
+    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);
     }
-    */
-    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;
+    /**
+     * 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;
+    }
+    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;
+    }
+    greg.abs2greg = abs2greg;
 })(exports.greg || (exports.greg = {}));
 
 /*
@@ -157,40 +163,56 @@ 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)
@@ -199,9 +221,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.
@@ -213,32 +235,33 @@ 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);
+        }
+        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);
+    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
@@ -246,27 +269,23 @@ 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
@@ -274,7 +293,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)
@@ -282,7 +301,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)
@@ -291,19 +310,22 @@ 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,
@@ -312,12 +334,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
@@ -326,13 +348,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
@@ -341,25 +363,29 @@ 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.
@@ -369,7 +395,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
@@ -377,7 +403,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
@@ -385,7 +411,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
@@ -393,116 +419,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;
-    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;
+    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.TISHREI;
+            return months.IYYAR;
         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;
+            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;
+        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;
         case 'ש':
-          return months.TISHREI;
-      }
-      break;
-  }
-  throw new RangeError(`Unable to parse month name: ${monthName}`);
+            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}`);
 }
 
 const NISAN$3 = months.NISAN;
@@ -518,140 +544,158 @@ const ADAR_II$1 = months.ADAR_II;
  * @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 (exports.greg.isDate(obj)) {
-    const abs = exports.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 (exports.greg.isDate(obj)) {
+        const abs = exports.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;
-      }
+    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;
     }
-    digits.push(i);
-    num -= i;
-  }
-  return digits;
+    return digits;
 }
 /**
  * Converts a numerical value to a string of Hebrew letters.
@@ -668,31 +712,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);
+    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;
     }
-    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;
+    const digits = num2digits(num1 % 1000);
+    if (digits.length === 1) {
+        return str + num2heb.get(digits[0]) + GERESH;
     }
-    str += num2heb.get(digits[i]);
-  }
-  return str;
+    for (let i = 0; i < digits.length; i++) {
+        if (i + 1 === digits.length) {
+            str += GERSHAYIM;
+        }
+        str += num2heb.get(digits[i]);
+    }
+    return str;
 }
 /**
  * Converts a string of Hebrew letters to a numerical value.
@@ -705,48 +749,75 @@ 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;
+    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']
-  }
+    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}`);
-  }
+    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];
+    const weekNum = Math.floor((omerDay - 1) / 7) + 1;
+    const daysWithinWeeks = omerDay % 7 || 7;
+    return [weekNum, daysWithinWeeks];
 }
 /**
  * Returns the sefira. For example, on day 8
@@ -758,13 +829,13 @@ function getWeeks(omerDay) {
  * @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();
+    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
@@ -774,35 +845,48 @@ function omerSefira(omerDay, lang) {
  *  or `הַיוֹם עֲשָׂרָה יָמִים, שְׁהֵם שָׁבוּעַ אֶחָד וְשְׁלוֹשָׁה יָמִים לָעוֹמֶר`
  */
 function omerTodayIs(omerDay, lang) {
-  checkDay(omerDay);
-  if (lang === 'en') {
-    return omerTodayIsEn(omerDay);
-  } else if (lang === 'he') {
-    return omerTodayIsHe(omerDay);
-  } else {
-    return undefined;
-  }
+    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}`;
+    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';
+    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 ones = [
+    '',
+    'אֶחָד',
+    'שְׁנַיִם',
+    'שְׁלוֹשָׁה',
+    'אַרְבָּעָה',
+    'חֲמִשָּׁה',
+    'שִׁשָּׁה',
+    'שִׁבְעָה',
+    'שְׁמוֹנָה',
+    'תִּשְׁעָה',
+];
 const shnei = 'שְׁנֵי';
 const yamim = 'יָמִים';
 const shneiYamim = shnei + ' ' + yamim;
@@ -810,66 +894,76 @@ 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 + ' ';
+    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 ? 'וּ' : 'וְ';
+        }
     }
-  } 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) {
+    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 {
-        // days == 2
+    }
+    else {
+        // omer == 2
         str += shneiYamim + ' ';
-      }
     }
-  }
-  str += 'לָעֽוֹמֶר';
-  return str.normalize();
+    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 + ' ';
+            }
+        }
+    }
+    str += 'לָעֽוֹמֶר';
+    return str.normalize();
 }
 /**
  * Returns an emoji number symbol with a circle, for example `㊲`
@@ -878,16 +972,18 @@ function omerTodayIsHe(omerDay) {
  * @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);
-  }
+    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 = {
@@ -10355,7 +10451,7 @@ class DailyLearning {
 }
 
 // DO NOT EDIT THIS AUTO-GENERATED FILE!
-const version = '5.3.4';
+const version = '5.3.5';
 
 const NONE$1 = 0;
 const HALF = 1;