@hebcal/core 4.5.1 → 5.0.0-rc2

package/dist/hdate.mjs

@@ -1,1909 +0,0 @@
-/*! @hebcal/core v4.5.1 */
-const GERESH = '׳';
-const GERSHAYIM = '״';
-
-const heb2num = {
-  'א': 1,
-  'ב': 2,
-  'ג': 3,
-  'ד': 4,
-  'ה': 5,
-  'ו': 6,
-  'ז': 7,
-  'ח': 8,
-  'ט': 9,
-  'י': 10,
-  'כ': 20,
-  'ל': 30,
-  'מ': 40,
-  'נ': 50,
-  'ס': 60,
-  'ע': 70,
-  'פ': 80,
-  'צ': 90,
-  'ק': 100,
-  'ר': 200,
-  'ש': 300,
-  'ת': 400,
-};
-const num2heb = {};
-Object.keys(heb2num).forEach((key) => {
-  const val = heb2num[key];
-  num2heb[val] = key;
-});
-
-/**
- * @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.
- *
- * When specifying years of the Hebrew calendar in the present millennium,
- * we omit the thousands (which is presently 5 [ה]).
- * @example
- * gematriya(5774) // 'תשע״ד' - cropped to 774
- * gematriya(25) // 'כ״ה'
- * gematriya(60) // 'ס׳'
- * gematriya(3761) // 'ג׳תשס״א'
- * gematriya(1123) // 'א׳קכ״ג'
- * @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 (const tdig of tdigits) {
-      str += num2heb[tdig];
-    }
-    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;
-}
-
-/**
- * Converts a string of Hebrew letters to a numerical value.
- *
- * Only considers the value of Hebrew letters `א` through `ת`.
- * Ignores final Hebrew letters such as `ך` (kaf sofit) or `ם` (mem sofit)
- * and vowels (nekudot).
- *
- * @param {string} str
- * @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[ch];
-    if (typeof n === 'number') {
-      num += n;
-    }
-  }
-  return num;
-}
-
-/*
- * More minimal greg routines
- */
-
-/** @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
- * @param {number} month Gregorian month (1=January, 12=December)
- * @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;
-*/
-
-/**
- * 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 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);
-  const d1 = mod(l0, 146097);
-  const n100 = quotient(d1, 36524);
-  const d2 = mod(d1, 36524);
-  const n4 = quotient(d2, 1461);
-  const d3 = mod(d2, 1461);
-  const n1 = quotient(d3, 365);
-  const year = 400 * n400 + 100 * n100 + 4 * n4 + n1;
-  return n100 != 4 && n1 != 4 ? year + 1 : year;
-}
-
-/**
- * @private
- * @param {number} year
- * @param {number} month (1-12)
- * @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:
- * 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.
- * @private
- * @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;
-}
-
-/*
-    Hebcal - A Jewish Calendar Generator
-    Copyright (c) 1994-2020 Danny Sadinoff
-    Portions copyright Eyal Schachter and Michael J. Radwin
-
-    https://github.com/hebcal/hebcal-es6
-
-    This program is free software; you can redistribute it and/or
-    modify it under the terms of the GNU General Public License
-    as published by the Free Software Foundation; either version 2
-    of the License, or (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    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.
- */
-const greg = {
-  /**
-   * Long names of the Gregorian months (1='January', 12='December')
-   * @readonly
-   * @type {string[]}
-   */
-  monthNames: [
-    '',
-    'January',
-    'February',
-    'March',
-    'April',
-    'May',
-    'June',
-    'July',
-    'August',
-    'September',
-    'October',
-    'November',
-    'December',
-  ],
-
-  /**
-   * Returns true if the Gregorian year is a leap year
-   * @function
-   * @param {number} year Gregorian year
-   * @return {boolean}
-   */
-  isLeapYear: isLeapYear$1,
-
-  /**
-   * Number of days in the Gregorian month for given year
-   * @function
-   * @param {number} month Gregorian month (1=January, 12=December)
-   * @param {number} year Gregorian year
-   * @return {number}
-   */
-  daysInMonth: daysInMonth$1,
-
-  /**
-   * Returns true if the object is a Javascript Date
-   * @function
-   * @param {Object} obj
-   * @return {boolean}
-   */
-  isDate: isDate,
-
-  /**
-   * Returns number of days since January 1 of that year
-   * @deprecated
-   * @param {Date} date Gregorian date
-   * @return {number}
-   */
-  dayOfYear: function(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
-   * @function
-   * @param {Date} date Gregorian date
-   * @return {number}
-   */
-  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.
-   * @function
-   * @param {number} theDate - R.D. number of days
-   * @return {Date}
-   */
-  abs2greg: abs2greg,
-};
-
-const noopLocale = {
-  headers: {'plural-forms': 'nplurals=2; plural=(n!=1);'},
-  contexts: {'': {}},
-};
-const alias = {
-  'h': 'he',
-  'a': 'ashkenazi',
-  's': 'en',
-  '': 'en',
-};
-
-/** @private */
-const locales = Object.create(null);
-/** @private */
-let activeLocale = null;
-/** @private */
-let activeName = null;
-
-/**
- * A locale in Hebcal is used for translations/transliterations of
- * holidays. `@hebcal/core` supports four locales by default
- * * `en` - default, Sephardic transliterations (e.g. "Shabbat")
- * * `ashkenazi` - Ashkenazi transliterations (e.g. "Shabbos")
- * * `he` - Hebrew (e.g. "שַׁבָּת")
- * * `he-x-NoNikud` - Hebrew without nikud (e.g. "שבת")
- */
-class Locale {
-  /**
-   * Returns translation only if `locale` offers a non-empty translation for `id`.
-   * Otherwise, returns `undefined`.
-   * @param {string} id Message ID to translate
-   * @param {string} [locale] Optional locale name (i.e: `'he'`, `'fr'`). Defaults to active locale.
-   * @return {string}
-   */
-  static lookupTranslation(id, locale) {
-    const locale0 = locale?.toLowerCase();
-    const loc = (typeof locale == 'string' && locales[locale0]) || 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 {LocaleData} data parsed data from a `.po` file.
-   */
-  static addLocale(locale, data) {
-    if (typeof locale !== 'string') {
-      throw new TypeError(`Invalid locale name: ${locale}`);
-    }
-    if (typeof data.contexts !== 'object' || typeof data.contexts[''] !== 'object') {
-      throw new TypeError(`Locale '${locale}' invalid compact format`);
-    }
-    locales[locale.toLowerCase()] = data.contexts[''];
-  }
-
-  /**
-   * Adds a translation to `locale`, replacing any previous translation.
-   * @param {string} locale Locale name (i.e: `'he'`, `'fr'`).
-   * @param {string} id Message ID to translate
-   * @param {string} translation Translation text
-   */
-  static addTranslation(locale, id, translation) {
-    if (typeof locale !== 'string') {
-      throw new TypeError(`Invalid locale name: ${locale}`);
-    }
-    const locale0 = locale.toLowerCase();
-    const loc = locales[locale0];
-    if (!loc) {
-      throw new TypeError(`Unknown locale: ${locale}`);
-    }
-    if (typeof id !== 'string' || id.length === 0) {
-      throw new TypeError(`Invalid id: ${id}`);
-    }
-    const isArray = Array.isArray(translation);
-    if (isArray) {
-      const t0 = translation[0];
-      if (typeof t0 !== 'string' || t0.length === 0) {
-        throw new TypeError(`Invalid translation array: ${translation}`);
-      }
-    } else if (typeof translation !== 'string') {
-      throw new TypeError(`Invalid translation: ${translation}`);
-    }
-    loc[id] = isArray ? translation : [translation];
-  }
-  /**
-   * Adds multiple translations to `locale`, replacing any previous translations.
-   * @param {string} locale Locale name (i.e: `'he'`, `'fr'`).
-   * @param {LocaleData} data parsed data from a `.po` file.
-   */
-  static addTranslations(locale, data) {
-    if (typeof locale !== 'string') {
-      throw new TypeError(`Invalid locale name: ${locale}`);
-    }
-    const locale0 = locale.toLowerCase();
-    const loc = locales[locale0];
-    if (!loc) {
-      throw new TypeError(`Unknown locale: ${locale}`);
-    }
-    if (typeof data.contexts !== 'object' || typeof data.contexts[''] !== 'object') {
-      throw new TypeError(`Locale '${locale}' invalid compact format`);
-    }
-    const ctx = data.contexts[''];
-    Object.keys(ctx).forEach((id) => {
-      loc[id] = ctx[id];
-    });
-  }
-  /**
-   * 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
-   * will be represented by the corresponding translation in the specified locale.
-   * @param {string} locale Locale name (i.e: `'he'`, `'fr'`)
-   * @return {LocaleData}
-   */
-  static useLocale(locale) {
-    const locale0 = locale.toLowerCase();
-    const obj = locales[locale0];
-    if (!obj) {
-      throw new RangeError(`Locale '${locale}' not found`);
-    }
-    activeName = alias[locale0] || locale0;
-    activeLocale = obj;
-    return activeLocale;
-  }
-
-  /**
-   * Returns the name of the active locale (i.e. 'he', 'ashkenazi', 'fr')
-   * @return {string}
-   */
-  static getLocaleName() {
-    return activeName;
-  }
-
-  /**
-   * Returns the names of registered locales
-   * @return {string[]}
-   */
-  static getLocaleNames() {
-    return Object.keys(locales).sort((a, b) => a.localeCompare(b));
-  }
-
-  /**
-   * @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?.toLowerCase();
-    const locale0 = locale1 || activeName;
-    if (!locale0) {
-      return this.getEnOrdinal(n);
-    }
-    switch (locale0) {
-      case 'en':
-      case 's':
-      case 'a':
-      case 'ashkenazi':
-      case 'ashkenazi_litvish':
-      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);
-Locale.useLocale('en');
-
-/*
- * More minimal HDate
- */
-
-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 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 AVG_HEBYEAR_DAYS = 365.24682220597794;
-
-/**
- * @private
- * @param {any} n
- * @param {string} name
- */
-function assertNumber(n, name) {
-  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.
- * R.D. 1 is the imaginary date Monday, January 1, 1 on the Gregorian
- * Calendar.
- * @private
- * @param {number} year Hebrew year
- * @param {number} month Hebrew month
- * @param {number} day Hebrew date (1-30)
- * @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) {
-    for (let m = TISHREI; m <= monthsInYear(year); m++) {
-      tempabs += daysInMonth(m, year);
-    }
-    for (let m = NISAN$1; m < month; m++) {
-      tempabs += daysInMonth(m, year);
-    }
-  } else {
-    for (let m = TISHREI; m < month; m++) {
-      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) {
-  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
- * @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
- * @param {number} month Hebrew month (e.g. months.TISHREI)
- * @param {number} year Hebrew year
- * @return {number}
- */
-function daysInMonth(month, year) {
-  switch (month) {
-    case IYYAR:
-    case TAMUZ:
-    case ELUL:
-    case TEVET$1:
-    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'.
- * @private
- * @param {number} month Hebrew month (e.g. months.TISHREI)
- * @param {number} year Hebrew year
- * @return {string}
- */
-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];
-}
-
-/**
- * Days from sunday prior to start of Hebrew calendar to mean
- * conjunction of Tishrei in Hebrew YEAR
- * @private
- * @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
- * @private
- * @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
-
-  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);
-  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
- * A leap Hebrew calendar year can have a length of 383, 384 or 385 days
- * @private
- * @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;
-}
-
-/**
- * @private
- * @param {string} msg
- */
-function throwTypeError(msg) {
-  throw new TypeError(msg);
-}
-
-/*
-    Hebcal - A Jewish Calendar Generator
-    Copyright (c) 1994-2020 Danny Sadinoff
-    Portions copyright Eyal Schachter and Michael J. Radwin
-
-    https://github.com/hebcal/hebcal-es6
-
-    This program is free software; you can redistribute it and/or
-    modify it under the terms of the GNU General Public License
-    as published by the Free Software Foundation; either version 2
-    of the License, or (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-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};
-
-/**
- * A simple Hebrew date object with numeric fields `yy`, `mm`, and `dd`
- * @typedef {Object} SimpleHebrewDate
- * @property {number} yy Hebrew year
- * @property {number} mm Hebrew month of year (1=NISAN, 7=TISHREI)
- * @property {number} dd Day of month (1-30)
- * @private
- */
-
-/** Represents a Hebrew date */
-class HDate {
-  /**
-   * Create a Hebrew date. There are 3 basic forms for the `HDate()` constructor.
-   *
-   * 1. No parameters - represents the current Hebrew date at time of instantiation
-   * 2. One parameter
-   *    * `Date` - represents the Hebrew date corresponding to the Gregorian date using
-   *       local time. Hours, minutes, seconds and milliseconds are ignored.
-   *    * `HDate` - clones a copy of the given Hebrew date
-   *    * `number` - Converts absolute R.D. days to Hebrew date.
-   *       R.D. 1 == the imaginary date January 1, 1 (Gregorian)
-   * 3. Three parameters: Hebrew day, Hebrew month, Hebrew year. Hebrew day should
-   *    be a number between 1-30, Hebrew month can be a number or string, and
-   *    Hebrew year is always a number.
-   * @example
-   * import {HDate, months} from '@hebcal/core';
-   *
-   * const hd1 = new HDate();
-   * const hd2 = new HDate(new Date(2008, 10, 13));
-   * const hd3 = new HDate(15, 'Cheshvan', 5769);
-   * const hd4 = new HDate(15, months.CHESHVAN, 5769);
-   * const hd5 = new HDate(733359); // ==> 15 Cheshvan 5769
-   * const monthName = 'אייר';
-   * const hd6 = new HDate(5, monthName, 5773);
-   * @param {number|Date|HDate} [day] - Day of month (1-30) if a `number`.
-   *   If a `Date` is specified, represents the Hebrew date corresponding to the
-   *   Gregorian date using local time.
-   *   If an `HDate` is specified, clones a copy of the given Hebrew date.
-   * @param {number|string} [month] - Hebrew month of year (1=NISAN, 7=TISHREI)
-   * @param {number} [year] - Hebrew year
-   */
-  constructor(day, month, year) {
-    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}
-       */
-      this.day = this.month = 1;
-      /**
-       * @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}`);
-      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
-         * @type {number}
-         */
-        this.abs0 = abs0;
-      }
-    }
-  }
-
-  /**
-   * 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
-   * @deprecated
-   * @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|string} month A number, or Hebrew month name string
-   * @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)
-   * Note also that R.D. = Julian Date − 1,721,424.5
-   * 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
-   * Calendar.
-   * @param {number} year Hebrew year
-   * @param {number} month Hebrew month
-   * @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'`.
-   * @example
-   * import {HDate, months} from '@hebcal/core';
-   *
-   * const hd = new HDate(15, months.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();
-    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}`;
-    } else {
-      return dateStr;
-    }
-  }
-
-  /**
-   * @private
-   * @param {string} locale
-   * @return {string}
-   */
-  static getDayOfTranslation(locale) {
-    switch (locale) {
-      case 'en':
-      case 's':
-      case 'a':
-      case 'ashkenazi':
-        return ' of';
-    }
-    const ofStr = Locale.lookupTranslation('of', locale);
-    if (ofStr) {
-      return ' ' + ofStr;
-    }
-    if (locale.startsWith('ashkenazi')) {
-      return ' of';
-    }
-    return '';
-  }
-
-  /**
-   * Renders this Hebrew date in Hebrew gematriya, regardless of locale.
-   * @example
-   * import {HDate, months} from '@hebcal/core';
-   * const hd = new HDate(15, months.CHESHVAN, 5769);
-   * console.log(hd.renderGematriya()); // 'ט״ו חֶשְׁוָן תשס״ט'
-   * @param {boolean} [suppressNikud]
-   * @return {string}
-   */
-  renderGematriya(suppressNikud=false) {
-    const d = this.getDate();
-    const locale = suppressNikud ? 'he-x-NoNikud' : 'he';
-    const m = Locale.gettext(this.getMonthName(), locale);
-    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
-   * @example
-   * new HDate(new Date('Wednesday February 19, 2014')).before(6).greg() // Sat Feb 15 2014
-   * @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
-   * @example
-   * new HDate(new Date('Wednesday February 19, 2014')).onOrBefore(6).greg() // Sat Feb 15 2014
-   * new HDate(new Date('Saturday February 22, 2014')).onOrBefore(6).greg() // Sat Feb 22 2014
-   * new HDate(new Date('Sunday February 23, 2014')).onOrBefore(6).greg() // Sat Feb 22 2014
-   * @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
-   * @example
-   * new HDate(new Date('Wednesday February 19, 2014')).nearest(6).greg() // Sat Feb 22 2014
-   * new HDate(new Date('Tuesday February 18, 2014')).nearest(6).greg() // Sat Feb 15 2014
-   * @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
-   * @example
-   * new HDate(new Date('Wednesday February 19, 2014')).onOrAfter(6).greg() // Sat Feb 22 2014
-   * new HDate(new Date('Saturday February 22, 2014')).onOrAfter(6).greg() // Sat Feb 22 2014
-   * new HDate(new Date('Sunday February 23, 2014')).onOrAfter(6).greg() // Sat Mar 01 2014
-   * @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
-   * @example
-   * new HDate(new Date('Wednesday February 19, 2014')).after(6).greg() // Sat Feb 22 2014
-   * new HDate(new Date('Saturday February 22, 2014')).after(6).greg() // Sat Mar 01 2014
-   * new HDate(new Date('Sunday February 23, 2014')).after(6).greg() // Sat Mar 01 2014
-   * @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
-   *
-   * Units are case insensitive, and support plural and short forms.
-   * Note, short forms are case sensitive.
-   *
-   * | Unit | Shorthand | Description
-   * | --- | --- | --- |
-   * | `day` | `d` | days |
-   * | `week` | `w` | weeks |
-   * | `month` | `M` | months |
-   * | `year` | `y` | years |
-   * @param {number} number
-   * @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) {
-      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()));
-      }
-      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
-   *
-   * Units are case insensitive, and support plural and short forms.
-   * Note, short forms are case sensitive.
-   *
-   * | Unit | Shorthand | Description
-   * | --- | --- | --- |
-   * | `day` | `d` | days |
-   * | `week` | `w` | weeks |
-   * | `month` | `M` | months |
-   * | `year` | `y` | years |
-   * @example
-   * import {HDate, months} from '@hebcal/core';
-   *
-   * const hd1 = new HDate(15, months.CHESHVAN, 5769);
-   * const hd2 = hd1.add(1, 'weeks'); // 7 Kislev 5769
-   * const hd3 = hd1.add(-3, 'M'); // 30 Av 5768
-   * @param {number} number
-   * @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.
-   *
-   * The result is positive if `this` date is comes chronologically
-   * after the `other` date, and negative
-   * if the order of the two dates is reversed.
-   *
-   * The result is zero if the two dates are identical.
-   * @example
-   * import {HDate, months} from '@hebcal/core';
-   *
-   * const hd1 = new HDate(25, months.KISLEV, 5770);
-   * const hd2 = new HDate(15, months.CHESHVAN, 5769);
-   * const days = hd1.deltaDays(hd2); // 394
-   * @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} */
-  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'.
-   * @param {number} month Hebrew month (e.g. months.TISHREI)
-   * @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);
-  }
-
-  /**
-   * 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;
-    }
-    let c = Locale.hebrewStripNikkud(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;
-          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
-   * absolute date d, applying it to d-1 gives the DAYNAME previous to absolute
-   * date d, and applying it to d+7 gives the DAYNAME following absolute date d.
-   * @param {number} dayOfWeek
-   * @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';
-  }
-
-  /**
-   * Construct a new instance of `HDate` from a Gematriya-formatted string
-   * @example
-   *  HDate.fromGematriyaString('כ״ז בְּתַמּוּז תשפ״ג') // 27 Tamuz 5783
-   *  HDate.fromGematriyaString('כ׳ סיון תש״ד') // 20 Sivan 5704
-   *  HDate.fromGematriyaString('ה׳ אִיָיר תש״ח') // 5 Iyyar 5708
-   * @param {string} str
-   * @param {number} currentThousands
-   * @return {HDate}
-   */
-  static fromGematriyaString(str, currentThousands=5000) {
-    const parts = str.split(' ');
-    const day = gematriyaStrToNum(parts[0]);
-    const month = HDate.monthFromName(parts[1]);
-    let year = gematriyaStrToNum(parts[2]);
-    if (year < 1000) {
-      year += currentThousands;
-    }
-    return new HDate(day, month, year);
-  }
-}
-
-/**
- * @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);
-    date.year -= 1;
-    fix(date);
-  } else if (date.month > monthsInYear(date.year)) {
-    date.month -= monthsInYear(date.year);
-    date.year += 1;
-    fix(date);
-  }
-  delete date.abs0;
-}
-
-/**
- * @private
- * @param {number} day
- * @param {HDate} t
- * @param {number} offset
- * @return {HDate}
- */
-function onOrBefore(day, t, offset) {
-  return new HDate(HDate.dayOnOrBefore(day, t.abs() + offset));
-}
-
-const NISAN = months.NISAN;
-const CHESHVAN = months.CHESHVAN;
-const KISLEV = months.KISLEV;
-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(),
-  };
-  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);
-  } else if (hDeath.mm == KISLEV && 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);
-  } else if (hDeath.mm == ADAR_II) {
-    // 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 && 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;
-    hDeath.dd = 1;
-  } else if (hDeath.mm == KISLEV && hDeath.dd == 30 && shortKislev(hyear)) {
-    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) {
-    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.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)) {
-    month = KISLEV;
-    day = 1;
-  } else if (month == KISLEV && day == 30 && shortKislev(hyear)) {
-    month = TEVET;
-    day = 1;
-  } else if (month == ADAR_I && day == 30 && isOrigLeap && !isLeapYear(hyear)) {
-    month = NISAN;
-    day = 1;
-  }
-
-  return new HDate(day, month, hyear);
-}
-
-const version="4.5.1";
-
-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};
-
-Locale.addLocale('he', poHeMin);
-Locale.addLocale('h', poHeMin);
-
-const heStrs = poHeMin.contexts[''];
-const heNoNikud = {};
-Object.keys(heStrs).forEach((key) => {
-  heNoNikud[key] = [Locale.hebrewStripNikkud(heStrs[key][0])];
-});
-Locale.addLocale('he-x-NoNikud', {
-  headers: poHeMin.headers,
-  contexts: {'': heNoNikud},
-});
-
-export { HDate, Locale, gematriya, getBirthdayOrAnniversary_ as getBirthdayOrAnniversary, getYahrzeit_ as getYahrzeit, greg, months, version };