@hebcal/core 3.39.2 → 3.41.1

package/dist/hdate.mjs

@@ -1,116 +1,66 @@
-/*! @hebcal/core v3.39.2 */
+/*! @hebcal/core v3.41.1 */
 const GERESH = '׳';
 const GERSHAYIM = '״';
+
 /**
  * @private
  * @param {number} num
  * @return {string}
  */
-
 function num2heb(num) {
   switch (num) {
-    case 1:
-      return 'א';
-
-    case 2:
-      return 'ב';
-
-    case 3:
-      return 'ג';
-
-    case 4:
-      return 'ד';
-
-    case 5:
-      return 'ה';
-
-    case 6:
-      return 'ו';
-
-    case 7:
-      return 'ז';
-
-    case 8:
-      return 'ח';
-
-    case 9:
-      return 'ט';
-
-    case 10:
-      return 'י';
-
-    case 20:
-      return 'כ';
-
-    case 30:
-      return 'ל';
-
-    case 40:
-      return 'מ';
-
-    case 50:
-      return 'נ';
-
-    case 60:
-      return 'ס';
-
-    case 70:
-      return 'ע';
-
-    case 80:
-      return 'פ';
-
-    case 90:
-      return 'צ';
-
-    case 100:
-      return 'ק';
-
-    case 200:
-      return 'ר';
-
-    case 300:
-      return 'ש';
-
-    case 400:
-      return 'ת';
-
-    default:
-      return '*INVALID*';
+    case 1: return 'א';
+    case 2: return 'ב';
+    case 3: return 'ג';
+    case 4: return 'ד';
+    case 5: return 'ה';
+    case 6: return 'ו';
+    case 7: return 'ז';
+    case 8: return 'ח';
+    case 9: return 'ט';
+    case 10: return 'י';
+    case 20: return 'כ';
+    case 30: return 'ל';
+    case 40: return 'מ';
+    case 50: return 'נ';
+    case 60: return 'ס';
+    case 70: return 'ע';
+    case 80: return 'פ';
+    case 90: return 'צ';
+    case 100: return 'ק';
+    case 200: return 'ר';
+    case 300: return 'ש';
+    case 400: return 'ת';
+    default: return '*INVALID*';
   }
 }
+
 /**
  * @private
  * @param {number} num
  * @return {number[]}
  */
-
-
 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;
   }
-
   return digits;
 }
+
 /**
  * Converts a numerical value to a string of Hebrew letters.
  *
@@ -125,42 +75,30 @@ function num2digits(num) {
  * @param {number} number
  * @return {string}
  */
-
-
 function gematriya(number) {
   const num = parseInt(number, 10);
-
   if (!num) {
     throw new TypeError(`invalid parameter to gematriya ${number}`);
   }
-
   let str = '';
   const thousands = Math.floor(num / 1000);
-
   if (thousands > 0 && thousands !== 5) {
     const tdigits = num2digits(thousands);
-
     for (let i = 0; i < tdigits.length; i++) {
       str += num2heb(tdigits[i]);
     }
-
     str += GERESH;
   }
-
   const digits = num2digits(num % 1000);
-
   if (digits.length == 1) {
     return str + num2heb(digits[0]) + GERESH;
   }
-
   for (let i = 0; i < digits.length; i++) {
     if (i + 1 === digits.length) {
       str += GERSHAYIM;
     }
-
     str += num2heb(digits[i]);
   }
-
   return str;
 }
 
