@hebcal/core 3.45.2 → 3.45.4

package/dist/hdate.js

@@ -1,120 +1,93 @@
-/*! @hebcal/core v3.45.2 */
+/*! @hebcal/core v3.45.4 */
 'use strict';
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
 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*';
   }
 }
+
 /**
  * @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.
  *
@@ -129,42 +102,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;
 }
 
@@ -175,40 +136,39 @@ 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()];
 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
@@ -216,21 +176,21 @@ 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__;
 }
+
 /*
 const ABS_14SEP1752 = 639797;
 const ABS_2SEP1752 = 639785;
@@ -242,27 +202,24 @@ const ABS_2SEP1752 = 639785;
  * @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;
 }
+
 /**
  * @private
  * @param {number} abs - R.D. number of days
  * @return {number}
  */
-
 function yearFromFixed(abs) {
   const l0 = abs - 1;
   const n400 = quotient(l0, 146097);
@@ -275,6 +232,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
@@ -282,12 +240,11 @@ function yearFromFixed(abs) {
  * @param {number} day (1-31)
  * @return {number}
  */
-
-
 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$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:
@@ -298,31 +255,25 @@ 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);
   /*
   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$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;
 }
 
@@ -346,10 +297,10 @@ 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')
@@ -357,73 +308,66 @@ class greg {
    * @type {string[]}
    */
   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
    * @deprecated
    * @param {Date} date Gregorian date
    * @return {number}
    */
-
-
   static dayOfYear(date) {
     if (!isDate(date)) {
       throw new TypeError(`Argument not a Date: ${date}`);
     }
-
     const month = date.getMonth();
     let doy = date.getDate() + 31 * month;
-
     if (month > 1) {
       // FEB
       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
    * @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:
@@ -433,12 +377,9 @@ class greg {
    * @param {number} theDate - R.D. number of days
    * @return {Date}
    */
-
-
   static abs2greg(theDate) {
     return abs2greg(theDate);
   }
-
 }
 
 const noopLocale = {
@@ -455,6 +396,7 @@ const alias = {
   's': 'en',
   '': 'en'
 };
+
 /**
  * A locale in Hebcal is used for translations/transliterations of
  * holidays. `@hebcal/core` supports four locales by default
@@ -463,16 +405,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`.
@@ -480,49 +420,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 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
@@ -530,53 +463,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':
@@ -586,42 +510,36 @@ 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);
@@ -631,77 +549,67 @@ 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
 };
 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 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
@@ -712,15 +620,12 @@ const AVG_HEBYEAR_DAYS = 365.24682220597794;
  * @param {number} day Hebrew date (1-30)
  * @return {number}
  */
-
 function hebrew2abs(year, month, day) {
   let tempabs = day;
-
   if (month < TISHREI) {
     for (let m = TISHREI; m <= monthsInYear(year); m++) {
       tempabs += daysInMonth(m, year);
     }
-
     for (let m = NISAN$1; m < month; m++) {
       tempabs += daysInMonth(m, year);
     }
@@ -729,46 +634,40 @@ function hebrew2abs(year, month, day) {
       tempabs += daysInMonth(m, year);
     }
   }
-
   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;
-
   while (abs > hebrew2abs(year, month, daysInMonth(month, year))) {
     ++month;
   }
-
   const day = 1 + abs - hebrew2abs(year, month, 1);
   return {
     yy: year,
@@ -776,26 +675,27 @@ function abs2hebrew(abs) {
     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
@@ -803,7 +703,6 @@ function monthsInYear(year) {
  * @param {number} year Hebrew year
  * @return {number}
  */
-
 function daysInMonth(month, year) {
   switch (month) {
     case IYYAR:
@@ -813,13 +712,13 @@ 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)) {
     return 29;
   } else {
     return 30;
   }
 }
+
 /**
  * Returns a transliterated string name of Hebrew month in year,
  * for example 'Elul' or 'Cheshvan'.
@@ -828,14 +727,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
@@ -843,11 +741,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
@@ -855,11 +753,12 @@ 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
+  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);
@@ -869,6 +768,7 @@ function elapsedDays0(year) {
   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
@@ -877,28 +777,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;
 }
@@ -924,10 +822,10 @@ 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);
 }
-
 const UNITS_DAY = 'day';
 const UNITS_WEEK = 'week';
 const UNITS_MONTH = 'month';
@@ -944,6 +842,7 @@ const UNITS_VALID = {
   month: UNITS_MONTH,
   year: UNITS_YEAR
 };
+
 /**
  * A simple Hebrew date object with numeric fields `yy`, `mm`, and `dd`
  * @typedef {Object} SimpleHebrewDate
@@ -954,7 +853,6 @@ const UNITS_VALID = {
  */
 
 /** Represents a Hebrew date */
-
 class HDate {
   /**
    * Create a Hebrew date. There are 3 basic forms for the `HDate()` constructor.
@@ -990,10 +888,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}
@@ -1003,30 +899,23 @@ 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
-
-
+      }
+      // 1 argument
       const abs0 = typeof day === 'number' && !isNaN(day) ? day : isDate(day) ? greg2abs(day) : HDate.isHDate(day) ? {
         dd: day.day,
         mm: day.month,
@@ -1038,21 +927,17 @@ class HDate {
        * @private
        * @type {number}
        */
-
       this.day = d.dd;
       /**
        * @private
        * @type {number}
        */
-
       this.month = d.mm;
       /**
        * @private
        * @type {number}
        */
-
       this.year = d.yy;
-
       if (isNumber) {
         /**
          * @private
@@ -1062,70 +947,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
@@ -1133,47 +1012,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)
@@ -1181,15 +1056,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
@@ -1199,31 +1072,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'`.
@@ -1231,14 +1101,12 @@ class HDate {
    * import {HDate, months} from '@hebcal/core';
    *
    * const hd = new HDate(15, months.CHESHVAN, 5769);
-   * console.log(hd.render()); // '15th of Cheshvan, 5769'
+   * console.log(hd.render('en')); // '15th of Cheshvan, 5769'
    * console.log(hd.render('he')); // '15 חֶשְׁוָן, 5769'
    * @param {string} [locale] Optional locale name (defaults to active locale).
    * @param {boolean} [showYear=true] Display year (defaults to true).
    * @return {string}
    */
-
-
   render(locale = null, showYear = true) {
     const locale0 = locale || Locale.getLocaleName();
     const day = this.getDate();
@@ -1246,7 +1114,6 @@ class HDate {
     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}`;
@@ -1254,13 +1121,12 @@ class HDate {
       return dateStr;
     }
   }
+
   /**
    * @private
    * @param {string} locale
    * @return {string}
    */
-
-
   static getDayOfTranslation(locale) {
     switch (locale) {
       case 'en':
@@ -1269,19 +1135,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
@@ -1290,14 +1153,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
@@ -1306,11 +1168,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
@@ -1321,11 +1182,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
@@ -1335,11 +1195,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
@@ -1350,11 +1209,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
@@ -1365,29 +1223,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
    *
@@ -1404,17 +1259,12 @@ class HDate {
    * @param {string} [units]
    * @return {HDate}
    */
-
-
   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) {
@@ -1425,25 +1275,23 @@ class HDate {
       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());
       }
-
       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
    *
@@ -1466,11 +1314,10 @@ class HDate {
    * @param {string} [units]
    * @return {HDate}
    */
-
-
   subtract(number, units = 'd') {
     return this.add(number * -1, units);
   }
+
   /**
    * Returns the difference in days between the two given HDates.
    *
@@ -1488,69 +1335,61 @@ 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 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'.
@@ -1558,77 +1397,65 @@ 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 */
+    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
@@ -1651,115 +1478,88 @@ 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
         }
 
         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.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
@@ -1769,71 +1569,60 @@ class HDate {
    * @param {number} absdate
    * @return {number}
    */
-
-
   static dayOnOrBefore(dayOfWeek, absdate) {
     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';
   }
-
 }
+
 /**
  * @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);
@@ -1844,9 +1633,9 @@ function fixMonth(date) {
     date.year += 1;
     fix(date);
   }
-
   delete date.abs0;
 }
+
 /**
  * @private
  * @param {number} day
@@ -1854,8 +1643,6 @@ function fixMonth(date) {
  * @param {number} offset
  * @return {HDate}
  */
-
-
 function onOrBefore(day, t, offset) {
   return new HDate(HDate.dayOnOrBefore(day, t.abs() + offset));
 }
@@ -1867,13 +1654,13 @@ 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 = {
@@ -1881,12 +1668,10 @@ function getYahrzeit_(hyear, gdate) {
     mm: orig.getMonth(),
     dd: orig.getDate()
   };
-
   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.
@@ -1903,10 +1688,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;
@@ -1914,29 +1699,25 @@ function getYahrzeit_(hyear, gdate) {
     hDeath.mm = TEVET;
     hDeath.dd = 1;
   }
-
   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) {
     month = monthsInYear(hyear);
   } else if (month == CHESHVAN && day == 30 && !longCheshvan(hyear)) {
@@ -1949,11 +1730,10 @@ function getBirthdayOrAnniversary_(hyear, gdate) {
     month = NISAN;
     day = 1;
   }
-
   return new HDate(day, month, hyear);
 }
 
-const version="3.45.2";
+const version="3.45.4";
 
 const headers={"plural-forms":"nplurals=2; plural=(n > 1);"};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};