@@ -171,40 +109,42 @@ function gematriya(number) {
 /** @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
  * @param {number} x
  * @param {number} y
  * @return {number}
  */
-
 function mod(x, y) {
   return x - y * Math.floor(x / y);
 }
+
 /**
  * @private
  * @param {number} x
  * @param {number} y
  * @return {number}
  */
-
 function quotient(x, y) {
   return Math.floor(x / y);
 }
+
 /**
  * Returns true if the Gregorian year is a leap year
  * @private
  * @param {number} year Gregorian year
  * @return {boolean}
  */
-
-
 function isLeapYear$1(year) {
   return !(year % 4) && (!!(year % 100) || !(year % 400));
 }
+
 /**
  * Number of days in the Gregorian month for given year
  * @private
@@ -212,71 +152,68 @@ function isLeapYear$1(year) {
  * @param {number} year Gregorian year
  * @return {number}
  */
-
 function daysInMonth$1(month, year) {
   // 1 based months
   return monthLengths[+isLeapYear$1(year)][month];
 }
+
 /**
  * Returns true if the object is a Javascript Date
  * @private
  * @param {Object} obj
  * @return {boolean}
  */
-
 function isDate(obj) {
   return typeof obj === 'object' && Date.prototype === obj.__proto__;
 }
+
 /**
  * Returns number of days since January 1 of that year
  * @private
  * @param {Date} date Gregorian date
  * @return {number}
  */
-
 function dayOfYear(date) {
   if (!isDate(date)) {
     throw new TypeError(`Argument not a Date: ${date}`);
   }
-
-  let doy = date.getDate() + 31 * date.getMonth();
-
-  if (date.getMonth() > 1) {
+  const month = date.getMonth();
+  let doy = date.getDate() + 31 * month;
+  if (month > 1) {
     // FEB
-    doy -= Math.floor((4 * (date.getMonth() + 1) + 23) / 10);
-
+    doy -= Math.floor((4 * (month + 1) + 23) / 10);
     if (isLeapYear$1(date.getFullYear())) {
       doy++;
     }
   }
-
   return doy;
 }
+
 /**
  * Converts Gregorian date to absolute R.D. (Rata Die) days
  * @private
  * @param {Date} date Gregorian date
  * @return {number}
  */
-
 function greg2abs(date) {
   if (!isDate(date)) {
     throw new TypeError(`Argument not a Date: ${date}`);
   }
-
   const year = date.getFullYear() - 1;
-  return dayOfYear(date) + // days this year
-  365 * year + ( // + days in prior years
-  Math.floor(year / 4) - // + Julian Leap years
-  Math.floor(year / 100) + // - century years
-  Math.floor(year / 400)); // + Gregorian leap years
+  return (
+    dayOfYear(date) + // days this year
+    365 * year + // + days in prior years
+    (Math.floor(year / 4) - // + Julian Leap years
+    Math.floor(year / 100) + // - century years
+    Math.floor(year / 400))
+  ); // + Gregorian leap years
 }
+
 /**
  * @private
  * @param {number} abs - R.D. number of days
  * @return {number}
  */
-
 function yearFromFixed(abs) {
   const l0 = abs - 1;
   const n400 = quotient(l0, 146097);
@@ -289,6 +226,7 @@ function yearFromFixed(abs) {
   const year = 400 * n400 + 100 * n100 + 4 * n4 + n1;
   return n100 != 4 && n1 != 4 ? year + 1 : year;
 }
+
 /**
  * @private
  * @param {number} year
@@ -296,12 +234,17 @@ function yearFromFixed(abs) {
  * @param {number} day
  * @return {number}
  */
-
-
 function toFixed(year, month, day) {
   const py = year - 1;
-  return 0 + 365 * py + quotient(py, 4) - quotient(py, 100) + quotient(py, 400) + quotient(367 * month - 362, 12) + Math.floor(month <= 2 ? 0 : isLeapYear$1(year) ? -1 : -2) + day;
+  return 365 * py +
+    quotient(py, 4) -
+    quotient(py, 100) +
+    quotient(py, 400) +
+    quotient((367 * month - 362), 12) +
+    (month <= 2 ? 0 : (isLeapYear$1(year) ? -1 : -2)) +
+    day;
 }
+
 /**
  * Converts from Rata Die (R.D. number) to Gregorian date.
  * See the footnote on page 384 of ``Calendrical Calculations, Part II:
@@ -312,25 +255,20 @@ function toFixed(year, month, day) {
  * @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);
   const year = yearFromFixed(abs);
   const priorDays = abs - toFixed(year, 1, 1);
-  const correction = abs < toFixed(year, 3, 1) ? 0 : isLeapYear$1(year) ? 1 : 2;
-  const month = quotient(12 * (priorDays + correction) + 373, 367);
+  const correction = abs < toFixed(year, 3, 1) ? 0 : (isLeapYear$1(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;
 }
 
@@ -354,67 +292,78 @@ function abs2greg(abs) {
     You should have received a copy of the GNU General Public License
     along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
+
 /**
  * Gregorian date helper functions.
  */
-
 class greg {
   /**
    * Long names of the Gregorian months (1='January', 12='December')
    * @readonly
    * @type {string[]}
    */
-  static monthNames = ['', 'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
+  static monthNames = [
+    '',
+    'January',
+    'February',
+    'March',
+    'April',
+    'May',
+    'June',
+    'July',
+    'August',
+    'September',
+    'October',
+    'November',
+    'December',
+  ];
+
   /**
    * Returns true if the Gregorian year is a leap year
    * @param {number} year Gregorian year
    * @return {boolean}
    */
-
   static isLeapYear(year) {
     return isLeapYear$1(year);
   }
+
   /**
    * 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}
    */
-
-
   static daysInMonth(month, year) {
     return daysInMonth$1(month, year);
   }
+
   /**
    * Returns true if the object is a Javascript Date
    * @param {Object} obj
    * @return {boolean}
    */
-
-
   static isDate(obj) {
     return isDate(obj);
   }
+
   /**
    * Returns number of days since January 1 of that year
    * @param {Date} date Gregorian date
    * @return {number}
    */
-
-
   static dayOfYear(date) {
     return dayOfYear(date);
   }
+
   /**
    * Converts Gregorian date to absolute R.D. (Rata Die) days
    * @param {Date} date Gregorian date
    * @return {number}
    */
-
-
   static greg2abs(date) {
     return greg2abs(date);
   }
+
   /**
    * Converts from Rata Die (R.D. number) to Gregorian date.
    * See the footnote on page 384 of ``Calendrical Calculations, Part II:
@@ -424,28 +373,22 @@ class greg {
    * @param {number} theDate - R.D. number of days
    * @return {Date}
    */
-
-
   static abs2greg(theDate) {
     return abs2greg(theDate);
   }
-
 }
 
 const noopLocale = {
-  headers: {
-    'plural-forms': 'nplurals=2; plural=(n!=1);'
-  },
-  contexts: {
-    '': {}
-  }
+  headers: {'plural-forms': 'nplurals=2; plural=(n!=1);'},
+  contexts: {'': {}},
 };
 const alias = {
   'h': 'he',
   'a': 'ashkenazi',
   's': 'en',
-  '': 'en'
+  '': 'en',
 };
+
 /**
  * A locale in Hebcal is used for translations/transliterations of
  * holidays. `@hebcal/core` supports four locales by default
@@ -454,16 +397,14 @@ const alias = {
  * * `he` - Hebrew (e.g. "שַׁבָּת")
  * * `he-x-NoNikud` - Hebrew without nikud (e.g. "שבת")
  */
-
 class Locale {
   /** @private */
   static locales = Object.create(null);
   /** @private */
-
   static activeLocale = null;
   /** @private */
-
   static activeName = null;
+
   /**
    * Returns translation only if `locale` offers a non-empty translation for `id`.
    * Otherwise, returns `undefined`.
@@ -471,49 +412,42 @@ class Locale {
    * @param {string} [locale] Optional locale name (i.e: `'he'`, `'fr'`). Defaults to active locale.
    * @return {string}
    */
-
   static lookupTranslation(id, locale) {
     const locale0 = locale && locale.toLowerCase();
-    const loc = typeof locale == 'string' && this.locales[locale0] || this.activeLocale;
+    const loc = (typeof locale == 'string' && this.locales[locale0]) || this.activeLocale;
     const array = loc[id];
-
     if (array && array.length && array[0].length) {
       return array[0];
     }
-
     return undefined;
   }
+
   /**
    * By default, if no translation was found, returns `id`.
    * @param {string} id Message ID to translate
    * @param {string} [locale] Optional locale name (i.e: `'he'`, `'fr'`). Defaults to active locale.
    * @return {string}
    */
-
-
   static gettext(id, locale) {
     const text = this.lookupTranslation(id, locale);
-
     if (typeof text == 'undefined') {
       return id;
     }
-
     return text;
   }
+
   /**
    * Register locale translations.
    * @param {string} locale Locale name (i.e.: `'he'`, `'fr'`)
    * @param {LocaleDate} data parsed data from a `.po` file.
    */
-
-
   static addLocale(locale, data) {
     if (typeof data.contexts !== 'object' || typeof data.contexts[''] !== 'object') {
       throw new TypeError(`Locale '${locale}' invalid compact format`);
     }
-
     this.locales[locale.toLowerCase()] = data.contexts[''];
   }
+
   /**
    * Activates a locale. Throws an error if the locale has not been previously added.
    * After setting the locale to be used, all strings marked for translations
@@ -521,53 +455,44 @@ class Locale {
    * @param {string} locale Locale name (i.e: `'he'`, `'fr'`)
    * @return {LocaleData}
    */
-
-
   static useLocale(locale) {
     const locale0 = locale.toLowerCase();
     const obj = this.locales[locale0];
-
     if (!obj) {
       throw new RangeError(`Locale '${locale}' not found`);
     }
-
     this.activeName = alias[locale0] || locale0;
     this.activeLocale = obj;
     return this.activeLocale;
   }
+
   /**
    * Returns the name of the active locale (i.e. 'he', 'ashkenazi', 'fr')
    * @return {string}
    */
-
-
   static getLocaleName() {
     return this.activeName;
   }
+
   /**
    * Returns the names of registered locales
    * @return {string[]}
    */
-
-
   static getLocaleNames() {
     return Object.keys(this.locales).sort();
   }
+
   /**
    * @param {number} n
    * @param {string} [locale] Optional locale name (i.e: `'he'`, `'fr'`). Defaults to active locale.
    * @return {string}
    */
-
-
   static ordinal(n, locale) {
     const locale1 = locale && locale.toLowerCase();
     const locale0 = locale1 || this.activeName;
-
     if (!locale0) {
       return this.getEnOrdinal(n);
     }
-
     switch (locale0) {
       case 'en':
       case 's':
@@ -577,43 +502,38 @@ class Locale {
       case 'ashkenazi_poylish':
       case 'ashkenazi_standard':
         return this.getEnOrdinal(n);
-
       case 'es':
         return n + 'º';
-
       case 'h':
       case 'he':
       case 'he-x-nonikud':
         return String(n);
-
       default:
         return n + '.';
     }
   }
+
   /**
    * @private
    * @param {number} n
    * @return {string}
    */
-
-
   static getEnOrdinal(n) {
     const s = ['th', 'st', 'nd', 'rd'];
     const v = n % 100;
     return n + (s[(v - 20) % 10] || s[v] || s[0]);
   }
+
   /**
    * Removes nekudot from Hebrew string
    * @param {string} str
    * @return {string}
    */
-
-
   static hebrewStripNikkud(str) {
     return str.replace(/[\u0590-\u05bd]/g, '').replace(/[\u05bf-\u05c7]/g, '');
   }
-
 }
+
 Locale.addLocale('en', noopLocale);
 Locale.addLocale('s', noopLocale);
 Locale.addLocale('', noopLocale);
@@ -622,77 +542,93 @@ Locale.useLocale('en');
 /*
  * More minimal HDate
  */
-const NISAN$1 = 1;
-const IYYAR = 2; // const SIVAN = 3;
-
-const TAMUZ = 4; // const AV = 5;
 
+const NISAN$1 = 1;
+const IYYAR = 2;
+// const SIVAN = 3;
+const TAMUZ = 4;
+// const AV = 5;
 const ELUL = 6;
 const TISHREI = 7;
 const CHESHVAN$1 = 8;
 const KISLEV$1 = 9;
-const TEVET$1 = 10; // const SHVAT = 11;
-
+const TEVET$1 = 10;
+// const SHVAT = 11;
 const ADAR_I$1 = 12;
 const ADAR_II$1 = 13;
+
 /**
  * Hebrew months of the year (NISAN=1, TISHREI=7)
  * @readonly
  * @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
+  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 = Object.create(null);
-const EPOCH = -1373428; // Avg year length in the cycle (19 solar years with 235 lunar months)
 
+const EPOCH = -1373428;
+// Avg year length in the cycle (19 solar years with 235 lunar months)
 const AVG_HEBYEAR_DAYS = 365.24682220597794;
+
 /**
  * Converts Hebrew date to R.D. (Rata Die) fixed days.
  * R.D. 1 is the imaginary date Monday, January 1, 1 on the Gregorian
@@ -703,7 +639,6 @@ const AVG_HEBYEAR_DAYS = 365.24682220597794;
  * @param {number} day Hebrew date (1-30)
  * @return {number}
  */
-
 function hebrew2abs(year, month, day) {
   let tempabs = day;
 
@@ -711,7 +646,6 @@ function hebrew2abs(year, month, day) {
     for (let m = TISHREI; m <= monthsInYear(year); m++) {
       tempabs += daysInMonth(m, year);
     }
-
     for (let m = NISAN$1; m < month; m++) {
       tempabs += daysInMonth(m, year);
     }
@@ -723,70 +657,64 @@ function hebrew2abs(year, month, day) {
 
   return EPOCH + elapsedDays(year) + tempabs - 1;
 }
+
 /**
  * @private
  * @param {number} year
  * @return {number}
  */
-
 function newYear(year) {
   return EPOCH + elapsedDays(year);
 }
+
 /**
  * Converts absolute R.D. days to Hebrew date
  * @private
  * @param {number} abs absolute R.D. days
  * @return {SimpleHebrewDate}
  */
-
-
 function abs2hebrew(abs) {
   if (typeof abs !== 'number' || isNaN(abs)) {
     throw new TypeError(`invalid parameter to abs2hebrew ${abs}`);
   }
+  abs = Math.trunc(abs);
 
-  abs = Math.trunc(abs); // first, quickly approximate year
-
+  // 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;
 
+  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
-  };
+  return {yy: year, mm: month, dd: day};
 }
+
 /**
  * Returns true if Hebrew year is a leap year
  * @private
  * @param {number} year Hebrew year
  * @return {boolean}
  */
-
 function isLeapYear(year) {
   return (1 + year * 7) % 19 < 7;
 }
+
 /**
  * Number of months in this Hebrew year (either 12 or 13 depending on leap year)
  * @private
  * @param {number} year Hebrew year
  * @return {number}
  */
-
 function monthsInYear(year) {
   return 12 + isLeapYear(year); // boolean is cast to 1 or 0
 }
+
 /**
  * Number of days in Hebrew month in a given year (29 or 30)
  * @private
@@ -794,7 +722,6 @@ function monthsInYear(year) {
  * @param {number} year Hebrew year
  * @return {number}
  */
-
 function daysInMonth(month, year) {
   switch (month) {
     case IYYAR:
@@ -804,13 +731,15 @@ function daysInMonth(month, year) {
     case ADAR_II$1:
       return 29;
   }
-
-  if (month === ADAR_I$1 && !isLeapYear(year) || month === CHESHVAN$1 && !longCheshvan(year) || month === KISLEV$1 && shortKislev(year)) {
+  if ((month === ADAR_I$1 && !isLeapYear(year)) ||
+      (month === CHESHVAN$1 && !longCheshvan(year)) ||
+      (month === KISLEV$1 && shortKislev(year))) {
     return 29;
   } else {
     return 30;
   }
 }
+
 /**
  * Returns a transliterated string name of Hebrew month in year,
  * for example 'Elul' or 'Cheshvan'.
@@ -819,14 +748,13 @@ function daysInMonth(month, year) {
  * @param {number} year Hebrew year
  * @return {string}
  */
-
 function getMonthName(month, year) {
   if (typeof month !== 'number' || isNaN(month) || 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
  * conjunction of Tishrei in Hebrew YEAR
@@ -834,11 +762,11 @@ function getMonthName(month, year) {
  * @param {number} year Hebrew year
  * @return {number}
  */
-
 function elapsedDays(year) {
   const elapsed = edCache[year] = edCache[year] || elapsedDays0(year);
   return elapsed;
 }
+
 /**
  * Days from sunday prior to start of Hebrew calendar to mean
  * conjunction of Tishrei in Hebrew YEAR
@@ -846,20 +774,30 @@ function elapsedDays(year) {
  * @param {number} year Hebrew year
  * @return {number}
  */
-
 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
+      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 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);
-  const altDay = day + (parts >= 19440 || 2 === day % 7 && parts >= 9924 && !isLeapYear(year) || 1 === day % 7 && parts >= 16789 && isLeapYear(prevYear));
+  const altDay = day +
+      (parts >= 19440 ||
+        (2 === day % 7 && parts >= 9924 && !isLeapYear(year)) ||
+        (1 === day % 7 && parts >= 16789 && isLeapYear(prevYear)));
+
   return altDay + (altDay % 7 === 0 || altDay % 7 === 3 || altDay % 7 === 5);
 }
+
 /**
  * Number of days in the hebrew YEAR.
  * A common Hebrew calendar year can have a length of 353, 354 or 355 days
@@ -868,28 +806,26 @@ function elapsedDays0(year) {
  * @param {number} year Hebrew year
  * @return {number}
  */
-
-
 function daysInYear(year) {
   return elapsedDays(year + 1) - elapsedDays(year);
 }
+
 /**
  * true if Cheshvan is long in Hebrew year
  * @private
  * @param {number} year Hebrew year
  * @return {boolean}
  */
-
 function longCheshvan(year) {
   return daysInYear(year) % 10 === 5;
 }
+
 /**
  * true if Kislev is short in Hebrew year
  * @private
  * @param {number} year Hebrew year
  * @return {boolean}
  */
-
 function shortKislev(year) {
   return daysInYear(year) % 10 === 3;
 }
@@ -915,6 +851,7 @@ function shortKislev(year) {
     along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+// eslint-disable-next-line require-jsdoc
 function throwTypeError(msg) {
   throw new TypeError(msg);
 }
@@ -923,18 +860,9 @@ const UNITS_DAY = 'day';
 const UNITS_WEEK = 'week';
 const UNITS_MONTH = 'month';
 const UNITS_YEAR = 'year';
-const UNITS_SINGLE = {
-  d: UNITS_DAY,
-  w: UNITS_WEEK,
-  M: UNITS_MONTH,
-  y: UNITS_YEAR
-};
-const UNITS_VALID = {
-  day: UNITS_DAY,
-  week: UNITS_WEEK,
-  month: UNITS_MONTH,
-  year: UNITS_YEAR
-};
+const UNITS_SINGLE = {d: UNITS_DAY, w: UNITS_WEEK, M: UNITS_MONTH, y: UNITS_YEAR};
+const UNITS_VALID = {day: UNITS_DAY, week: UNITS_WEEK, month: UNITS_MONTH, year: UNITS_YEAR};
+
 /**
  * A simple Hebrew date object with numeric fields `yy`, `mm`, and `dd`
  * @typedef {Object} SimpleHebrewDate
@@ -945,7 +873,6 @@ const UNITS_VALID = {
  */
 
 /** Represents a Hebrew date */
-
 class HDate {
   /**
    * Create a Hebrew date. There are 3 basic forms for the `HDate()` constructor.
@@ -981,10 +908,8 @@ class HDate {
     if (arguments.length == 2 || arguments.length > 3) {
       throw new TypeError('HDate constructor requires 0, 1 or 3 arguments');
     }
-
     if (arguments.length == 3) {
       // Hebrew day, Hebrew month, Hebrew year
-
       /**
        * @private
        * @type {number}
@@ -994,56 +919,44 @@ class HDate {
        * @private
        * @type {number}
        */
-
       year = parseInt(year, 10);
-
       if (isNaN(year)) {
         throw new TypeError(`HDate called with bad year argument: ${year}`);
       }
-
       this.year = year;
       this.setMonth(month); // will throw if we can't parse
-
       day = parseInt(day, 10);
-
       if (isNaN(day)) {
         throw new TypeError(`HDate called with bad day argument: ${day}`);
       }
-
       this.setDate(day);
     } else {
       // 0 arguments
       if (typeof day === 'undefined') {
         day = new Date();
-      } // 1 argument
-
-
-      const abs0 = typeof day === 'number' && !isNaN(day) ? day : isDate(day) ? greg2abs(day) : HDate.isHDate(day) ? {
-        dd: day.day,
-        mm: day.month,
-        yy: day.year
-      } : throwTypeError(`HDate called with bad argument: ${day}`);
+      }
+      // 1 argument
+      const abs0 = (typeof day === 'number' && !isNaN(day)) ? day :
+        isDate(day) ? greg2abs(day) :
+        HDate.isHDate(day) ? {dd: day.day, mm: day.month, yy: day.year} :
+        throwTypeError(`HDate called with bad argument: ${day}`);
       const isNumber = typeof abs0 === 'number';
       const d = isNumber ? abs2hebrew(abs0) : abs0;
       /**
        * @private
        * @type {number}
        */
-
       this.day = d.dd;
       /**
        * @private
        * @type {number}
        */
-
       this.month = d.mm;
       /**
        * @private
        * @type {number}
        */
-
       this.year = d.yy;
-
       if (isNumber) {
         /**
          * @private
@@ -1053,70 +966,64 @@ class HDate {
       }
     }
   }
+
   /**
    * Gets the Hebrew year of this Hebrew date
    * @return {number}
    */
-
-
   getFullYear() {
     return this.year;
   }
+
   /**
    * Tests if this date occurs during a leap year
    * @return {boolean}
    */
-
-
   isLeapYear() {
     return isLeapYear(this.year);
   }
+
   /**
    * Gets the Hebrew month (1=NISAN, 7=TISHREI) of this Hebrew date
    * @return {number}
    */
-
-
   getMonth() {
     return this.month;
   }
+
   /**
    * The Tishrei-based month of the date. 1 is Tishrei, 7 is Nisan, 13 is Elul in a leap year
    * @return {number}
    */
-
-
   getTishreiMonth() {
     const nummonths = monthsInYear(this.getFullYear());
     return (this.getMonth() + nummonths - 6) % nummonths || nummonths;
   }
+
   /**
    * Number of days in the month of this Hebrew date
    * @return {number}
    */
-
-
   daysInMonth() {
     return daysInMonth(this.getMonth(), this.getFullYear());
   }
+
   /**
    * Gets the day within the month (1-30)
    * @return {number}
    */
-
-
   getDate() {
     return this.day;
   }
+
   /**
    * Gets the day of the week. 0=Sunday, 6=Saturday
    * @return {number}
    */
-
-
   getDay() {
     return mod(this.abs(), 7);
   }
+
   /**
    * Sets the year of the date. Returns the object it was called upon.
    * @private
@@ -1124,47 +1031,43 @@ class HDate {
    * @param {number} year
    * @return {HDate}
    */
-
-
   setFullYear(year) {
     this.year = year;
     fix(this);
     return this;
   }
+
   /**
    * Sets the day of the month of the date. Returns the object it was called upon
    * @private
    * @param {number} month
    * @return {HDate}
    */
-
-
   setMonth(month) {
     this.month = HDate.monthNum(month);
     fix(this);
     return this;
   }
+
   /**
    * @private
    * @param {number} date
    * @return {HDate}
    */
-
-
   setDate(date) {
     this.day = date;
     fix(this);
     return this;
   }
+
   /**
    * Converts to Gregorian date
    * @return {Date}
    */
-
-
   greg() {
     return abs2greg(this.abs());
   }
+
   /**
    * Returns R.D. (Rata Die) fixed days.
    * R.D. 1 == Monday, January 1, 1 (Gregorian)
@@ -1172,15 +1075,13 @@ class HDate {
    * https://en.wikipedia.org/wiki/Rata_Die#Dershowitz_and_Reingold
    * @return {number}
    */
-
-
   abs() {
     if (typeof this.abs0 !== 'number') {
       this.abs0 = hebrew2abs(this.year, this.month, this.day);
     }
-
     return this.abs0;
   }
+
   /**
    * Converts Hebrew date to R.D. (Rata Die) fixed days.
    * R.D. 1 is the imaginary date Monday, January 1, 1 on the Gregorian
@@ -1190,31 +1091,28 @@ class HDate {
    * @param {number} day Hebrew date (1-30)
    * @return {number}
    */
-
-
   static hebrew2abs(year, month, day) {
     return hebrew2abs(year, month, day);
   }
+
   /**
    * Converts absolute R.D. days to Hebrew date
    * @private
    * @param {number} abs absolute R.D. days
    * @return {SimpleHebrewDate}
    */
-
-
   static abs2hebrew(abs) {
     return abs2hebrew(abs);
   }
+
   /**
    * Returns a transliterated Hebrew month name, e.g. `'Elul'` or `'Cheshvan'`.
    * @return {string}
    */
-
-
   getMonthName() {
     return getMonthName(this.getMonth(), this.getFullYear());
   }
+
   /**
    * Renders this Hebrew date as a translated or transliterated string,
    * including ordinal e.g. `'15th of Cheshvan, 5769'`.
@@ -1228,16 +1126,13 @@ class HDate {
    * @param {boolean} [showYear=true] Display year (defaults to true).
    * @return {string}
    */
-
-
-  render(locale = null, showYear = true) {
+  render(locale=null, showYear=true) {
     const locale0 = locale || Locale.getLocaleName();
     const day = this.getDate();
     const monthName = Locale.gettext(this.getMonthName(), locale0);
     const nth = Locale.ordinal(day, locale0);
     const dayOf = HDate.getDayOfTranslation(locale0);
     const dateStr = `${nth}${dayOf} ${monthName}`;
-
     if (showYear) {
       const fullYear = this.getFullYear();
       return `${dateStr}, ${fullYear}`;
@@ -1245,13 +1140,12 @@ class HDate {
       return dateStr;
     }
   }
+
   /**
    * @private
    * @param {string} locale
    * @return {string}
    */
-
-
   static getDayOfTranslation(locale) {
     switch (locale) {
       case 'en':
@@ -1260,19 +1154,16 @@ class HDate {
       case 'ashkenazi':
         return ' of';
     }
-
     const ofStr = Locale.lookupTranslation('of', locale);
-
     if (ofStr) {
       return ' ' + ofStr;
     }
-
     if ('ashkenazi' === locale.substring(0, 9)) {
       return ' of';
     }
-
     return '';
   }
+
   /**
    * Renders this Hebrew date in Hebrew gematriya, regardless of locale.
    * @example
@@ -1281,14 +1172,13 @@ class HDate {
    * console.log(hd.renderGematriya()); // 'ט״ו חֶשְׁוָן תשס״ט'
    * @return {string}
    */
-
-
   renderGematriya() {
     const d = this.getDate();
     const m = Locale.gettext(this.getMonthName(), 'he');
     const y = this.getFullYear();
     return gematriya(d) + ' ' + m + ' ' + gematriya(y);
   }
+
   /**
    * Returns an `HDate` representing the a dayNumber before the current date.
    * Sunday=0, Saturday=6
@@ -1297,11 +1187,10 @@ class HDate {
    * @param {number} day day of week
    * @return {HDate}
    */
-
-
   before(day) {
     return onOrBefore(day, this, -1);
   }
+
   /**
    * Returns an `HDate` representing the a dayNumber on or before the current date.
    * Sunday=0, Saturday=6
@@ -1312,11 +1201,10 @@ class HDate {
    * @param {number} dow day of week
    * @return {HDate}
    */
-
-
   onOrBefore(dow) {
     return onOrBefore(dow, this, 0);
   }
+
   /**
    * Returns an `HDate` representing the nearest dayNumber to the current date
    * Sunday=0, Saturday=6
@@ -1326,11 +1214,10 @@ class HDate {
    * @param {number} dow day of week
    * @return {HDate}
    */
-
-
   nearest(dow) {
     return onOrBefore(dow, this, 3);
   }
+
   /**
    * Returns an `HDate` representing the a dayNumber on or after the current date.
    * Sunday=0, Saturday=6
@@ -1341,11 +1228,10 @@ class HDate {
    * @param {number} dow day of week
    * @return {HDate}
    */
-
-
   onOrAfter(dow) {
     return onOrBefore(dow, this, 6);
   }
+
   /**
    * Returns an `HDate` representing the a dayNumber after the current date.
    * Sunday=0, Saturday=6
@@ -1356,29 +1242,26 @@ class HDate {
    * @param {number} day day of week
    * @return {HDate}
    */
-
-
   after(day) {
     return onOrBefore(day, this, 7);
   }
+
   /**
    * Returns the next Hebrew date
    * @return {HDate}
    */
-
-
   next() {
     return new HDate(this.abs() + 1);
   }
+
   /**
    * Returns the previous Hebrew date
    * @return {HDate}
    */
-
-
   prev() {
     return new HDate(this.abs() - 1);
   }
+
   /**
    * Returns a cloned `HDate` object with a specified amount of time added
    *
@@ -1395,46 +1278,39 @@ class HDate {
    * @param {string} [units]
    * @return {HDate}
    */
-
-
-  add(number, units = 'd') {
+  add(number, units='d') {
     number = parseInt(number, 10);
-
     if (!number) {
       return new HDate(this);
     }
-
     units = HDate.standardizeUnits(units);
-
     if (units === UNITS_DAY) {
       return new HDate(this.abs() + number);
     } else if (units === UNITS_WEEK) {
-      return new HDate(this.abs() + 7 * number);
+      return new HDate(this.abs() + (7 * number));
     } else if (units === UNITS_YEAR) {
       return new HDate(this.getDate(), this.getMonth(), this.getFullYear() + number);
     } else if (units === UNITS_MONTH) {
       let hd = new HDate(this);
       const sign = number > 0 ? 1 : -1;
       number = Math.abs(number);
-
       for (let i = 0; i < number; i++) {
-        hd = new HDate(hd.abs() + sign * hd.daysInMonth());
+        hd = new HDate(hd.abs() + (sign * hd.daysInMonth()));
       }
-
       return hd;
     }
   }
+
   /**
    * @private
    * @param {string} units
    * @return {string}
    */
-
-
   static standardizeUnits(units) {
     const full = UNITS_SINGLE[units] || String(units || '').toLowerCase().replace(/s$/, '');
     return UNITS_VALID[full] || throwTypeError(`Invalid units '${units}'`);
   }
+
   /**
    * Returns a cloned `HDate` object with a specified amount of time subracted
    *
@@ -1457,11 +1333,10 @@ class HDate {
    * @param {string} [units]
    * @return {HDate}
    */
-
-
-  subtract(number, units = 'd') {
+  subtract(number, units='d') {
     return this.add(number * -1, units);
   }
+
   /**
    * Returns the difference in days between the two given HDates.
    *
@@ -1479,69 +1354,63 @@ class HDate {
    * @param {HDate} other Hebrew date to compare
    * @return {number}
    */
-
-
   deltaDays(other) {
     if (!HDate.isHDate(other)) {
       throw new TypeError(`Bad argument: ${other}`);
     }
-
     return this.abs() - other.abs();
   }
+
   /**
    * Compares this date to another date, returning `true` if the dates match.
    * @param {HDate} other Hebrew date to compare
    * @return {boolean}
    */
-
-
   isSameDate(other) {
     if (HDate.isHDate(other)) {
-      return this.year == other.year && this.month == other.month && this.day == other.day;
+      return this.year == other.year &&
+        this.month == other.month &&
+        this.day == other.day;
     }
-
     return false;
   }
-  /** @return {string} */
-
 
+  /** @return {string} */
   toString() {
     const day = this.getDate();
     const fullYear = this.getFullYear();
     const monthName = this.getMonthName();
     return `${day} ${monthName} ${fullYear}`;
   }
+
   /**
    * Returns true if Hebrew year is a leap year
    * @param {number} year Hebrew year
    * @return {boolean}
    */
-
-
   static isLeapYear(year) {
     return isLeapYear(year);
   }
+
   /**
    * Number of months in this Hebrew year (either 12 or 13 depending on leap year)
    * @param {number} year Hebrew year
    * @return {number}
    */
-
-
   static monthsInYear(year) {
     return monthsInYear(year);
   }
+
   /**
    * Number of days in Hebrew month in a given year (29 or 30)
    * @param {number} month Hebrew month (e.g. months.TISHREI)
    * @param {number} year Hebrew year
    * @return {number}
    */
-
-
   static daysInMonth(month, year) {
     return daysInMonth(month, year);
   }
+
   /**
    * Returns a transliterated string name of Hebrew month in year,
    * for example 'Elul' or 'Cheshvan'.
@@ -1549,77 +1418,66 @@ class HDate {
    * @param {number} year Hebrew year
    * @return {string}
    */
-
-
   static getMonthName(month, year) {
     return getMonthName(month, year);
   }
+
   /**
    * Returns the Hebrew month number (NISAN=1, TISHREI=7)
    * @param {number|string} month A number, or Hebrew month name string
    * @return {number}
    */
-
-
   static monthNum(month) {
     if (typeof month === 'number') {
       if (isNaN(month) || month > 14) {
         throw new RangeError(`Invalid month number: ${month}`);
       }
-
       return month;
     }
-
-    return month.charCodeAt(0) >= 48 && month.charCodeAt(0) <= 57 ?
-    /* number */
-    parseInt(month, 10) : HDate.monthFromName(month);
+    return month.charCodeAt(0) >= 48 && month.charCodeAt(0) <= 57 ? /* number */
+    parseInt(month, 10) :
+    HDate.monthFromName(month);
   }
+
   /**
    * Number of days in the hebrew YEAR
    * @param {number} year Hebrew year
    * @return {number}
    */
-
-
   static daysInYear(year) {
     return daysInYear(year);
   }
+
   /**
    * true if Cheshvan is long in Hebrew year
    * @param {number} year Hebrew year
    * @return {boolean}
    */
-
-
   static longCheshvan(year) {
     return longCheshvan(year);
   }
+
   /**
    * true if Kislev is short in Hebrew year
    * @param {number} year Hebrew year
    * @return {boolean}
    */
-
-
   static shortKislev(year) {
     return shortKislev(year);
   }
+
   /**
    * Converts Hebrew month string name to numeric
    * @param {string} monthName monthName
    * @return {number}
    */
-
-
   static monthFromName(monthName) {
     if (typeof monthName === 'number') {
       if (isNaN(monthName) || monthName < 1 || monthName > 14) {
         throw new RangeError(`Invalid month name: ${monthName}`);
       }
-
       return monthName;
     }
-
     const c = monthName.toLowerCase();
     /*
     the Hebrew months are unique to their second letter
@@ -1633,7 +1491,8 @@ class HDate {
     Si Sh     Sivan, Shvat
     Ta Ti Te Tamuz, Tishrei, Tevet
     Av Ad    Av, Adar
-     אב אד אי אל   אב אדר אייר אלול
+
+    אב אד אי אל   אב אדר אייר אלול
     ח            חשון
     ט            טבת
     כ            כסלו
@@ -1642,115 +1501,84 @@ class HDate {
     ש            שבט
     תמ תש        תמוז תשרי
     */
-
     switch (c[0]) {
       case 'n':
       case 'נ':
         if (c[1] == 'o') {
-          break;
-          /* this catches "november" */
+          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;
         }
-
       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
+            return months.ADAR_II; // else assume sheini
         }
-
         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
-
+            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}`);
   }
+
   /**
    * Note: Applying this function to d+6 gives us the DAYNAME on or after an
    * absolute day d. Similarly, applying it to d+3 gives the DAYNAME nearest to
@@ -1760,71 +1588,65 @@ class HDate {
    * @param {number} absdate
    * @return {number}
    */
-
-
   static dayOnOrBefore(dayOfWeek, absdate) {
-    return absdate - (absdate - dayOfWeek) % 7;
+    return absdate - ((absdate - dayOfWeek) % 7);
   }
+
   /**
    * Tests if the object is an instance of `HDate`
    * @param {any} obj
    * @return {boolean}
    */
-
-
   static isHDate(obj) {
-    return obj !== null && typeof obj === 'object' && typeof obj.year === 'number' && typeof obj.month === 'number' && typeof obj.day === 'number' && typeof obj.greg === 'function' && typeof obj.abs === 'function';
+    return obj !== null && typeof obj === 'object' &&
+      typeof obj.year === 'number' &&
+      typeof obj.month === 'number' &&
+      typeof obj.day === 'number' &&
+      typeof obj.greg === 'function' &&
+      typeof obj.abs === 'function';
   }
-
 }
+
 /**
  * @private
  * @param {HDate} date
  */
-
 function fix(date) {
   fixMonth(date);
   fixDate(date);
 }
+
 /**
  * @private
  * @param {HDate} date
  */
-
-
 function fixDate(date) {
   if (date.day < 1) {
     if (date.month == months.TISHREI) {
       date.year -= 1;
     }
-
     date.day += daysInMonth(date.month, date.year);
     date.month -= 1;
     fix(date);
   }
-
   if (date.day > daysInMonth(date.month, date.year)) {
     if (date.month === months.ELUL) {
       date.year += 1;
     }
-
     date.day -= daysInMonth(date.month, date.year);
     date.month += 1;
     fix(date);
   }
-
   fixMonth(date);
 }
+
 /**
  * @private
  * @param {HDate} date
  */
-
-
 function fixMonth(date) {
   if (date.month === months.ADAR_II && !date.isLeapYear()) {
     date.month -= 1; // to Adar I
-
     fix(date);
   } else if (date.month < 1) {
     date.month += monthsInYear(date.year);
@@ -1835,9 +1657,9 @@ function fixMonth(date) {
     date.year += 1;
     fix(date);
   }
-
   delete date.abs0;
 }
+
 /**
  * @private
  * @param {number} day
@@ -1845,8 +1667,6 @@ function fixMonth(date) {
  * @param {number} offset
  * @return {HDate}
  */
-
-
 function onOrBefore(day, t, offset) {
   return new HDate(HDate.dayOnOrBefore(day, t.abs() + offset));
 }
@@ -1858,21 +1678,20 @@ const TEVET = months.TEVET;
 const SHVAT = months.SHVAT;
 const ADAR_I = months.ADAR_I;
 const ADAR_II = months.ADAR_II;
+
 /**
  * @private
  * @param {number} hyear Hebrew year
  * @param {Date|HDate} gdate Gregorian or Hebrew date of death
  * @return {HDate} anniversary occurring in hyear
  */
-
 function getYahrzeit_(hyear, gdate) {
   const orig = HDate.isHDate(gdate) ? gdate : new HDate(gdate);
   let hDeath = {
     yy: orig.getFullYear(),
     mm: orig.getMonth(),
-    dd: orig.getDate()
+    dd: orig.getDate(),
   };
-
   if (hyear <= hDeath.yy) {
     // `Hebrew year ${hyear} occurs on or before original date in ${hDeath.yy}`
     return undefined;
@@ -1894,10 +1713,10 @@ function getYahrzeit_(hyear, gdate) {
     // (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
-
+  }
+  // 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;
     hDeath.dd = 1;
@@ -1908,27 +1727,25 @@ function getYahrzeit_(hyear, gdate) {
 
   return new HDate(hDeath.dd, hDeath.mm, hyear);
 }
+
 /**
  * @private
  * @param {number} hyear Hebrew year
  * @param {Date|HDate} gdate Gregorian or Hebrew date of event
  * @return {HDate} anniversary occurring in `hyear`
  */
-
 function getBirthdayOrAnniversary_(hyear, gdate) {
   const orig = HDate.isHDate(gdate) ? gdate : new HDate(gdate);
   const origYear = orig.getFullYear();
-
   if (hyear <= origYear) {
     // `Hebrew year ${hyear} occurs on or before original date in ${origYear}`
     return undefined;
   }
-
   const isOrigLeap = isLeapYear(origYear);
   let month = orig.getMonth();
   let day = orig.getDate();
 
-  if (month == ADAR_I && !isOrigLeap || month == ADAR_II && isOrigLeap) {
+  if ((month == ADAR_I && !isOrigLeap) || (month == ADAR_II && isOrigLeap)) {
     month = monthsInYear(hyear);
   } else if (month == CHESHVAN && day == 30 && !longCheshvan(hyear)) {
     month = KISLEV;
@@ -1944,22 +1761,21 @@ function getBirthdayOrAnniversary_(hyear, gdate) {
   return new HDate(day, month, hyear);
 }
 
-const version="3.39.2";
+const version="3.41.1";
 
 const headers={"plural-forms":"nplurals=2; plural=(n > 1);",language:"he"};const contexts={"":{Adar:["אַדָר"],"Adar I":["אַדָר א׳"],"Adar II":["אַדָר ב׳"],Av:["אָב"],Cheshvan:["חֶשְׁוָן"],Elul:["אֱלוּל"],Iyyar:["אִיָיר"],Kislev:["כִּסְלֵו"],Nisan:["נִיסָן"],"Sh'vat":["שְׁבָט"],Sivan:["סִיוָן"],Tamuz:["תַּמּוּז"],Tevet:["טֵבֵת"],Tishrei:["תִשְׁרֵי"]}};var poHeMin = {headers:headers,contexts:contexts};
 
 Locale.addLocale('he', poHeMin);
 Locale.addLocale('h', poHeMin);
+
 const heStrs = poHeMin.contexts[''];
 const heNoNikud = {};
-Object.keys(heStrs).forEach(key => {
+Object.keys(heStrs).forEach((key) => {
   heNoNikud[key] = [Locale.hebrewStripNikkud(heStrs[key][0])];
 });
 Locale.addLocale('he-x-NoNikud', {
   headers: poHeMin.headers,
-  contexts: {
-    '': heNoNikud
-  }
+  contexts: {'': heNoNikud},
 });
 
 export { HDate, Locale, gematriya, getBirthdayOrAnniversary_ as getBirthdayOrAnniversary, getYahrzeit_ as getYahrzeit, greg, months, version };