@hebcal/core 6.0.5 → 6.0.7

package/dist/size-demo/dist/getHoliday.js

@@ -0,0 +1,3712 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _QuickLRU_instances, _QuickLRU_size, _QuickLRU_cache, _QuickLRU_oldCache, _QuickLRU_maxSize, _QuickLRU_maxAge, _QuickLRU_onEviction, _QuickLRU_emitEvictions, _QuickLRU_deleteIfExpired, _QuickLRU_getOrDeleteIfExpired, _QuickLRU_getItemValue, _QuickLRU_peek, _QuickLRU_set, _QuickLRU_moveToRecent, _QuickLRU_entriesAscending;
+/*! @hebcal/hdate v0.21.1, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+/* eslint-disable @typescript-eslint/no-namespace, no-inner-declarations */
+/** @private */
+const lengths = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+/** @private */
+const monthLengths = [lengths, lengths.slice()];
+monthLengths[1][2] = 29;
+/**
+ * @private
+ */
+function mod$1(x, y) {
+    return x - y * Math.floor(x / y);
+}
+/**
+ * @private
+ */
+function quotient(x, y) {
+    return Math.floor(x / y);
+}
+/**
+ * @private
+ * @param abs - R.D. number of days
+ */
+function yearFromFixed(abs) {
+    const l0 = abs - 1;
+    const n400 = quotient(l0, 146097);
+    const d1 = mod$1(l0, 146097);
+    const n100 = quotient(d1, 36524);
+    const d2 = mod$1(d1, 36524);
+    const n4 = quotient(d2, 1461);
+    const d3 = mod$1(d2, 1461);
+    const n1 = quotient(d3, 365);
+    const year = 400 * n400 + 100 * n100 + 4 * n4 + n1;
+    return n100 !== 4 && n1 !== 4 ? year + 1 : year;
+}
+/*
+const ABS_14SEP1752 = 639797;
+const ABS_2SEP1752 = 639785;
+*/
+/*
+ * Formerly in namespace, now top-level
+ */
+/**
+ * Returns true if the Gregorian year is a leap year
+ * @param year Gregorian year
+ */
+function isGregLeapYear(year) {
+    return !(year % 4) && (!!(year % 100) || !(year % 400));
+}
+/**
+ * Number of days in the Gregorian month for given year
+ * @param month Gregorian month (1=January, 12=December)
+ * @param year Gregorian year
+ */
+function daysInGregMonth(month, year) {
+    // 1 based months
+    return monthLengths[+isGregLeapYear(year)][month];
+}
+/**
+ * Returns true if the object is a Javascript Date
+ */
+function isDate(obj) {
+    // eslint-disable-next-line no-prototype-builtins
+    return typeof obj === 'object' && Date.prototype.isPrototypeOf(obj);
+}
+/**
+ * @private
+ * @param year
+ * @param month (1-12)
+ * @param day (1-31)
+ */
+function toFixed(year, month, day) {
+    const py = year - 1;
+    return (365 * py +
+        quotient(py, 4) -
+        quotient(py, 100) +
+        quotient(py, 400) +
+        quotient(367 * month - 362, 12) +
+        (month <= 2 ? 0 : isGregLeapYear(year) ? -1 : -2) +
+        day);
+}
+/**
+ * Converts Gregorian date to absolute R.D. (Rata Die) days
+ * @param date Gregorian date
+ */
+function greg2abs(date) {
+    if (!isDate(date)) {
+        throw new TypeError(`not a Date: ${date}`);
+    }
+    else if (isNaN(date.getTime())) {
+        throw new RangeError('Invalid 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;
+}
+/**
+ * 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.
+ *
+ * Note that this function returns the daytime portion of the date.
+ * For example, the 15th of Cheshvan 5769 began at sundown on
+ * 12 November 2008 and continues through 13 November 2008. This
+ * function would return only the date 13 November 2008.
+ * @param abs - R.D. number of days
+ * @example
+ * const abs = hebrew2abs(5769, months.CHESHVAN, 15);
+ * const date = abs2greg(abs); // 13 November 2008
+ * const year = date.getFullYear(); // 2008
+ * const monthNum = date.getMonth() + 1; // 11
+ * const day = date.getDate(); // 13
+ */
+function abs2greg(abs) {
+    if (typeof abs !== 'number' || isNaN(abs)) {
+        throw new TypeError(`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 : isGregLeapYear(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/hdate v0.21.1, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-namespace */
+/**
+ * Gregorian date helper functions
+ */
+var greg;
+(function (greg) {
+})(greg || (greg = {}));
+greg.abs2greg = abs2greg;
+greg.daysInMonth = daysInGregMonth;
+greg.greg2abs = greg2abs;
+greg.isDate = isDate;
+greg.isLeapYear = isGregLeapYear;
+/*! @hebcal/hdate v0.21.1, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+/**
+ * Removes niqqud from Hebrew string
+ */
+function hebrewStripNikkud(str) {
+    const a = str.normalize();
+    // now strip out niqqud and trope
+    return a.replace(/[\u0590-\u05bd]/g, '').replace(/[\u05bf-\u05c7]/g, '');
+}
+/*! @hebcal/hdate v0.21.1, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+/*
+ * More minimal HDate
+ */
+const NISAN$2 = 1;
+const IYYAR$1 = 2;
+const SIVAN = 3;
+const TAMUZ$1 = 4;
+const AV$1 = 5;
+const ELUL = 6;
+const TISHREI$1 = 7;
+const CHESHVAN = 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: NISAN$2,
+    /** Iyyar / אייר */
+    IYYAR: IYYAR$1,
+    /** Sivan / סיון */
+    SIVAN,
+    /** Tamuz (sometimes Tammuz) / תמוז */
+    TAMUZ: TAMUZ$1,
+    /** Av / אב */
+    AV: AV$1,
+    /** Elul / אלול */
+    ELUL,
+    /** Tishrei / תִּשְׁרֵי */
+    TISHREI: TISHREI$1,
+    /** Cheshvan / חשון */
+    CHESHVAN,
+    /** Kislev / כסלו */
+    KISLEV: KISLEV$1,
+    /** Tevet / טבת */
+    TEVET: TEVET$1,
+    /** Sh'vat / שבט */
+    SHVAT,
+    /** Adar or Adar Rishon / אדר */
+    ADAR_I: ADAR_I$1,
+    /** Adar Sheini (only on leap years) / אדר ב׳ */
+    ADAR_II: ADAR_II$1,
+};
+const NISAN_STR = 'Nisan';
+const monthNames0 = [
+    '',
+    NISAN_STR,
+    '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, 'Adar', NISAN_STR],
+    [...monthNames0, 'Adar I', 'Adar II', NISAN_STR],
+];
+const edCache = new Map();
+const EPOCH = -1373428;
+// Avg year length in the cycle (19 solar years with 235 lunar months)
+const AVG_HEBYEAR_DAYS = 365.24682220597794;
+/**
+ * @private
+ */
+function assertNumber(n, name) {
+    if (typeof n !== 'number' || isNaN(n)) {
+        throw new TypeError(`param '${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.
+ * @param year Hebrew year
+ * @param month Hebrew month
+ * @param day Hebrew date (1-30)
+ * @example
+ * const abs = hebrew2abs(5769, months.CHESHVAN, 15);
+ */
+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$1) {
+        for (let m = TISHREI$1; m <= monthsInYear(year); m++) {
+            tempabs += daysInMonth(m, year);
+        }
+        for (let m = NISAN$2; m < month; m++) {
+            tempabs += daysInMonth(m, year);
+        }
+    }
+    else {
+        for (let m = TISHREI$1; m < month; m++) {
+            tempabs += daysInMonth(m, year);
+        }
+    }
+    return EPOCH + elapsedDays(year) + tempabs - 1;
+}
+/**
+ * @private
+ */
+function newYear(year) {
+    return EPOCH + elapsedDays(year);
+}
+/**
+ * Converts absolute R.D. days to Hebrew date
+ * @param abs absolute R.D. days
+ */
+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
+ * @param year Hebrew year
+ */
+function isLeapYear(year) {
+    return (1 + year * 7) % 19 < 7;
+}
+/**
+ * Number of months in this Hebrew year (either 12 or 13 depending on leap year)
+ * @param year Hebrew year
+ */
+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)
+ * @param month Hebrew month (e.g. months.TISHREI)
+ * @param year Hebrew year
+ */
+function daysInMonth(month, year) {
+    switch (month) {
+        case IYYAR$1:
+        case TAMUZ$1:
+        case ELUL:
+        case TEVET$1:
+        case ADAR_II$1:
+            return 29;
+    }
+    if ((month === ADAR_I$1 && !isLeapYear(year)) ||
+        (month === CHESHVAN && !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'.
+ * @param month Hebrew month (e.g. months.TISHREI)
+ * @param year Hebrew year
+ */
+function getMonthName(month, year) {
+    assertNumber(month, 'month');
+    assertNumber(year, 'year');
+    if (month < 1 || month > 14) {
+        throw new TypeError(`bad monthNum: ${month}`);
+    }
+    return monthNames[+isLeapYear(year)][month];
+}
+/**
+ * Days from sunday prior to start of Hebrew calendar to mean
+ * conjunction of Tishrei in Hebrew YEAR
+ * @param year Hebrew year
+ */
+function elapsedDays(year) {
+    const n = edCache.get(year);
+    if (typeof n === 'number') {
+        return n;
+    }
+    const elapsed = elapsedDays0(year);
+    edCache.set(year, elapsed);
+    return elapsed;
+}
+/**
+ * Days from sunday prior to start of Hebrew calendar to mean
+ * conjunction of Tishrei in Hebrew YEAR
+ * @private
+ * @param year Hebrew year
+ */
+function elapsedDays0(year) {
+    const prevYear = year - 1;
+    const mElapsed = 235 * Math.floor(prevYear / 19) + // Months in complete 19 year lunar (Metonic) cycles so far
+        12 * (prevYear % 19) + // Regular months in this cycle
+        Math.floor(((prevYear % 19) * 7 + 1) / 19); // Leap months this cycle
+    const pElapsed = 204 + 793 * (mElapsed % 1080);
+    const hElapsed = 5 +
+        12 * mElapsed +
+        793 * Math.floor(mElapsed / 1080) +
+        Math.floor(pElapsed / 1080);
+    const parts = (pElapsed % 1080) + 1080 * (hElapsed % 24);
+    const day = 1 + 29 * mElapsed + Math.floor(hElapsed / 24);
+    let altDay = day;
+    if (parts >= 19440 ||
+        (2 === day % 7 && parts >= 9924 && !isLeapYear(year)) ||
+        (1 === day % 7 && parts >= 16789 && isLeapYear(prevYear))) {
+        altDay++;
+    }
+    if (altDay % 7 === 0 || altDay % 7 === 3 || altDay % 7 === 5) {
+        return altDay + 1;
+    }
+    else {
+        return altDay;
+    }
+}
+/**
+ * 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
+ * @param year Hebrew year
+ */
+function daysInYear(year) {
+    return elapsedDays(year + 1) - elapsedDays(year);
+}
+/**
+ * true if Cheshvan is long in Hebrew year
+ * @param year Hebrew year
+ */
+function longCheshvan(year) {
+    return daysInYear(year) % 10 === 5;
+}
+/**
+ * true if Kislev is short in Hebrew year
+ * @param year Hebrew year
+ */
+function shortKislev(year) {
+    return daysInYear(year) % 10 === 3;
+}
+/**
+ * Converts Hebrew month string name to numeric
+ * @param monthName monthName
+ */
+function monthFromName(monthName) {
+    if (typeof monthName === 'number') {
+        if (isNaN(monthName) || monthName < 1 || monthName > 14) {
+            throw new RangeError(`bad monthName: ${monthName}`);
+        }
+        return monthName;
+    }
+    let c = monthName.trim().toLowerCase();
+    // remove all niqud and trailing gershayim (for Adar Alef/Bet)
+    c = hebrewStripNikkud(c).replace(/׳$/, '');
+    // 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 NISAN$2;
+        case 'i':
+            return IYYAR$1;
+        case 'e':
+            return ELUL;
+        case 'c':
+        case 'ח':
+            return CHESHVAN;
+        case 'k':
+        case 'כ':
+            return KISLEV$1;
+        case 's':
+            switch (c[1]) {
+                case 'i':
+                    return SIVAN;
+                case 'h':
+                    return SHVAT;
+            }
+            break;
+        case 't':
+            switch (c[1]) {
+                case 'a':
+                    return TAMUZ$1;
+                case 'i':
+                    return TISHREI$1;
+                case 'e':
+                    return TEVET$1;
+            }
+            break;
+        case 'a':
+            switch (c[1]) {
+                case 'v':
+                    return AV$1;
+                case 'd':
+                    if (/(1|[^i]i|a|א)$/i.test(c)) {
+                        return ADAR_I$1;
+                    }
+                    return ADAR_II$1; // else assume sheini
+            }
+            break;
+        case 'ס':
+            return SIVAN;
+        case 'ט':
+            return TEVET$1;
+        case 'ש':
+            return SHVAT;
+        case 'א':
+            switch (c[1]) {
+                case 'ב':
+                    return AV$1;
+                case 'ד':
+                    if (/(1|[^i]i|a|א)$/i.test(c)) {
+                        return ADAR_I$1;
+                    }
+                    return ADAR_II$1; // else assume sheini
+                case 'י':
+                    return IYYAR$1;
+                case 'ל':
+                    return ELUL;
+            }
+            break;
+        case 'ת':
+            switch (c[1]) {
+                case 'מ':
+                    return TAMUZ$1;
+                case 'ש':
+                    return TISHREI$1;
+            }
+            break;
+    }
+    throw new RangeError(`bad monthName: ${monthName}`);
+}
+/*! @hebcal/hdate v0.21.1, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+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 = {};
+for (const [key, val] of Object.entries(heb2num)) {
+    num2heb[val] = key;
+}
+function num2digits(num) {
+    const digits = [];
+    while (num > 0) {
+        if (num === 15 || num === 16) {
+            digits.push(9);
+            digits.push(num - 9);
+            break;
+        }
+        let incr = 100;
+        let i;
+        for (i = 400; i > num; i -= incr) {
+            if (i === incr) {
+                incr = incr / 10;
+            }
+        }
+        digits.push(i);
+        num -= i;
+    }
+    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) // 'א׳קכ״ג'
+ */
+function gematriya(num) {
+    const num1 = parseInt(num, 10);
+    if (!num1 || num1 < 0) {
+        throw new TypeError(`invalid number: ${num}`);
+    }
+    let str = '';
+    const thousands = Math.floor(num1 / 1000);
+    if (thousands > 0 && thousands !== 5) {
+        const tdigits = num2digits(thousands);
+        for (const tdig of tdigits) {
+            str += num2heb[tdig];
+        }
+        str += GERESH;
+    }
+    const digits = num2digits(num1 % 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).
+ */
+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;
+}
+/*! @hebcal/hdate v0.21.1, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+/**
+ * Formats a number with leading zeros so the resulting string is 4 digits long.
+ * Similar to `string.padStart(4, '0')` but will also format
+ * negative numbers similar to how the JavaScript date formats
+ * negative year numbers (e.g. `-37` is formatted as `-000037`).
+ */
+function pad4(num) {
+    if (num < 0) {
+        return '-00' + pad4(-num);
+    }
+    else if (num < 10) {
+        return '000' + num;
+    }
+    else if (num < 100) {
+        return '00' + num;
+    }
+    else if (num < 1000) {
+        return '0' + num;
+    }
+    return String(num);
+}
+/**
+ * Formats a number with leading zeros so the resulting string is 2 digits long.
+ * Similar to `string.padStart(2, '0')`.
+ */
+function pad2(num) {
+    if (num >= 0 && num < 10) {
+        return '0' + num;
+    }
+    return String(num);
+}
+/*! @hebcal/hdate v0.21.1, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+/**
+ * Returns YYYY-MM-DD in the local timezone
+ */
+function isoDateString(dt) {
+    return (pad4(dt.getFullYear()) +
+        '-' +
+        pad2(dt.getMonth() + 1) +
+        '-' +
+        pad2(dt.getDate()));
+}
+/*! @hebcal/hdate v0.21.1, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+var poAshkenazi$1 = { "headers": { "plural-forms": "nplurals=2; plural=(n > 1);", "language": "en_CA@ashkenazi" }, "contexts": { "": { "Tevet": ["Teves"] } } };
+/*! @hebcal/hdate v0.21.1, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+var poHe$1 = { "headers": { "plural-forms": "nplurals=2; plural=(n > 1);", "language": "he" }, "contexts": { "": { "Adar": ["אֲדָר"], "Adar I": ["אֲדָר א׳"], "Adar II": ["אֲדָר ב׳"], "Av": ["אָב"], "Cheshvan": ["חֶשְׁוָן"], "Elul": ["אֱלוּל"], "Iyyar": ["אִיָּיר"], "Kislev": ["כִּסְלֵו"], "Nisan": ["נִיסָן"], "Sh'vat": ["שְׁבָט"], "Sivan": ["סִיוָן"], "Tamuz": ["תַּמּוּז"], "Tevet": ["טֵבֵת"], "Tishrei": ["תִּשְׁרֵי"] } } };
+/*! @hebcal/hdate v0.21.1, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+const noopLocale = {
+    headers: { 'plural-forms': 'nplurals=2; plural=(n!=1);' },
+    contexts: { '': {} },
+};
+const alias = {
+    h: 'he',
+    a: 'ashkenazi',
+    s: 'en',
+    '': 'en',
+};
+/** @private */
+const locales = new Map();
+/** @private */
+function getEnOrdinal(n) {
+    const s = ['th', 'st', 'nd', 'rd'];
+    const v = n % 100;
+    return n + (s[(v - 20) % 10] || s[v] || s[0]);
+}
+/** @private */
+function checkLocale(locale) {
+    if (typeof locale !== 'string') {
+        throw new TypeError(`Invalid locale name: ${locale}`);
+    }
+    locale = alias[locale] || locale;
+    return locale.toLowerCase();
+}
+/** @private */
+function getExistingLocale(locale) {
+    const locale1 = checkLocale(locale);
+    const loc = locales.get(locale1);
+    if (!loc) {
+        throw new RangeError(`Locale '${locale}' not found`);
+    }
+    return loc;
+}
+/**
+ * A locale in Hebcal is used for translations/transliterations of
+ * holidays. `@hebcal/hdate` 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 id Message ID to translate
+     * @param [locale] Optional locale name (i.e: `'he'`, `'fr'`). Defaults to no-op locale.
+     */
+    static lookupTranslation(id, locale) {
+        const loc = (typeof locale === 'string' && locales.get(checkLocale(locale))) ||
+            noopLocale.contexts[''];
+        const array = loc[id];
+        if ((array === null || array === void 0 ? void 0 : array.length) && array[0].length) {
+            return array[0];
+        }
+        return undefined;
+    }
+    /**
+     * By default, if no translation was found, returns `id`.
+     * @param id Message ID to translate
+     * @param [locale] Optional locale name (i.e: `'he'`, `'fr'`). Defaults to no-op locale.
+     */
+    static gettext(id, locale) {
+        const text = this.lookupTranslation(id, locale);
+        if (typeof text === 'undefined') {
+            return id;
+        }
+        return text;
+    }
+    /**
+     * Register locale translations.
+     * @param locale Locale name (i.e.: `'he'`, `'fr'`)
+     * @param data parsed data from a `.po` file.
+     */
+    static addLocale(locale, data) {
+        locale = checkLocale(locale);
+        const ctx = data.contexts;
+        if (typeof ctx !== 'object' || typeof ctx[''] !== 'object') {
+            throw new TypeError(`Locale '${locale}' invalid compact format`);
+        }
+        locales.set(locale, ctx['']);
+    }
+    /**
+     * Adds a translation to `locale`, replacing any previous translation.
+     * @param locale Locale name (i.e: `'he'`, `'fr'`).
+     * @param id Message ID to translate
+     * @param translation Translation text
+     */
+    static addTranslation(locale, id, translation) {
+        const loc = getExistingLocale(locale);
+        if (typeof id !== 'string' || id.length === 0) {
+            throw new TypeError(`Invalid id string: ${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 string: ${translation}`);
+        }
+        loc[id] = isArray ? translation : [translation];
+    }
+    /**
+     * Adds multiple translations to `locale`, replacing any previous translations.
+     * @param locale Locale name (i.e: `'he'`, `'fr'`).
+     * @param data parsed data from a `.po` file.
+     */
+    static addTranslations(locale, data) {
+        const loc = getExistingLocale(locale);
+        const ctx = data.contexts;
+        if (typeof ctx !== 'object' || typeof ctx[''] !== 'object') {
+            throw new TypeError(`Locale '${locale}' invalid compact format`);
+        }
+        Object.assign(loc, ctx['']);
+    }
+    /**
+     * Returns the names of registered locales
+     */
+    static getLocaleNames() {
+        const keys = Array.from(locales.keys());
+        return keys.sort((a, b) => a.localeCompare(b));
+    }
+    /**
+     * Checks whether a locale has been registered
+     * @param locale Locale name (i.e: `'he'`, `'fr'`).
+     */
+    static hasLocale(locale) {
+        const locale1 = checkLocale(locale);
+        return locales.has(locale1);
+    }
+    /**
+     * Renders a number in ordinal, such as 1st, 2nd or 3rd
+     * @param [locale] Optional locale name (i.e: `'he'`, `'fr'`). Defaults to no-op locale.
+     */
+    static ordinal(n, locale) {
+        let locale0 = locale === null || locale === void 0 ? void 0 : locale.toLowerCase();
+        if (!locale0) {
+            return getEnOrdinal(n);
+        }
+        locale0 = alias[locale0] || locale0;
+        switch (locale0) {
+            case 'en':
+            case 'ashkenazi':
+                return getEnOrdinal(n);
+            case 'es':
+                return n + 'º';
+            case 'he':
+            case 'he-x-nonikud':
+                return String(n);
+        }
+        if (locale0.startsWith('ashkenazi')) {
+            return getEnOrdinal(n);
+        }
+        return n + '.';
+    }
+    /**
+     * Removes nekudot from Hebrew string
+     */
+    static hebrewStripNikkud(str) {
+        return hebrewStripNikkud(str);
+    }
+    /**
+     * Makes a copy of entire Hebrew locale with no niqqud
+     */
+    static copyLocaleNoNikud(data) {
+        const strs = data.contexts[''];
+        const m = {};
+        for (const [key, val] of Object.entries(strs)) {
+            m[key] = [hebrewStripNikkud(val[0])];
+        }
+        return {
+            headers: data.headers,
+            contexts: { '': m },
+        };
+    }
+}
+Locale.addLocale('en', noopLocale);
+/* Ashkenazic transliterations */
+Locale.addLocale('ashkenazi', poAshkenazi$1);
+/* Hebrew with nikkud */
+Locale.addLocale('he', poHe$1);
+/* Hebrew without nikkud */
+const poHeNoNikud$1 = Locale.copyLocaleNoNikud(poHe$1);
+Locale.addLocale('he-x-NoNikud', poHeNoNikud$1);
+/*! @hebcal/hdate v0.21.1, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+/*
+    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/>.
+ */
+function mod(x, y) {
+    return x - y * Math.floor(x / y);
+}
+function isSimpleHebrewDate(obj) {
+    return obj.yy !== undefined;
+}
+const UNITS_DAY = 'day';
+const UNITS_WEEK = 'week';
+const UNITS_MONTH = 'month';
+const UNITS_YEAR = 'year';
+/**
+ * A `HDate` represents a Hebrew calendar date.
+ *
+ * An instance of this class encapsulates a date in the Hebrew calendar system.
+ * It consists of a year, month, and day, without any associated time or location data.
+ * The Hebrew calendar is a lunisolar calendar, meaning it is based on both lunar and solar cycles.
+ *
+ * A Hebrew date internally stores three numbers:
+ * - year: The Hebrew year (1-9999). Counted from the traditional Hebrew date of creation (3761 BCE in the Gregorian calendar)
+ * - month: The Hebrew month (1-13). Month 1 is Nisan, month 7 is Tishrei. There are 12 months in a regular year and 13 months in a leap year.
+ * - day: The day of the month (1-30)
+ *
+ * This class uses Rata Die to convert between the Hebrew and Gregorian calendars.
+ *
+ * To calculate times of day, use `Zmanim` class from `@hebcal/core`
+ * @see {@link https://en.wikipedia.org/wiki/Rata_Die | Rata Die}
+ * @see {@link https://hebcal.github.io/api/core/classes/Zmanim.html | Zmanim}
+ */
+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/hdate';
+     *
+     * 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 [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 [month] - Hebrew month of year (1=NISAN, 7=TISHREI)
+     * @param [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
+            this.dd = this.mm = 1;
+            const yy = typeof year === 'string' ? parseInt(year, 10) : year;
+            if (isNaN(yy)) {
+                throw new TypeError(`HDate called with bad year: ${year}`);
+            }
+            this.yy = yy;
+            setMonth(this, month); // will throw if we can't parse
+            const dd = typeof day === 'string' ? parseInt(day, 10) : day;
+            if (isNaN(dd)) {
+                throw new TypeError(`HDate called with bad day: ${day}`);
+            }
+            setDate(this, dd);
+        }
+        else {
+            // 0 arguments
+            if (typeof day === 'undefined' || day === null) {
+                day = new Date();
+            }
+            // 1 argument
+            const abs0 = typeof day === 'number' && !isNaN(day)
+                ? day
+                : isDate(day)
+                    ? greg2abs(day)
+                    : isSimpleHebrewDate(day)
+                        ? day
+                        : null;
+            if (abs0 === null) {
+                throw new TypeError(`HDate called with bad arg: ${day}`);
+            }
+            const isNumber = typeof abs0 === 'number';
+            const d = isNumber ? abs2hebrew(abs0) : abs0;
+            this.yy = d.yy;
+            this.mm = d.mm;
+            this.dd = d.dd;
+            if (isNumber) {
+                this.rd = abs0;
+            }
+        }
+    }
+    /**
+     * Returns the Hebrew year of this Hebrew date
+     * @returns an integer >= 1
+     * @example
+     * const hd = new HDate(new Date(2008, 10, 13)); // 15 Cheshvan 5769
+     * hd.getFullYear(); // 5769
+     */
+    getFullYear() {
+        return this.yy;
+    }
+    /**
+     * Returns `true` if this Hebrew date occurs during a Hebrew leap year
+     * @example
+     * const hd = new HDate(new Date(2008, 10, 13)); // 15 Cheshvan 5769
+     * hd.isLeapYear(); // false
+     */
+    isLeapYear() {
+        return isLeapYear(this.yy);
+    }
+    /**
+     * Returns the Hebrew month (1=NISAN, 7=TISHREI) of this Hebrew date
+     * @returns an integer 1-13
+     * @example
+     * const hd = new HDate(new Date(2008, 10, 13)); // 15 Cheshvan 5769
+     * hd.getMonth(); // 8
+     */
+    getMonth() {
+        return this.mm;
+    }
+    /**
+     * The Tishrei-based month of this Hebrew date. 1 is Tishrei, 7 is Nisan, 13 is Elul in a leap year
+     * @returns an integer 1-13
+     * @example
+     * const hd = new HDate(new Date(2008, 10, 13)); // 15 Cheshvan 5769
+     * hd.getTishreiMonth(); // 2
+     */
+    getTishreiMonth() {
+        const nummonths = monthsInYear(this.getFullYear());
+        return (this.getMonth() + nummonths - 6) % nummonths || nummonths;
+    }
+    /**
+     * Number of days in the month of this Hebrew date (29 or 30)
+     * @returns an integer 29-30
+     * @example
+     * const hd = new HDate(new Date(2008, 10, 13)); // 15 Cheshvan 5769
+     * hd.daysInMonth(); // 29
+     */
+    daysInMonth() {
+        return daysInMonth(this.getMonth(), this.getFullYear());
+    }
+    /**
+     * Gets the day within the month (1-30)
+     * @returns an integer 1-30
+     * @example
+     * const hd = new HDate(new Date(2008, 10, 13)); // 15 Cheshvan 5769
+     * hd.getDate(); // 15
+     */
+    getDate() {
+        return this.dd;
+    }
+    /**
+     * Returns the day of the week for this Hebrew date,
+     * where 0 represents Sunday, 1 represents Monday, 6 represents Saturday.
+     *
+     * For the day of the month, see `getDate()`
+     * @returns an integer 0-6
+     * @example
+     * const hd = new HDate(new Date(2008, 10, 13)); // 15 Cheshvan 5769
+     * hd.getDate(); // 4
+     */
+    getDay() {
+        return mod(this.abs(), 7);
+    }
+    /**
+     * Converts this Hebrew date to the corresponding Gregorian date.
+     *
+     * The returned `Date` object will be in the local (i.e. host system) time zone.
+     * Hours, minutes, seconds and milliseconds will all be zero.
+     *
+     * Note that this function returns the daytime portion of the date.
+     * For example, the 15th of Cheshvan 5769 began at sundown on
+     * 12 November 2008 and continues through 13 November 2008. This
+     * function would return only the date 13 November 2008.
+     * @example
+     * const hd = new HDate(15, 'Cheshvan', 5769);
+     * const date = hd.greg(); // 13 November 2008
+     * const year = date.getFullYear(); // 2008
+     * const monthNum = date.getMonth() + 1; // 11
+     * const day = date.getDate(); // 13
+     */
+    greg() {
+        return abs2greg(this.abs());
+    }
+    /**
+     * Converts from Hebrew date representation to R.D. (Rata Die) fixed days.
+     * R.D. 1 is the imaginary date Monday, January 1, 1 (Gregorian).
+     * Note also that R.D. = Julian Date − 1,721,424.5
+     * @see {@link https://en.wikipedia.org/wiki/Rata_Die | Rata Die}
+     * @example
+     * const hd = new HDate(15, 'Cheshvan', 5769);
+     * hd.abs(); // 733359
+     */
+    abs() {
+        if (typeof this.rd !== 'number') {
+            this.rd = hebrew2abs(this.yy, this.mm, this.dd);
+        }
+        return this.rd;
+    }
+    /**
+     * 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 year Hebrew year
+     * @param month Hebrew month (1=NISAN, 7=TISHREI)
+     * @param day Hebrew date (1-30)
+     * @example
+     * import {HDate, months} from '@hebcal/hdate';
+     * HDate.hebrew2abs(5769, months.CHESHVAN, 15); // 733359
+     */
+    static hebrew2abs(year, month, day) {
+        return hebrew2abs(year, month, day);
+    }
+    /**
+     * Returns a transliterated Hebrew month name, e.g. `'Elul'` or `'Cheshvan'`.
+     * @example
+     * const hd = new HDate(new Date(2008, 10, 13)); // 15 Cheshvan 5769
+     * hd.getMonthName(); // 'Cheshvan'
+     */
+    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/hdate';
+     *
+     * const hd = new HDate(15, months.CHESHVAN, 5769);
+     * console.log(hd.render('en')); // '15th of Cheshvan, 5769'
+     * console.log(hd.render('he')); // '15 חֶשְׁוָן, 5769'
+     * console.log(hd.render('en', false)); // '15th of Cheshvan'
+     * console.log(hd.render('he', false)); // '15 חֶשְׁוָן'
+     * @param [locale] Optional locale name (defaults to active locale).
+     * @param [showYear=true] Display year (defaults to true).
+     * @see {@link Locale}
+     */
+    render(locale, showYear = true) {
+        const locale0 = locale || 'en';
+        const day = this.getDate();
+        const monthName0 = Locale.gettext(this.getMonthName(), locale0);
+        const monthName = monthName0.replace(/'/g, '’');
+        const nth = Locale.ordinal(day, locale0);
+        const dayOf = getDayOfTranslation(locale0);
+        const dateStr = `${nth}${dayOf} ${monthName}`;
+        if (showYear) {
+            const fullYear = this.getFullYear();
+            return `${dateStr}, ${fullYear}`;
+        }
+        else {
+            return dateStr;
+        }
+    }
+    /**
+     * Renders this Hebrew date in Hebrew gematriya, regardless of locale.
+     * @param suppressNikud - suppress nekudot (default false)
+     * @param suppressYear - suppress Hebrew year (default false)
+     * @example
+     * import {HDate, months} from '@hebcal/hdate';
+     * const hd = new HDate(15, months.CHESHVAN, 5769);
+     * hd.renderGematriya(); // 'ט״ו חֶשְׁוָן תשס״ט'
+     * hd.renderGematriya(true); // 'ט״ו חשון תשס״ט'
+     * hd.renderGematriya(false, true); // 'ט״ו חֶשְׁוָן'
+     */
+    renderGematriya(suppressNikud = false, suppressYear = false) {
+        const d = this.getDate();
+        const locale = suppressNikud ? 'he-x-NoNikud' : 'he';
+        const m = Locale.gettext(this.getMonthName(), locale);
+        const prefix = gematriya(d) + ' ' + m;
+        if (suppressYear) {
+            return prefix;
+        }
+        const y = this.getFullYear();
+        return prefix + ' ' + gematriya(y);
+    }
+    /**
+     * Returns an `HDate` corresponding to the specified day of week
+     * **before** this Hebrew date
+     * @example
+     * new HDate(new Date('Wednesday February 19, 2014')).before(6).greg() // Sat Feb 15 2014
+     * @param dayOfWeek day of week: Sunday=0, Saturday=6
+     */
+    before(dayOfWeek) {
+        return onOrBefore(dayOfWeek, this, -1);
+    }
+    /**
+     * Returns an `HDate` corresponding to the specified day of week
+     * **on or before** this Hebrew date
+     * @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 dayOfWeek day of week: Sunday=0, Saturday=6
+     */
+    onOrBefore(dayOfWeek) {
+        return onOrBefore(dayOfWeek, this, 0);
+    }
+    /**
+     * Returns an `HDate` corresponding to the specified day of week
+     * **nearest** to this Hebrew date
+     * @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 dayOfWeek day of week: Sunday=0, Saturday=6
+     */
+    nearest(dayOfWeek) {
+        return onOrBefore(dayOfWeek, this, 3);
+    }
+    /**
+     * Returns an `HDate` corresponding to the specified day of week
+     * **on or after** this Hebrew date
+     * @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 dayOfWeek day of week: Sunday=0, Saturday=6
+     */
+    onOrAfter(dayOfWeek) {
+        return onOrBefore(dayOfWeek, this, 6);
+    }
+    /**
+     * Returns an `HDate` corresponding to the specified day of week
+     * **after** this Hebrew date
+     * @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 dayOfWeek day of week: Sunday=0, Saturday=6
+     */
+    after(dayOfWeek) {
+        return onOrBefore(dayOfWeek, this, 7);
+    }
+    /**
+     * Returns the next Hebrew date
+     * @example
+     * const hd = new HDate(new Date(2008, 10, 13)); // 15 Cheshvan 5769
+     * hd.next(); // '16 Cheshvan 5769'
+     */
+    next() {
+        return new HDate(this.abs() + 1);
+    }
+    /**
+     * Returns the previous Hebrew date
+     * @example
+     * const hd = new HDate(new Date(2008, 10, 13)); // 15 Cheshvan 5769
+     * hd.prev(); // '14 Cheshvan 5769'
+     */
+    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 |
+     */
+    add(amount, units = 'd') {
+        amount =
+            typeof amount === 'string' ? parseInt(amount, 10) : amount;
+        if (!amount) {
+            return new HDate(this);
+        }
+        units = standardizeUnits(units);
+        if (units === UNITS_DAY) {
+            return new HDate(this.abs() + amount);
+        }
+        else if (units === UNITS_WEEK) {
+            return new HDate(this.abs() + 7 * amount);
+        }
+        else if (units === UNITS_YEAR) {
+            return new HDate(this.getDate(), this.getMonth(), this.getFullYear() + amount);
+        }
+        else {
+            // units === UNITS_MONTH
+            let hd = new HDate(this);
+            const sign = amount > 0 ? 1 : -1;
+            amount = Math.abs(amount);
+            for (let i = 0; i < amount; i++) {
+                hd = new HDate(hd.abs() + sign * hd.daysInMonth());
+            }
+            return hd;
+        }
+    }
+    /**
+     * 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/hdate';
+     *
+     * 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
+     */
+    subtract(amount, units = 'd') {
+        return this.add(amount * -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/hdate';
+     *
+     * const hd1 = new HDate(25, months.KISLEV, 5770);
+     * const hd2 = new HDate(15, months.CHESHVAN, 5769);
+     * const days = hd1.deltaDays(hd2); // 394
+     * @param other Hebrew date to compare
+     */
+    deltaDays(other) {
+        return this.abs() - other.abs();
+    }
+    /**
+     * Compares this Hebrew date to another date, returning `true` if the dates match.
+     * @param other Hebrew date to compare
+     * @example
+     * const hd1 = new HDate(new Date(2008, 10, 13));
+     * const hd2 = new HDate(15, 'Cheshvan', 5769);
+     * hd1.isSameDate(hd2); // true
+     */
+    isSameDate(other) {
+        return this.yy === other.yy && this.mm === other.mm && this.dd === other.dd;
+    }
+    /**
+     * Returns a string representation of this Hebrew date using English transliterations
+     * @example
+     * const hd = new HDate(new Date(2008, 10, 13)); // 15 Cheshvan 5769
+     * hd.toString(); // '15 Cheshvan 5769'
+     */
+    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 year Hebrew year
+     * @example
+     * HDate.isLeapYear(5783); // false
+     * HDate.isLeapYear(5784); // true
+     */
+    static isLeapYear(year) {
+        return isLeapYear(year);
+    }
+    /**
+     * Number of months in this Hebrew year (either 12 or 13 depending on leap year)
+     * @param year Hebrew year
+     * @example
+     * HDate.monthsInYear(5783); // 12
+     * HDate.monthsInYear(5784); // 13
+     */
+    static monthsInYear(year) {
+        return monthsInYear(year);
+    }
+    /**
+     * Number of days in Hebrew month in a given year (29 or 30)
+     * @param month Hebrew month (e.g. months.TISHREI)
+     * @param year Hebrew year
+     * @example
+     * import {HDate, months} from '@hebcal/hdate';
+     * HDate.daysInMonth(months.CHESHVAN, 5769); // 29
+     */
+    static daysInMonth(month, year) {
+        return daysInMonth(month, year);
+    }
+    /**
+     * Returns a transliterated string name of Hebrew month in year,
+     * for example 'Elul' or 'Cheshvan'.
+     * @param month Hebrew month (e.g. months.TISHREI)
+     * @param year Hebrew year
+     * @example
+     * import {HDate, months} from '@hebcal/hdate';
+     * HDate.getMonthName(months.CHESHVAN, 5769); // 'Cheshvan'
+     */
+    static getMonthName(month, year) {
+        return getMonthName(month, year);
+    }
+    /**
+     * Returns the Hebrew month number (NISAN=1, TISHREI=7)
+     * @param month A number, or Hebrew month name string
+     * @example
+     * import {HDate, months} from '@hebcal/hdate';
+     * HDate.monthNum(months.CHESHVAN); // 8
+     * HDate.monthNum('Cheshvan'); // 8
+     * HDate.monthNum('חשון'); // 8
+     */
+    static monthNum(month) {
+        if (typeof month === 'number') {
+            if (isNaN(month) || month > 14) {
+                throw new RangeError(`bad monthNum: ${month}`);
+            }
+            return month;
+        }
+        return month.charCodeAt(0) >= 48 && month.charCodeAt(0) <= 57 /* number */
+            ? parseInt(month, 10)
+            : monthFromName(month);
+    }
+    /**
+     * Number of days in the Hebrew year.
+     * Regular years can have 353, 354, or 355 days.
+     * Leap years can have 383, 384, or 385 days.
+     * @param year Hebrew year
+     * @example
+     * HDate.daysInYear(5783); // 355
+     * HDate.daysInYear(5784); // 383
+     */
+    static daysInYear(year) {
+        return daysInYear(year);
+    }
+    /**
+     * true if Cheshvan is long in Hebrew year
+     * @param year Hebrew year
+     * @example
+     * HDate.longCheshvan(5783); // true
+     * HDate.longCheshvan(5784); // false
+     */
+    static longCheshvan(year) {
+        return longCheshvan(year);
+    }
+    /**
+     * true if Kislev is short in Hebrew year
+     * @param year Hebrew year
+     * @example
+     * HDate.shortKislev(5783); // false
+     * HDate.shortKislev(5784); // true
+     */
+    static shortKislev(year) {
+        return shortKislev(year);
+    }
+    /**
+     * Converts Hebrew month string name to numeric
+     * @example
+     * import {HDate, months} from '@hebcal/hdate';
+     * HDate.monthFromName(months.CHESHVAN); // 8
+     * HDate.monthFromName('Cheshvan'); // 8
+     * HDate.monthFromName('חשון'); // 8
+     */
+    static monthFromName(monthName) {
+        return monthFromName(monthName);
+    }
+    /**
+     * Convenience function for determining the R.D. date
+     * near a specified R.D. date, corresponding to the specified day of week.
+     *
+     * Note: Applying this function to d+6 gives us the `dayOfWeek` on or after an
+     * absolute day d. Similarly, applying it to d+3 gives the `dayOfWeek` nearest to
+     * absolute date d, applying it to d-1 gives the `dayOfWeek` previous to absolute
+     * date d, and applying it to d+7 gives the `dayOfWeek` following absolute date d.
+     * @param dayOfWeek day of week: Sunday=0, Saturday=6
+     */
+    static dayOnOrBefore(dayOfWeek, absdate) {
+        return absdate - ((absdate - dayOfWeek) % 7);
+    }
+    /**
+     * Tests if the object is an instance of `HDate`
+     * @example
+     * HDate.isHDate(new HDate()); // true
+     * HDate.isHDate(new Date()); // false
+     * HDate.isHDate(null); // false
+     * HDate.isHDate(12345); // false
+     * HDate.isHDate('15 Cheshvan 5769'); // false
+     */
+    static isHDate(obj) {
+        return (obj !== null &&
+            typeof obj === 'object' &&
+            typeof obj.yy === 'number' &&
+            typeof obj.mm === 'number' &&
+            typeof obj.dd === '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
+     */
+    static fromGematriyaString(str, currentThousands = 5000) {
+        const parts = str.split(' ').filter(x => x.length !== 0);
+        const numParts = parts.length;
+        if (numParts !== 3 && numParts !== 4) {
+            throw new RangeError(`cannot parse gematriya str: "${str}"`);
+        }
+        const day = gematriyaStrToNum(parts[0]);
+        const monthStr = numParts === 3 ? parts[1] : parts[1] + ' ' + parts[2];
+        const month = monthFromName(monthStr);
+        const yearStr = numParts === 3 ? parts[2] : parts[3];
+        let year = gematriyaStrToNum(yearStr);
+        if (year < 1000) {
+            year += currentThousands;
+        }
+        return new HDate(day, month, year);
+    }
+}
+function standardizeUnits(units) {
+    switch (units) {
+        case 'd':
+            return UNITS_DAY;
+        case 'w':
+            return UNITS_WEEK;
+        case 'M':
+            return UNITS_MONTH;
+        case 'y':
+            return UNITS_YEAR;
+    }
+    const str = String(units || '')
+        .toLowerCase()
+        .replace(/s$/, '');
+    switch (str) {
+        case UNITS_DAY:
+        case UNITS_WEEK:
+        case UNITS_MONTH:
+        case UNITS_YEAR:
+            return str;
+    }
+    throw new TypeError(`Invalid units '${units}'`);
+}
+function 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 '';
+}
+/**
+ * Sets the day of the month of the date. Returns the object it was called upon
+ * @private
+ * @param month A number, or Hebrew month name string
+ */
+function setMonth(hd, month) {
+    hd.mm = HDate.monthNum(month);
+    fix(hd);
+    return hd;
+}
+function setDate(hd, date) {
+    hd.dd = date;
+    fix(hd);
+    return hd;
+}
+function fix(hd) {
+    fixMonth(hd);
+    fixDate(hd);
+}
+function fixDate(hd) {
+    if (hd.dd < 1) {
+        if (hd.mm === months.TISHREI) {
+            hd.yy -= 1;
+        }
+        hd.dd += daysInMonth(hd.mm, hd.yy);
+        hd.mm -= 1;
+        fix(hd);
+    }
+    if (hd.dd > daysInMonth(hd.mm, hd.yy)) {
+        if (hd.mm === months.ELUL) {
+            hd.yy += 1;
+        }
+        hd.dd -= daysInMonth(hd.mm, hd.yy);
+        if (hd.mm === monthsInYear(hd.yy)) {
+            hd.mm = 1; // rollover to NISAN
+        }
+        else {
+            hd.mm += 1;
+        }
+        fix(hd);
+    }
+    fixMonth(hd);
+}
+function fixMonth(hd) {
+    if (hd.mm === months.ADAR_II && !hd.isLeapYear()) {
+        hd.mm -= 1; // to Adar I
+        fix(hd);
+    }
+    else if (hd.mm < 1) {
+        hd.mm += monthsInYear(hd.yy);
+        hd.yy -= 1;
+        fix(hd);
+    }
+    else if (hd.mm > monthsInYear(hd.yy)) {
+        hd.mm -= monthsInYear(hd.yy);
+        hd.yy += 1;
+        fix(hd);
+    }
+    delete hd.rd;
+}
+function onOrBefore(day, t, offset) {
+    return new HDate(HDate.dayOnOrBefore(day, t.abs() + offset));
+}
+class QuickLRU extends Map {
+    constructor(options = {}) {
+        super();
+        _QuickLRU_instances.add(this);
+        _QuickLRU_size.set(this, 0);
+        _QuickLRU_cache.set(this, new Map());
+        _QuickLRU_oldCache.set(this, new Map());
+        _QuickLRU_maxSize.set(this, void 0);
+        _QuickLRU_maxAge.set(this, void 0);
+        _QuickLRU_onEviction.set(this, void 0);
+        if (!(options.maxSize && options.maxSize > 0)) {
+            throw new TypeError('`maxSize` must be a number greater than 0');
+        }
+        if (typeof options.maxAge === 'number' && options.maxAge === 0) {
+            throw new TypeError('`maxAge` must be a number greater than 0');
+        }
+        __classPrivateFieldSet(this, _QuickLRU_maxSize, options.maxSize, "f");
+        __classPrivateFieldSet(this, _QuickLRU_maxAge, options.maxAge || Number.POSITIVE_INFINITY, "f");
+        __classPrivateFieldSet(this, _QuickLRU_onEviction, options.onEviction, "f");
+    }
+    // For tests.
+    get __oldCache() {
+        return __classPrivateFieldGet(this, _QuickLRU_oldCache, "f");
+    }
+    get(key) {
+        if (__classPrivateFieldGet(this, _QuickLRU_cache, "f").has(key)) {
+            const item = __classPrivateFieldGet(this, _QuickLRU_cache, "f").get(key);
+            return __classPrivateFieldGet(this, _QuickLRU_instances, "m", _QuickLRU_getItemValue).call(this, key, item);
+        }
+        if (__classPrivateFieldGet(this, _QuickLRU_oldCache, "f").has(key)) {
+            const item = __classPrivateFieldGet(this, _QuickLRU_oldCache, "f").get(key);
+            if (__classPrivateFieldGet(this, _QuickLRU_instances, "m", _QuickLRU_deleteIfExpired).call(this, key, item) === false) {
+                __classPrivateFieldGet(this, _QuickLRU_instances, "m", _QuickLRU_moveToRecent).call(this, key, item);
+                return item.value;
+            }
+        }
+    }
+    set(key, value, { maxAge = __classPrivateFieldGet(this, _QuickLRU_maxAge, "f") } = {}) {
+        const expiry = typeof maxAge === 'number' && maxAge !== Number.POSITIVE_INFINITY
+            ? (Date.now() + maxAge)
+            : undefined;
+        if (__classPrivateFieldGet(this, _QuickLRU_cache, "f").has(key)) {
+            __classPrivateFieldGet(this, _QuickLRU_cache, "f").set(key, {
+                value,
+                expiry,
+            });
+        }
+        else {
+            __classPrivateFieldGet(this, _QuickLRU_instances, "m", _QuickLRU_set).call(this, key, { value, expiry });
+        }
+        return this;
+    }
+    has(key) {
+        if (__classPrivateFieldGet(this, _QuickLRU_cache, "f").has(key)) {
+            return !__classPrivateFieldGet(this, _QuickLRU_instances, "m", _QuickLRU_deleteIfExpired).call(this, key, __classPrivateFieldGet(this, _QuickLRU_cache, "f").get(key));
+        }
+        if (__classPrivateFieldGet(this, _QuickLRU_oldCache, "f").has(key)) {
+            return !__classPrivateFieldGet(this, _QuickLRU_instances, "m", _QuickLRU_deleteIfExpired).call(this, key, __classPrivateFieldGet(this, _QuickLRU_oldCache, "f").get(key));
+        }
+        return false;
+    }
+    peek(key) {
+        if (__classPrivateFieldGet(this, _QuickLRU_cache, "f").has(key)) {
+            return __classPrivateFieldGet(this, _QuickLRU_instances, "m", _QuickLRU_peek).call(this, key, __classPrivateFieldGet(this, _QuickLRU_cache, "f"));
+        }
+        if (__classPrivateFieldGet(this, _QuickLRU_oldCache, "f").has(key)) {
+            return __classPrivateFieldGet(this, _QuickLRU_instances, "m", _QuickLRU_peek).call(this, key, __classPrivateFieldGet(this, _QuickLRU_oldCache, "f"));
+        }
+    }
+    expiresIn(key) {
+        var _a;
+        const item = (_a = __classPrivateFieldGet(this, _QuickLRU_cache, "f").get(key)) !== null && _a !== void 0 ? _a : __classPrivateFieldGet(this, _QuickLRU_oldCache, "f").get(key);
+        if (item) {
+            return item.expiry ? item.expiry - Date.now() : Number.POSITIVE_INFINITY;
+        }
+    }
+    delete(key) {
+        var _a;
+        const deleted = __classPrivateFieldGet(this, _QuickLRU_cache, "f").delete(key);
+        if (deleted) {
+            __classPrivateFieldSet(this, _QuickLRU_size, (_a = __classPrivateFieldGet(this, _QuickLRU_size, "f"), _a--, _a), "f");
+        }
+        return __classPrivateFieldGet(this, _QuickLRU_oldCache, "f").delete(key) || deleted;
+    }
+    clear() {
+        __classPrivateFieldGet(this, _QuickLRU_cache, "f").clear();
+        __classPrivateFieldGet(this, _QuickLRU_oldCache, "f").clear();
+        __classPrivateFieldSet(this, _QuickLRU_size, 0, "f");
+    }
+    resize(newSize) {
+        if (!(newSize && newSize > 0)) {
+            throw new TypeError('`maxSize` must be a number greater than 0');
+        }
+        const items = [...__classPrivateFieldGet(this, _QuickLRU_instances, "m", _QuickLRU_entriesAscending).call(this)];
+        const removeCount = items.length - newSize;
+        if (removeCount < 0) {
+            __classPrivateFieldSet(this, _QuickLRU_cache, new Map(items), "f");
+            __classPrivateFieldSet(this, _QuickLRU_oldCache, new Map(), "f");
+            __classPrivateFieldSet(this, _QuickLRU_size, items.length, "f");
+        }
+        else {
+            if (removeCount > 0) {
+                __classPrivateFieldGet(this, _QuickLRU_instances, "m", _QuickLRU_emitEvictions).call(this, items.slice(0, removeCount));
+            }
+            __classPrivateFieldSet(this, _QuickLRU_oldCache, new Map(items.slice(removeCount)), "f");
+            __classPrivateFieldSet(this, _QuickLRU_cache, new Map(), "f");
+            __classPrivateFieldSet(this, _QuickLRU_size, 0, "f");
+        }
+        __classPrivateFieldSet(this, _QuickLRU_maxSize, newSize, "f");
+    }
+    evict(count = 1) {
+        const requested = Number(count);
+        if (!requested || requested <= 0) {
+            return;
+        }
+        const items = [...__classPrivateFieldGet(this, _QuickLRU_instances, "m", _QuickLRU_entriesAscending).call(this)];
+        const evictCount = Math.trunc(Math.min(requested, Math.max(items.length - 1, 0)));
+        if (evictCount <= 0) {
+            return;
+        }
+        __classPrivateFieldGet(this, _QuickLRU_instances, "m", _QuickLRU_emitEvictions).call(this, items.slice(0, evictCount));
+        __classPrivateFieldSet(this, _QuickLRU_oldCache, new Map(items.slice(evictCount)), "f");
+        __classPrivateFieldSet(this, _QuickLRU_cache, new Map(), "f");
+        __classPrivateFieldSet(this, _QuickLRU_size, 0, "f");
+    }
+    *keys() {
+        for (const [key] of this) {
+            yield key;
+        }
+    }
+    *values() {
+        for (const [, value] of this) {
+            yield value;
+        }
+    }
+    *[(_QuickLRU_size = new WeakMap(), _QuickLRU_cache = new WeakMap(), _QuickLRU_oldCache = new WeakMap(), _QuickLRU_maxSize = new WeakMap(), _QuickLRU_maxAge = new WeakMap(), _QuickLRU_onEviction = new WeakMap(), _QuickLRU_instances = new WeakSet(), _QuickLRU_emitEvictions = function _QuickLRU_emitEvictions(cache) {
+        if (typeof __classPrivateFieldGet(this, _QuickLRU_onEviction, "f") !== 'function') {
+            return;
+        }
+        for (const [key, item] of cache) {
+            __classPrivateFieldGet(this, _QuickLRU_onEviction, "f").call(this, key, item.value);
+        }
+    }, _QuickLRU_deleteIfExpired = function _QuickLRU_deleteIfExpired(key, item) {
+        if (typeof item.expiry === 'number' && item.expiry <= Date.now()) {
+            if (typeof __classPrivateFieldGet(this, _QuickLRU_onEviction, "f") === 'function') {
+                __classPrivateFieldGet(this, _QuickLRU_onEviction, "f").call(this, key, item.value);
+            }
+            return this.delete(key);
+        }
+        return false;
+    }, _QuickLRU_getOrDeleteIfExpired = function _QuickLRU_getOrDeleteIfExpired(key, item) {
+        const deleted = __classPrivateFieldGet(this, _QuickLRU_instances, "m", _QuickLRU_deleteIfExpired).call(this, key, item);
+        if (deleted === false) {
+            return item.value;
+        }
+    }, _QuickLRU_getItemValue = function _QuickLRU_getItemValue(key, item) {
+        return item.expiry ? __classPrivateFieldGet(this, _QuickLRU_instances, "m", _QuickLRU_getOrDeleteIfExpired).call(this, key, item) : item.value;
+    }, _QuickLRU_peek = function _QuickLRU_peek(key, cache) {
+        const item = cache.get(key);
+        return __classPrivateFieldGet(this, _QuickLRU_instances, "m", _QuickLRU_getItemValue).call(this, key, item);
+    }, _QuickLRU_set = function _QuickLRU_set(key, value) {
+        var _a;
+        __classPrivateFieldGet(this, _QuickLRU_cache, "f").set(key, value);
+        __classPrivateFieldSet(this, _QuickLRU_size, (_a = __classPrivateFieldGet(this, _QuickLRU_size, "f"), _a++, _a), "f");
+        if (__classPrivateFieldGet(this, _QuickLRU_size, "f") >= __classPrivateFieldGet(this, _QuickLRU_maxSize, "f")) {
+            __classPrivateFieldSet(this, _QuickLRU_size, 0, "f");
+            __classPrivateFieldGet(this, _QuickLRU_instances, "m", _QuickLRU_emitEvictions).call(this, __classPrivateFieldGet(this, _QuickLRU_oldCache, "f"));
+            __classPrivateFieldSet(this, _QuickLRU_oldCache, __classPrivateFieldGet(this, _QuickLRU_cache, "f"), "f");
+            __classPrivateFieldSet(this, _QuickLRU_cache, new Map(), "f");
+        }
+    }, _QuickLRU_moveToRecent = function _QuickLRU_moveToRecent(key, item) {
+        __classPrivateFieldGet(this, _QuickLRU_oldCache, "f").delete(key);
+        __classPrivateFieldGet(this, _QuickLRU_instances, "m", _QuickLRU_set).call(this, key, item);
+    }, _QuickLRU_entriesAscending = function* _QuickLRU_entriesAscending() {
+        for (const item of __classPrivateFieldGet(this, _QuickLRU_oldCache, "f")) {
+            const [key, value] = item;
+            if (!__classPrivateFieldGet(this, _QuickLRU_cache, "f").has(key)) {
+                const deleted = __classPrivateFieldGet(this, _QuickLRU_instances, "m", _QuickLRU_deleteIfExpired).call(this, key, value);
+                if (deleted === false) {
+                    yield item;
+                }
+            }
+        }
+        for (const item of __classPrivateFieldGet(this, _QuickLRU_cache, "f")) {
+            const [key, value] = item;
+            const deleted = __classPrivateFieldGet(this, _QuickLRU_instances, "m", _QuickLRU_deleteIfExpired).call(this, key, value);
+            if (deleted === false) {
+                yield item;
+            }
+        }
+    }, Symbol.iterator)]() {
+        for (const item of __classPrivateFieldGet(this, _QuickLRU_cache, "f")) {
+            const [key, value] = item;
+            const deleted = __classPrivateFieldGet(this, _QuickLRU_instances, "m", _QuickLRU_deleteIfExpired).call(this, key, value);
+            if (deleted === false) {
+                yield [key, value.value];
+            }
+        }
+        for (const item of __classPrivateFieldGet(this, _QuickLRU_oldCache, "f")) {
+            const [key, value] = item;
+            if (!__classPrivateFieldGet(this, _QuickLRU_cache, "f").has(key)) {
+                const deleted = __classPrivateFieldGet(this, _QuickLRU_instances, "m", _QuickLRU_deleteIfExpired).call(this, key, value);
+                if (deleted === false) {
+                    yield [key, value.value];
+                }
+            }
+        }
+    }
+    *entriesDescending() {
+        let items = [...__classPrivateFieldGet(this, _QuickLRU_cache, "f")];
+        for (let i = items.length - 1; i >= 0; --i) {
+            const item = items[i];
+            const [key, value] = item;
+            const deleted = __classPrivateFieldGet(this, _QuickLRU_instances, "m", _QuickLRU_deleteIfExpired).call(this, key, value);
+            if (deleted === false) {
+                yield [key, value.value];
+            }
+        }
+        items = [...__classPrivateFieldGet(this, _QuickLRU_oldCache, "f")];
+        for (let i = items.length - 1; i >= 0; --i) {
+            const item = items[i];
+            const [key, value] = item;
+            if (!__classPrivateFieldGet(this, _QuickLRU_cache, "f").has(key)) {
+                const deleted = __classPrivateFieldGet(this, _QuickLRU_instances, "m", _QuickLRU_deleteIfExpired).call(this, key, value);
+                if (deleted === false) {
+                    yield [key, value.value];
+                }
+            }
+        }
+    }
+    *entriesAscending() {
+        for (const [key, value] of __classPrivateFieldGet(this, _QuickLRU_instances, "m", _QuickLRU_entriesAscending).call(this)) {
+            yield [key, value.value];
+        }
+    }
+    get size() {
+        if (!__classPrivateFieldGet(this, _QuickLRU_size, "f")) {
+            return __classPrivateFieldGet(this, _QuickLRU_oldCache, "f").size;
+        }
+        let oldCacheSize = 0;
+        for (const key of __classPrivateFieldGet(this, _QuickLRU_oldCache, "f").keys()) {
+            if (!__classPrivateFieldGet(this, _QuickLRU_cache, "f").has(key)) {
+                oldCacheSize++;
+            }
+        }
+        return Math.min(__classPrivateFieldGet(this, _QuickLRU_size, "f") + oldCacheSize, __classPrivateFieldGet(this, _QuickLRU_maxSize, "f"));
+    }
+    get maxSize() {
+        return __classPrivateFieldGet(this, _QuickLRU_maxSize, "f");
+    }
+    get maxAge() {
+        return __classPrivateFieldGet(this, _QuickLRU_maxAge, "f");
+    }
+    entries() {
+        return this.entriesAscending();
+    }
+    forEach(callbackFunction, thisArgument = this) {
+        for (const [key, value] of this.entriesAscending()) {
+            callbackFunction.call(thisArgument, value, key, this);
+        }
+    }
+    get [Symbol.toStringTag]() {
+        return 'QuickLRU';
+    }
+    toString() {
+        return `QuickLRU(${this.size}/${this.maxSize})`;
+    }
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return this.toString();
+    }
+}
+/*! @hebcal/core v6.0.7, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+var poAshkenazi = { "headers": { "plural-forms": "nplurals=2; plural=(n > 1);", "language": "en_CA@ashkenazi" }, "contexts": { "": { "Shabbat": ["Shabbos"], "Achrei Mot": ["Achrei Mos"], "Bechukotai": ["Bechukosai"], "Beha'alotcha": ["Beha’aloscha"], "Bereshit": ["Bereshis"], "Chukat": ["Chukas"], "Erev Shavuot": ["Erev Shavuos"], "Erev Sukkot": ["Erev Sukkos"], "Ki Tavo": ["Ki Savo"], "Ki Teitzei": ["Ki Seitzei"], "Ki Tisa": ["Ki Sisa"], "Matot": ["Matos"], "Pesach Shabbat Chol ha-Moed": ["Pesach Shabbos Chol ha-Moed"], "Purim Katan": ["Purim Koton"], "Shabbat Chazon": ["Shabbos Chazon"], "Shabbat HaChodesh": ["Shabbos HaChodesh"], "Shabbat HaGadol": ["Shabbos HaGadol"], "Shabbat Nachamu": ["Shabbos Nachamu"], "Shabbat Parah": ["Shabbos Parah"], "Shabbat Shekalim": ["Shabbos Shekalim"], "Shabbat Shuva": ["Shabbos Shuvah"], "Shabbat Zachor": ["Shabbos Zachor"], "Shavuot": ["Shavuos"], "Shavuot I": ["Shavuos I"], "Shavuot II": ["Shavuos II"], "Shemot": ["Shemos"], "Shmini Atzeret": ["Shmini Atzeres"], "Simchat Torah": ["Simchas Torah"], "Sukkot": ["Sukkos"], "Sukkot I": ["Sukkos I"], "Sukkot II": ["Sukkos II"], "Sukkot II (CH''M)": ["Sukkos II (CH’’M)"], "Sukkot III (CH''M)": ["Sukkos III (CH’’M)"], "Sukkot IV (CH''M)": ["Sukkos IV (CH’’M)"], "Sukkot V (CH''M)": ["Sukkos V (CH’’M)"], "Sukkot VI (CH''M)": ["Sukkos VI (CH’’M)"], "Sukkot VII (Hoshana Raba)": ["Sukkos VII (Hoshana Raba)"], "Sukkot Shabbat Chol ha-Moed": ["Sukkos Shabbos Chol ha-Moed"], "Ta'anit Bechorot": ["Ta’anis Bechoros"], "Ta'anit Esther": ["Ta’anis Esther"], "Toldot": ["Toldos"], "Vaetchanan": ["Vaeschanan"], "Yitro": ["Yisro"], "Vezot Haberakhah": ["Vezos Haberakhah"], "Parashat": ["Parshas"], "Leil Selichot": ["Leil Selichos"], "Shabbat Mevarchim Chodesh": ["Shabbos Mevorchim Chodesh"], "Shabbat Shirah": ["Shabbos Shirah"], "Asara B'Tevet": ["Asara B’Teves"], "Alot HaShachar": ["Alos HaShachar"], "Kriat Shema, sof zeman": ["Krias Shema, sof zman"], "Tefilah, sof zeman": ["Tefilah, sof zman"], "Kriat Shema, sof zeman (MGA)": ["Krias Shema, sof zman (MGA)"], "Tefilah, sof zeman (MGA)": ["Tefilah, sof zman (MGA)"], "Chatzot HaLailah": ["Chatzos HaLailah"], "Chatzot hayom": ["Chatzos"], "Tzeit HaKochavim": ["Tzeis HaKochavim"], "Birkat Hachamah": ["Birkas Hachamah"], "Shushan Purim Katan": ["Shushan Purim Koton"] } } };
+/*! @hebcal/core v6.0.7, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+var poHe = { "headers": { "plural-forms": "nplurals=2; plural=(n > 1);", "language": "he_IL" }, "contexts": { "": { "Shabbat": ["שַׁבָּת"], "Parashat": ["פָּרָשַׁת"], "Achrei Mot": ["אַחֲרֵי מוֹת"], "Balak": ["בָּלָק"], "Bamidbar": ["בְּמִדְבַּר"], "Bechukotai": ["בְּחֻקֹּתַי"], "Beha'alotcha": ["בְּהַעֲלֹתְךָ"], "Behar": ["בְּהַר"], "Bereshit": ["בְּרֵאשִׁית"], "Beshalach": ["בְּשַׁלַּח"], "Bo": ["בֹּא"], "Chayei Sara": ["חַיֵּי שָֹרָה"], "Chukat": ["חֻקַּת"], "Devarim": ["דְּבָרִים"], "Eikev": ["עֵקֶב"], "Emor": ["אֱמוֹר"], "Ha'azinu": ["הַאֲזִינוּ"], "Kedoshim": ["קְדֹשִׁים"], "Ki Tavo": ["כִּי־תָבוֹא"], "Ki Teitzei": ["כִּי־תֵצֵא"], "Ki Tisa": ["כִּי תִשָּׂא"], "Korach": ["קֹרַח"], "Lech-Lecha": ["לֶךְ־לְךָ"], "Masei": ["מַסְעֵי"], "Matot": ["מַטּוֹת"], "Metzora": ["מְצֹרָע"], "Miketz": ["מִקֵּץ"], "Mishpatim": ["מִשְׁפָּטִים"], "Nasso": ["נָשׂא"], "Nitzavim": ["נִצָּבִים"], "Noach": ["נֹחַ"], "Pekudei": ["פְקוּדֵי"], "Pinchas": ["פִּינְחָס"], "Re'eh": ["רְאֵה"], "Sh'lach": ["שְׁלַח־לְךָ"], "Shemot": ["שְׁמוֹת"], "Shmini": ["שְּׁמִינִי"], "Shoftim": ["שׁוֹפְטִים"], "Tazria": ["תַזְרִיעַ"], "Terumah": ["תְּרוּמָה"], "Tetzaveh": ["תְּצַוֶּה"], "Toldot": ["תּוֹלְדוֹת"], "Tzav": ["צַו"], "Vaera": ["וָאֵרָא"], "Vaetchanan": ["וָאֶתְחַנַּן"], "Vayakhel": ["וַיַּקְהֵל"], "Vayechi": ["וַיְחִי"], "Vayeilech": ["וַיֵּלֶךְ"], "Vayera": ["וַיֵּרָא"], "Vayeshev": ["וַיֵּשֶׁב"], "Vayetzei": ["וַיֵּצֵא"], "Vayigash": ["וַיִּגַּשׁ"], "Vayikra": ["וַיִּקְרָא"], "Vayishlach": ["וַיִּשְׁלַח"], "Vezot Haberakhah": ["וְזֹאת הַבְּרָכָה"], "Yitro": ["יִתְרוֹ"], "Asara B'Tevet": ["עֲשָׂרָה בְּטֵבֵת"], "Candle lighting": ["הַדְלָקַת נֵרוֹת"], "Chanukah": ["חֲנוּכָּה"], "Chanukah: 1 Candle": ["חֲנוּכָּה: א׳ נֵר"], "Chanukah: 2 Candles": ["חֲנוּכָּה: ב׳ נֵרוֹת"], "Chanukah: 3 Candles": ["חֲנוּכָּה: ג׳ נֵרוֹת"], "Chanukah: 4 Candles": ["חֲנוּכָּה: ד׳ נֵרוֹת"], "Chanukah: 5 Candles": ["חֲנוּכָּה: ה׳ נֵרוֹת"], "Chanukah: 6 Candles": ["חֲנוּכָּה: ו׳ נֵרוֹת"], "Chanukah: 7 Candles": ["חֲנוּכָּה: ז׳ נֵרוֹת"], "Chanukah: 8 Candles": ["חֲנוּכָּה: ח׳ נֵרוֹת"], "Chanukah: 8th Day": ["חֲנוּכָּה: יוֹם ח׳"], "Days of the Omer": ["סְפִירַת הָעוֹמֶר"], "Omer": ["עוֹמֶר"], "day of the Omer": ["בָּעוֹמֶר"], "Erev Pesach": ["עֶרֶב פֶּסַח"], "Erev Purim": ["עֶרֶב פּוּרִים"], "Erev Rosh Hashana": ["עֶרֶב רֹאשׁ הַשָּׁנָה"], "Erev Shavuot": ["עֶרֶב שָׁבוּעוֹת"], "Erev Simchat Torah": ["עֶרֶב שִׂמְחַת תּוֹרָה"], "Erev Sukkot": ["עֶרֶב סוּכּוֹת"], "Erev Tish'a B'Av": ["עֶרֶב תִּשְׁעָה בְּאָב"], "Erev Yom Kippur": ["עֶרֶב יוֹם כִּפּוּר"], "Havdalah": ["הַבְדָּלָה"], "Lag BaOmer": ["ל״ג בָּעוֹמֶר"], "Leil Selichot": ["סְלִיחוֹת"], "Pesach": ["פֶּסַח"], "Pesach I": ["פֶּסַח א׳"], "Pesach II": ["פֶּסַח ב׳"], "Pesach II (CH''M)": ["פֶּסַח ב׳ (חוה״מ)"], "Pesach III (CH''M)": ["פֶּסַח ג׳ (חוה״מ)"], "Pesach IV (CH''M)": ["פֶּסַח ד׳ (חוה״מ)"], "Pesach Sheni": ["פֶּסַח שֵׁנִי"], "Pesach V (CH''M)": ["פֶּסַח ה׳ (חוה״מ)"], "Pesach VI (CH''M)": ["פֶּסַח ו׳ (חוה״מ)"], "Pesach VII": ["פֶּסַח ז׳"], "Pesach VIII": ["פֶּסַח ח׳"], "Pesach Shabbat Chol ha-Moed": ["פֶּסַח שַׁבָּת חוֹל הַמּוֹעֵד"], "Purim": ["פּוּרִים"], "Purim Katan": ["פּוּרִים קָטָן"], "Rosh Chodesh %s": ["רֹאשׁ חוֹדֶשׁ %s"], "Rosh Chodesh": ["רֹאשׁ חוֹדֶשׁ"], "Rosh Hashana": ["רֹאשׁ הַשָּׁנָה"], "Rosh Hashana I": ["רֹאשׁ הַשָּׁנָה א׳"], "Rosh Hashana II": ["רֹאשׁ הַשָּׁנָה ב׳"], "Shabbat Chazon": ["שַׁבַּת חֲזוֹן"], "Shabbat HaChodesh": ["שַׁבַּת הַחֹדֶשׁ"], "Shabbat HaGadol": ["שַׁבַּת הַגָּדוֹל"], "Shabbat Nachamu": ["שַׁבַּת נַחֲמוּ"], "Shabbat Parah": ["שַׁבַּת פָּרָה"], "Shabbat Shekalim": ["שַׁבַּת שְׁקָלִים"], "Shabbat Shuva": ["שַׁבַּת שׁוּבָה"], "Shabbat Zachor": ["שַׁבַּת זָכוֹר"], "Shavuot": ["שָׁבוּעוֹת"], "Shavuot I": ["שָׁבוּעוֹת א׳"], "Shavuot II": ["שָׁבוּעוֹת ב׳"], "Shmini Atzeret": ["שְׁמִינִי עֲצֶרֶת"], "Shushan Purim": ["שׁוּשָׁן פּוּרִים"], "Sigd": ["חַג הַסִּיגְד"], "Simchat Torah": ["שִׂמְחַת תּוֹרָה"], "Sukkot": ["סוּכּוֹת"], "Sukkot I": ["סוּכּוֹת א׳"], "Sukkot II": ["סוּכּוֹת ב׳"], "Sukkot II (CH''M)": ["סוּכּוֹת ב׳ (חוה״מ)"], "Sukkot III (CH''M)": ["סוּכּוֹת ג׳ (חוה״מ)"], "Sukkot IV (CH''M)": ["סוּכּוֹת ד׳ (חוה״מ)"], "Sukkot V (CH''M)": ["סוּכּוֹת ה׳ (חוה״מ)"], "Sukkot VI (CH''M)": ["סוּכּוֹת ו׳ (חוה״מ)"], "Sukkot VII (Hoshana Raba)": ["סוּכּוֹת ז׳ (הוֹשַׁעְנָא רַבָּה)"], "Sukkot Shabbat Chol ha-Moed": ["סוּכּוֹת שַׁבָּת חוֹל הַמּוֹעֵד"], "Ta'anit Bechorot": ["תַּעֲנִית בְּכוֹרוֹת"], "Ta'anit Esther": ["תַּעֲנִית אֶסְתֵּר"], "Tish'a B'Av": ["תִּשְׁעָה בְּאָב"], "Tu B'Av": ["ט״וּ בְּאָב"], "Tu BiShvat": ["ט״וּ בִּשְׁבָט"], "Tu B'Shvat": ["ט״וּ בִּשְׁבָט"], "Tzom Gedaliah": ["צוֹם גְּדַלְיָה"], "Tzom Tammuz": ["צוֹם י״ז בְּתַמּוּז"], "Yom HaAtzma'ut": ["יוֹם הָעַצְמָאוּת"], "Yom HaShoah": ["יוֹם הַשּׁוֹאָה"], "Yom HaZikaron": ["יוֹם הַזִּכָּרוֹן"], "Yom Kippur": ["יוֹם כִּפּוּר"], "Yom Yerushalayim": ["יוֹם יְרוּשָׁלַיִם"], "Yom HaAliyah": ["יוֹם הַעֲלִיָּה"], "Yom HaAliyah School Observance": ["שְׁמִירָת בֵּית הַסֵפֶר לְיוֹם הַעֲלִיָּה"], "Rosh Chodesh Adar": ["רֹאשׁ חוֹדֶשׁ אֲדָר"], "Rosh Chodesh Adar I": ["רֹאשׁ חוֹדֶשׁ אֲדָר א׳"], "Rosh Chodesh Adar II": ["רֹאשׁ חוֹדֶשׁ אֲדָר ב׳"], "Rosh Chodesh Av": ["רֹאשׁ חוֹדֶשׁ אָב"], "Rosh Chodesh Cheshvan": ["רֹאשׁ חוֹדֶשׁ חֶשְׁוָן"], "Rosh Chodesh Elul": ["רֹאשׁ חוֹדֶשׁ אֱלוּל"], "Rosh Chodesh Iyyar": ["רֹאשׁ חוֹדֶשׁ אִיָּיר"], "Rosh Chodesh Kislev": ["רֹאשׁ חוֹדֶשׁ כִּסְלֵו"], "Rosh Chodesh Nisan": ["רֹאשׁ חוֹדֶשׁ נִיסָן"], "Rosh Chodesh Sh'vat": ["רֹאשׁ חוֹדֶשׁ שְׁבָט"], "Rosh Chodesh Sivan": ["רֹאשׁ חוֹדֶשׁ סִיוָן"], "Rosh Chodesh Tamuz": ["רֹאשׁ חוֹדֶשׁ תַּמּוּז"], "Rosh Chodesh Tammuz": ["רֹאשׁ חוֹדֶשׁ תַּמּוּז"], "Rosh Chodesh Tevet": ["רֹאשׁ חוֹדֶשׁ טֵבֵת"], "min": ["דַּקּוֹת"], "Fast begins": ["תְּחִילַּת הַצוֹם"], "Fast ends": ["סִיּוּם הַצוֹם"], "Rosh Hashana LaBehemot": ["רֹאשׁ הַשָּׁנָה לְמַעְשַׂר בְּהֵמָה"], "Tish'a B'Av (observed)": ["(תִּשְׁעָה בְּאָב (נִדְחָה"], "Shabbat Mevarchim Chodesh": ["שַׁבַּת מְבָרְכִים חוֹדֶשׁ"], "Shabbat Shirah": ["שַׁבַּת שִׁירָה"], "Lovingkindness": ["חֶסֶד"], "Might": ["גְּבוּרָה"], "Beauty": ["תִּפְאֶרֶת"], "Eternity": ["נֶּצַח"], "Splendor": ["הוֹד"], "Foundation": ["יְּסוֹד"], "Majesty": ["מַּלְכוּת"], "day": ["יוֹם"], "Yom Kippur Katan": ["יוֹם כִּפּוּר קָטָן"], "Yizkor": ["יִזְכּוֹר"], "Family Day": ["יוֹם הַמִּשׁפָּחָה"], "Yitzhak Rabin Memorial Day": ["יוֹם הַזִּכָּרוֹן לְיִצְחָק רַבִּין"], "Jabotinsky Day": ["יוֹם זַ׳בּוֹטִינְסְקִי"], "Herzl Day": ["יוֹם הֵרְצְל"], "Ben-Gurion Day": ["יוֹם בן־גוריון"], "Hebrew Language Day": ["יוֹם הַשָׂפָה הַעִברִית"], "Birkat Hachamah": ["בִּרְכַּת הַחַמָּה"], "Shushan Purim Katan": ["שׁוּשָׁן פּוּרִים קָטָן"], "Purim Meshulash": ["פּוּרִים מְשׁוּלָּשׁ"], "Chag HaBanot": ["חַג הַבָּנוֹת"], "Molad": ["מוֹלָד הָלְּבָנָה"], "chalakim": ["חֲלָקִים"] } } };
+/*! @hebcal/core v6.0.7, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+var noNikudOverride = { "headers": { "plural-forms": "nplurals=2; plural=(n != 1);", "language": "he-x-NoNikud" }, "contexts": { "": { "Korach": ["קורח"], "Chukat": ["חוקת"], "Yom Kippur": ["יום כיפור"], "Yom Kippur Katan": ["יום כיפור קטן"] } } };
+/*! @hebcal/core v6.0.7, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+Locale.addTranslations('he', poHe);
+Locale.addTranslations('ashkenazi', poAshkenazi);
+/* Hebrew without nikkud */
+const poHeNoNikud = Locale.copyLocaleNoNikud(poHe);
+Locale.addTranslations('he-x-NoNikud', poHeNoNikud);
+Locale.addTranslations('he-x-NoNikud', noNikudOverride);
+/*! @hebcal/core v6.0.7, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+/**
+ * Holiday flags for Event. These flags are typically
+ * combined using bitwise arithmetic to form a mask.
+ * @readonly
+ * @enum {number}
+ */
+const flags = {
+    /** Chag, yontiff, yom tov */
+    CHAG: 0x000001,
+    /** Light candles 18 minutes before sundown */
+    LIGHT_CANDLES: 0x000002,
+    /** End of holiday (end of Yom Tov)  */
+    YOM_TOV_ENDS: 0x000004,
+    /** Observed only in the Diaspora (chutz l'aretz)  */
+    CHUL_ONLY: 0x000008,
+    /** Observed only in Israel */
+    IL_ONLY: 0x000010,
+    /** Light candles in the evening at Tzeit time (3 small stars) */
+    LIGHT_CANDLES_TZEIS: 0x000020,
+    /** Candle-lighting for Chanukah */
+    CHANUKAH_CANDLES: 0x000040,
+    /** Rosh Chodesh, beginning of a new Hebrew month */
+    ROSH_CHODESH: 0x000080,
+    /** Minor fasts like Tzom Tammuz, Ta'anit Esther, ... */
+    MINOR_FAST: 0x000100,
+    /** Shabbat Shekalim, Zachor, ... */
+    SPECIAL_SHABBAT: 0x000200,
+    /** Weekly sedrot on Saturdays */
+    PARSHA_HASHAVUA: 0x000400,
+    /** Days of the Omer */
+    OMER_COUNT: 0x001000,
+    /** Yom HaShoah, Yom HaAtzma'ut, ... */
+    MODERN_HOLIDAY: 0x002000,
+    /** Yom Kippur and Tish'a B'Av */
+    MAJOR_FAST: 0x004000,
+    /** On the Saturday before Rosh Chodesh */
+    SHABBAT_MEVARCHIM: 0x008000,
+    /** Molad */
+    MOLAD: 0x010000,
+    /** Yahrzeit or Hebrew Anniversary */
+    USER_EVENT: 0x020000,
+    /** Daily Hebrew date ("11th of Sivan, 5780") */
+    HEBREW_DATE: 0x040000,
+    /** A holiday that's not major, modern, rosh chodesh, or a fast day */
+    MINOR_HOLIDAY: 0x080000,
+    /** Evening before a major or minor holiday */
+    EREV: 0x100000,
+    /** Chol haMoed, intermediate days of Pesach or Sukkot */
+    CHOL_HAMOED: 0x200000,
+    /** Yom Kippur Katan, minor day of atonement on the day preceeding each Rosh Chodesh */
+    YOM_KIPPUR_KATAN: 0x800000,
+    /** Yizkor */
+    YIZKOR: 0x8000000,
+};
+const flagToCategory = [
+    [flags.MAJOR_FAST, 'holiday', 'major', 'fast'],
+    [flags.CHANUKAH_CANDLES, 'holiday', 'major'],
+    [flags.HEBREW_DATE, 'hebdate'],
+    [flags.MINOR_FAST, 'holiday', 'fast'],
+    [flags.MINOR_HOLIDAY, 'holiday', 'minor'],
+    [flags.MODERN_HOLIDAY, 'holiday', 'modern'],
+    [flags.MOLAD, 'molad'],
+    [flags.OMER_COUNT, 'omer'],
+    [flags.PARSHA_HASHAVUA, 'parashat'], // backwards-compat
+    [flags.ROSH_CHODESH, 'roshchodesh'],
+    [flags.SHABBAT_MEVARCHIM, 'mevarchim'],
+    [flags.SPECIAL_SHABBAT, 'holiday', 'shabbat'],
+    [flags.USER_EVENT, 'user'],
+    [flags.YIZKOR, 'yizkor'],
+];
+/**
+ * Represents an Event with a title, date, and flags.
+ *
+ * Events are used to represent holidays, candle-lighting times,
+ * Torah readings, and more.
+ *
+ * To get the title of the event a language other than English
+ * with Sephardic transliterations, use the `render()` method.
+ */
+class Event {
+    /**
+     * Constructs Event
+     * @param date Hebrew date event occurs
+     * @param desc Description (not translated)
+     * @param [mask=0] optional bitmask of holiday flags (see {@link flags})
+     * @param [attrs={}] optional additional attributes (e.g. `eventTimeStr`, `cholHaMoedDay`)
+     */
+    constructor(date, desc, mask = 0, attrs) {
+        if (!HDate.isHDate(date)) {
+            throw new TypeError(`Invalid Event date: ${date}`);
+        }
+        else if (typeof desc !== 'string') {
+            throw new TypeError(`Invalid Event description: ${desc}`);
+        }
+        this.date = date;
+        this.desc = desc;
+        this.mask = +mask;
+        if (typeof attrs === 'object' && attrs !== null) {
+            Object.assign(this, attrs);
+        }
+    }
+    /**
+     * Hebrew date of this event
+     */
+    getDate() {
+        return this.date;
+    }
+    /**
+     * Gregorian date of this event
+     */
+    greg() {
+        return this.date.greg();
+    }
+    /**
+     * Untranslated title of this event. Note that these description
+     * strings are always in English and will remain stable across releases.
+     * To get the title of the event in another language, use the
+     * `render()` method.
+     */
+    getDesc() {
+        return this.desc;
+    }
+    /**
+     * Bitmask of optional event flags. See {@link flags}
+     */
+    getFlags() {
+        return this.mask;
+    }
+    /**
+     * Returns (translated) description of this event
+     * @example
+     * const ev = new Event(new HDate(6, 'Sivan', 5749), 'Shavuot', flags.CHAG);
+     * ev.render('en'); // 'Shavuot'
+     * ev.render('he'); // 'שָׁבוּעוֹת'
+     * ev.render('ashkenazi'); // 'Shavuos'
+     * @param [locale] Optional locale name (defaults to empty locale)
+     */
+    render(locale) {
+        return Locale.gettext(this.desc, locale);
+    }
+    /**
+     * Returns a brief (translated) description of this event.
+     * For most events, this is the same as render(). For some events, it procudes
+     * a shorter text (e.g. without a time or added description).
+     * @param [locale] Optional locale name (defaults to empty locale)
+     */
+    renderBrief(locale) {
+        return this.render(locale);
+    }
+    /**
+     * Optional holiday-specific Emoji or `null`.
+     */
+    getEmoji() {
+        return this.emoji || null;
+    }
+    /**
+     * Returns a simplified (untranslated) description for this event. For example,
+     * the `HolidayEvent` class supports
+     * "Erev Pesach" => "Pesach", and "Sukkot III (CH''M)" => "Sukkot".
+     * For many holidays the basename and the event description are the same.
+     */
+    basename() {
+        return this.getDesc();
+    }
+    /**
+     * Returns a URL to hebcal.com or sefaria.org for more detail on the event.
+     * Returns `undefined` for events with no detail page.
+     */
+    url() {
+        return undefined;
+    }
+    /**
+     * Is this event observed in Israel?
+     * @example
+     * const ev1 = new Event(new HDate(7, 'Sivan', 5749), 'Shavuot II', flags.CHAG | flags.CHUL_ONLY);
+     * ev1.observedInIsrael(); // false
+     * const ev2 = new Event(new HDate(26, 'Kislev', 5749), 'Chanukah: 3 Candles', 0);
+     * ev2.observedInIsrael(); // true
+     */
+    observedInIsrael() {
+        return !(this.mask & flags.CHUL_ONLY);
+    }
+    /**
+     * Is this event observed in the Diaspora?
+     * @example
+     * const ev1 = new Event(new HDate(7, 'Sivan', 5749), 'Shavuot II', flags.CHAG | flags.CHUL_ONLY);
+     * ev1.observedInDiaspora(); // true
+     * const ev2 = new Event(new HDate(26, 'Kislev', 5749), 'Chanukah: 3 Candles', 0);
+     * ev2.observedInDiaspora(); // true
+     */
+    observedInDiaspora() {
+        return !(this.mask & flags.IL_ONLY);
+    }
+    /**
+     * Is this event observed in Israel/Diaspora?
+     * @example
+     * const ev1 = new Event(new HDate(7, 'Sivan', 5749), 'Shavuot II', flags.CHAG | flags.CHUL_ONLY);
+     * ev1.observedIn(false); // true
+     * ev1.observedIn(true); // false
+     * const ev2 = new Event(new HDate(26, 'Kislev', 5749), 'Chanukah: 3 Candles', 0);
+     * ev2.observedIn(false); // true
+     * ev2.observedIn(true); // true
+     * @param il
+     */
+    observedIn(il) {
+        return il ? this.observedInIsrael() : this.observedInDiaspora();
+    }
+    /**
+     * Returns a list of event categories
+     */
+    getCategories() {
+        const mask = this.getFlags();
+        for (const attrs of flagToCategory) {
+            const attr0 = attrs[0];
+            if (mask & attr0) {
+                return attrs.slice(1);
+            }
+        }
+        return ['unknown'];
+    }
+}
+/*! @hebcal/core v6.0.7, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+const SUN$1 = 0;
+const TUE$1 = 2;
+const FRI$1 = 5;
+const SAT$1 = 6;
+const NISAN$1 = months.NISAN;
+const IYYAR = months.IYYAR;
+/**
+ * Yom HaShoah first observed in 1951.
+ * When the actual date of Yom Hashoah falls on a Friday, the
+ * state of Israel observes Yom Hashoah on the preceding
+ * Thursday. When it falls on a Sunday, Yom Hashoah is observed
+ * on the following Monday.
+ * http://www.ushmm.org/remembrance/dor/calendar/
+ * @private
+ * @param year
+ */
+function dateYomHaShoah(year) {
+    if (year < 5711) {
+        return null;
+    }
+    let nisan27dt = new HDate(27, NISAN$1, year);
+    if (nisan27dt.getDay() === FRI$1) {
+        nisan27dt = new HDate(26, NISAN$1, year);
+    }
+    else if (nisan27dt.getDay() === SUN$1) {
+        nisan27dt = new HDate(28, NISAN$1, year);
+    }
+    return nisan27dt;
+}
+/**
+ * Yom HaAtzma'ut only celebrated after 1948
+ * @private
+ * @param year
+ */
+function dateYomHaZikaron(year) {
+    if (year < 5708) {
+        return null;
+    }
+    let day;
+    const pesach = new HDate(15, NISAN$1, year);
+    const pdow = pesach.getDay();
+    if (pdow === SUN$1) {
+        day = 2;
+    }
+    else if (pdow === SAT$1) {
+        day = 3;
+    }
+    else if (year < 5764) {
+        day = 4;
+    }
+    else if (pdow === TUE$1) {
+        day = 5;
+    }
+    else {
+        day = 4;
+    }
+    return new HDate(day, IYYAR, year);
+}
+/*! @hebcal/core v6.0.7, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+/*
+    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/>.
+ */
+/*
+ * Many of the following algorithms were taken from hebrew calendar
+ * routines by Maimonedes, from his Mishneh Torah, and implemented by
+ *  Nachum Dershowitz                Department of Computer Science
+ *  (217) 333-4219                   University of Illinois at Urbana-Champaign
+ *  nachum@cs.uiuedu               1304 West Springfield Avenue
+ *                                   Urbana, Illinois 61801
+ *
+ * The routines were included in the emacs 19 distribution.
+ *
+ */
+const INCOMPLETE = 0;
+const REGULAR = 1;
+const COMPLETE = 2;
+function yearType(hyear) {
+    const longC = HDate.longCheshvan(hyear);
+    const shortK = HDate.shortKislev(hyear);
+    if (longC && !shortK) {
+        return COMPLETE;
+    }
+    else if (!longC && shortK) {
+        return INCOMPLETE;
+    }
+    else {
+        return REGULAR;
+    }
+}
+/**
+ * Represents Parashah HaShavua for an entire Hebrew year
+ */
+class Sedra {
+    /**
+     * Caculates the Parashah HaShavua for an entire Hebrew year
+     * @param hyear - Hebrew year (e.g. 5749)
+     * @param il - Use Israel sedra schedule (false for Diaspora)
+     */
+    constructor(hyear, il) {
+        hyear = +hyear;
+        this.year = hyear;
+        const rh0 = new HDate(1, months.TISHREI, hyear);
+        const rh = (this.rh = rh0.abs());
+        const rhDay = rh0.getDay() + 1;
+        // find the first Saturday on or after Rosh Hashana
+        this.firstSaturday = HDate.dayOnOrBefore(6, rh + 6);
+        const leap = +HDate.isLeapYear(hyear);
+        this.il = Boolean(il);
+        const type = yearType(hyear);
+        let key = `${leap}${rhDay}${type}`;
+        if (types[key]) {
+            this.theSedraArray = types[key];
+            this.yearKey = key;
+        }
+        else {
+            key = key + +this.il; // cast to num, then concat
+            this.theSedraArray = types[key];
+            this.yearKey = key;
+        }
+        if (!this.theSedraArray) {
+            throw new Error(`improper sedra year type ${key} calculated for ${hyear}`);
+        }
+    }
+    /**
+     * Returns the date that a parsha occurs
+     * or `null` if the parsha doesn't occur this year
+     * @param parsha if a `string`, specified with Sephardic transliterations
+     *  like `'Noach'` or `'Matot-Masei'`. If an array, must be a 1- or 2-element
+     *  array such as `['Noach']` or `['Matot', 'Masei']`. If a `number`, should
+     *  be a 0-based parsha index (`0` for Bereshit, `1` for Noach) or a negative
+     *  number for a doubled parsha (e.g. `-21` for Vayakhel-Pekudei)
+     */
+    find(parsha) {
+        if (typeof parsha === 'number') {
+            if (parsha >= parshiot.length || (parsha < 0 && !isValidDouble(parsha))) {
+                throw new RangeError(`Invalid parsha number: ${parsha}`);
+            }
+            return this.findInternal(parsha);
+        }
+        else if (typeof parsha === 'string') {
+            const num = parsha2id.get(parsha);
+            if (typeof num === 'number') {
+                return this.find(num);
+            }
+            else if (parsha.indexOf('-') !== -1) {
+                if (parsha === CHMPESACH || parsha === CHMSUKOT) {
+                    return this.findInternal(parsha);
+                }
+                return this.find(parsha.split('-'));
+            }
+            else {
+                // try to find Saturday holiday like 'Yom Kippur'
+                return this.findInternal(parsha);
+            }
+        }
+        else if (Array.isArray(parsha)) {
+            const plen = parsha.length;
+            if ((plen !== 1 && plen !== 2) || typeof parsha[0] !== 'string') {
+                throw new TypeError(`Invalid parsha argument: ${JSON.stringify(parsha)}`);
+            }
+            if (plen === 1) {
+                return this.find(parsha[0]);
+            }
+            const p1 = parsha[0];
+            const p2 = parsha[1];
+            const num1 = parsha2id.get(p1);
+            const num2 = parsha2id.get(p2);
+            if (typeof num1 !== 'number' ||
+                typeof num2 !== 'number' ||
+                num2 !== num1 + 1 ||
+                !isValidDouble(-num1)) {
+                throw new RangeError(`Unrecognized parsha name: ${p1}-${p2}`);
+            }
+            return this.find(-num1);
+        }
+        return null; /* NOTREACHED */
+    }
+    findInternal(parsha) {
+        const idx = this.theSedraArray.indexOf(parsha);
+        if (idx === -1) {
+            return null; // doesn't occur this year
+        }
+        return new HDate(this.firstSaturday + idx * 7);
+    }
+    /**
+     * Returns the date that a parsha (or its doubled or undoubled counterpart)
+     * occurs, or `null` if the parsha doesn't occur this year
+     */
+    findContaining(parsha) {
+        const hdate = this.find(parsha);
+        if (hdate) {
+            return hdate;
+        }
+        if (typeof parsha === 'number') {
+            // a valid negative number (double parsha in a year where they are
+            // combined) would've been found above, and a invalid negative number
+            // would've thrown an error, so this parsha must be a positive number
+            // representing either p1 or p2
+            const p1 = -parsha;
+            if (isValidDouble(p1)) {
+                return this.find(p1);
+            }
+            else {
+                // this must be the second individual parsha of a doubled pair
+                // for example 29 for Kedoshim, so check for -28 for Achrei Mot-Kedoshim
+                return this.find(p1 + 1);
+            }
+        }
+        else {
+            const num = parsha2id.get(parsha);
+            if (num) {
+                // parsha is either the first or second individual parsha of
+                // a pair that is doubled this year
+                const p1 = -num;
+                if (isValidDouble(p1)) {
+                    return this.find(p1);
+                }
+                else {
+                    return this.find(p1 + 1);
+                }
+            }
+            else {
+                // this was indeed a doubled parsha, so return date of the first half
+                const [p1] = parsha.split('-');
+                return this.find(p1);
+            }
+        }
+    }
+    /**
+     * Returns the underlying annual sedra schedule.
+     * Used by `@hebcal/triennial`
+     */
+    getSedraArray() {
+        return this.theSedraArray;
+    }
+    /**
+     * R.D. date of the first Saturday on or after Rosh Hashana
+     */
+    getFirstSaturday() {
+        return this.firstSaturday;
+    }
+    getYear() {
+        return this.year;
+    }
+    /**
+     * Returns an object describing the parsha on the first Saturday on or after `hd`
+     * @param hd Hebrew date or R.D. days
+     */
+    lookup(hd) {
+        const abs = typeof hd === 'number' ? hd : HDate.isHDate(hd) ? hd.abs() : NaN;
+        if (isNaN(abs)) {
+            throw new TypeError(`Bad date argument: ${hd}`);
+        }
+        else if (abs < this.rh) {
+            throw new RangeError(`Date ${hd} before start of Hebrew year ${this.year}`);
+        }
+        // find the first saturday on or after today's date
+        const saturday = HDate.dayOnOrBefore(6, abs + 6);
+        const weekNum = (saturday - this.firstSaturday) / 7;
+        const index = this.theSedraArray[weekNum];
+        if (typeof index === 'undefined') {
+            const sedra = getSedra(this.year + 1, this.il);
+            return sedra.lookup(saturday); // must be next year
+        }
+        const hdate = new HDate(saturday);
+        if (typeof index === 'string') {
+            // Shabbat has a chag. Return a description
+            return { parsha: [index], chag: true, hdate, il: this.il, num: 0 };
+        }
+        if (index >= 0) {
+            return {
+                parsha: [parshiot[index]],
+                chag: false,
+                num: index + 1,
+                hdate,
+                il: this.il,
+            };
+        }
+        const p1 = D(index); // undouble the parsha
+        return {
+            parsha: [parshiot[p1], parshiot[p1 + 1]],
+            chag: false,
+            num: [p1 + 1, p1 + 2],
+            hdate,
+            il: this.il,
+        };
+    }
+}
+/**
+ * The 54 parshiyot of the Torah as transilterated strings.
+ * * parshiot[0] == `Bereshit`
+ * * parshiot[1] == `Noach`
+ * * parshiot[52] == `Ha'azinu`
+ * * parshiot[53] == `Vezot Haberakhah`
+ * @readonly
+ * @type {string[]}
+ */
+const parshiot = [
+    'Bereshit',
+    'Noach',
+    'Lech-Lecha',
+    'Vayera',
+    'Chayei Sara',
+    'Toldot',
+    'Vayetzei',
+    'Vayishlach',
+    'Vayeshev',
+    'Miketz',
+    'Vayigash',
+    'Vayechi',
+    'Shemot',
+    'Vaera',
+    'Bo',
+    'Beshalach',
+    'Yitro',
+    'Mishpatim',
+    'Terumah',
+    'Tetzaveh',
+    'Ki Tisa',
+    'Vayakhel',
+    'Pekudei',
+    'Vayikra',
+    'Tzav',
+    'Shmini',
+    'Tazria',
+    'Metzora',
+    'Achrei Mot',
+    'Kedoshim',
+    'Emor',
+    'Behar',
+    'Bechukotai',
+    'Bamidbar',
+    'Nasso',
+    "Beha'alotcha",
+    "Sh'lach",
+    'Korach',
+    'Chukat',
+    'Balak',
+    'Pinchas',
+    'Matot',
+    'Masei',
+    'Devarim',
+    'Vaetchanan',
+    'Eikev',
+    "Re'eh",
+    'Shoftim',
+    'Ki Teitzei',
+    'Ki Tavo',
+    'Nitzavim',
+    'Vayeilech',
+    "Ha'azinu",
+    'Vezot Haberakhah',
+];
+// 0-based parsha IDs
+const parsha2id = new Map();
+for (let id = 0; id < parshiot.length; id++) {
+    const name = parshiot[id];
+    parsha2id.set(name, id);
+}
+// 0-based parsha IDs
+const doubles = [
+    21, // Vayakhel-Pekudei
+    26, // Tazria-Metzora
+    28, // Achrei Mot-Kedoshim
+    31, // Behar-Bechukotai
+    38, // Chukat-Balak
+    41, // Matot-Masei
+    50, // Nitzavim-Vayeilech
+];
+/**
+ * @private
+ * @param id a negative number
+ */
+function isValidDouble(id) {
+    return doubles.includes(-id);
+}
+/**
+ * parsha doubler/undoubler
+ * @private
+ * @param p
+ */
+function D(p) {
+    return -p;
+}
+const RH = 'Rosh Hashana'; // 0
+const YK = 'Yom Kippur'; // 1
+const SUKKOT = 'Sukkot'; // 0
+const CHMSUKOT = 'Sukkot Shabbat Chol ha-Moed'; // 0
+const SHMINI = 'Shmini Atzeret'; // 0
+const PESACH = 'Pesach'; // 25
+const PESACH1 = 'Pesach I';
+const CHMPESACH = 'Pesach Shabbat Chol ha-Moed'; // 25
+const PESACH7 = 'Pesach VII'; // 25
+const PESACH8 = 'Pesach VIII';
+const SHAVUOT$1 = 'Shavuot'; // 33
+/**
+ * Returns an array from start to end
+ * @private
+ * @param start beginning number, inclusive
+ * @param stop ending number, inclusive
+ */
+function range(start, stop) {
+    return Array.from({ length: stop - start + 1 }, (v, k) => k + start);
+}
+const yearStartVayeilech = [51, 52, CHMSUKOT];
+const yearStartHaazinu = [52, YK, CHMSUKOT];
+const yearStartRH = [RH, 52, SUKKOT, SHMINI];
+const r020 = range(0, 20);
+const r027 = range(0, 27);
+const r3340 = range(33, 40);
+const r4349 = range(43, 49);
+const r4350 = range(43, 50);
+/**
+ * The ordinary year types (keviot)
+ * names are leap/nonleap - day - incomplete/regular/complete - diaspora/Israel
+ * @private
+ * @readonly
+ */
+const types = {
+    /* Hebrew year that starts on Monday, is `incomplete' (Heshvan and
+     * Kislev each have 29 days), and has Passover start on Tuesday. */
+    // e.g. 5753
+    '020': yearStartVayeilech.concat(r020, D(21), 23, 24, CHMPESACH, 25, D(26), D(28), 30, D(31), r3340, D(41), r4349, D(50)),
+    /* Hebrew year that starts on Monday, is `complete' (Heshvan and
+     * Kislev each have 30 days), and has Passover start on Thursday. */
+    // e.g. 5756
+    '0220': yearStartVayeilech.concat(r020, D(21), 23, 24, CHMPESACH, 25, D(26), D(28), 30, D(31), 33, SHAVUOT$1, range(34, 37), D(38), 40, D(41), r4349, D(50)),
+    /* Hebrew year that starts on Thursday, is `regular' (Heshvan has 29
+     * days and Kislev has 30 days), and has Passover start on Saturday. */
+    // e.g. 5701
+    '0510': yearStartHaazinu.concat(r020, D(21), 23, 24, PESACH1, PESACH8, 25, D(26), D(28), 30, D(31), r3340, D(41), r4350),
+    /* Hebrew year that starts on Thursday, is `regular' (Heshvan has 29
+     * days and Kislev has 30 days), and has Passover start on Saturday. */
+    // e.g. 5745
+    '0511': yearStartHaazinu.concat(r020, D(21), 23, 24, PESACH, 25, D(26), D(28), range(30, 40), D(41), r4350),
+    /* Hebrew year that starts on Thursday, is `complete' (Heshvan and
+     * Kislev each have 30 days), and has Passover start on Sunday. */
+    // e.g. 5754
+    '052': yearStartHaazinu.concat(range(0, 24), PESACH7, 25, D(26), D(28), 30, D(31), r3340, D(41), r4350),
+    /* Hebrew year that starts on Saturday, is `incomplete' (Heshvan and Kislev
+     * each have 29 days), and has Passover start on Sunday. */
+    // e.g. 5761
+    '070': yearStartRH.concat(r020, D(21), 23, 24, PESACH7, 25, D(26), D(28), 30, D(31), r3340, D(41), r4350),
+    /* Hebrew year that starts on Saturday, is `complete' (Heshvan and
+     * Kislev each have 30 days), and has Passover start on Tuesday. */
+    // e.g. 5716
+    '072': yearStartRH.concat(r020, D(21), 23, 24, CHMPESACH, 25, D(26), D(28), 30, D(31), r3340, D(41), r4349, D(50)),
+    /* --  The leap year types (keviot) -- */
+    /* Hebrew year that starts on Monday, is `incomplete' (Heshvan and
+     * Kislev each have 29 days), and has Passover start on Thursday. */
+    // e.g. 5746
+    '1200': yearStartVayeilech.concat(r027, CHMPESACH, range(28, 33), SHAVUOT$1, range(34, 37), D(38), 40, D(41), r4349, D(50)),
+    /* Hebrew year that starts on Monday, is `incomplete' (Heshvan and
+     * Kislev each have 29 days), and has Passover start on Thursday. */
+    // e.g. 5746
+    '1201': yearStartVayeilech.concat(r027, CHMPESACH, range(28, 40), D(41), r4349, D(50)),
+    /* Hebrew year that starts on Monday, is `complete' (Heshvan and
+     * Kislev each have 30 days), and has Passover start on Saturday. */
+    // e.g.5752
+    '1220': yearStartVayeilech.concat(r027, PESACH1, PESACH8, range(28, 40), D(41), r4350),
+    /* Hebrew year that starts on Monday, is `complete' (Heshvan and
+     * Kislev each have 30 days), and has Passover start on Saturday. */
+    // e.g.5752
+    '1221': yearStartVayeilech.concat(r027, PESACH, range(28, 50)),
+    /* Hebrew year that starts on Thursday, is `incomplete' (Heshvan and
+     * Kislev both have 29 days), and has Passover start on Sunday. */
+    // e.g. 5768
+    '150': yearStartHaazinu.concat(range(0, 28), PESACH7, range(29, 50)),
+    /* Hebrew year that starts on Thursday, is `complete' (Heshvan and
+     * Kislev both have 30 days), and has Passover start on Tuesday. */
+    // eg. 5771
+    '152': yearStartHaazinu.concat(range(0, 28), CHMPESACH, range(29, 49), D(50)),
+    /* Hebrew year that starts on Saturday, is `incomplete' (Heshvan and
+     * Kislev each have 29 days), and has Passover start on Tuesday. */
+    // e.g.5757
+    '170': yearStartRH.concat(r027, CHMPESACH, range(28, 40), D(41), r4349, D(50)),
+    /* Hebrew year that starts on Saturday, is `complete' (Heshvan and
+     * Kislev each have 30 days), and has Passover start on Thursday. */
+    '1720': yearStartRH.concat(r027, CHMPESACH, range(28, 33), SHAVUOT$1, range(34, 37), D(38), 40, D(41), r4349, D(50)),
+};
+/* Hebrew year that starts on Monday, is `complete' (Heshvan and
+ * Kislev each have 30 days), and has Passover start on Thursday. */
+types['0221'] = types['020'];
+/* Hebrew year that starts on Tuesday, is `regular' (Heshvan has 29
+ * days and Kislev has 30 days), and has Passover start on Thursday. */
+// e.g. 5715
+types['0310'] = types['0220'];
+/* Hebrew year that starts on Tuesday, is `regular' (Heshvan has 29
+ * days and Kislev has 30 days), and has Passover start on Thursday. */
+types['0311'] = types['020'];
+/* Hebrew year that starts on Tuesday, is `regular' (Heshvan has 29
+ * days and Kislev has 30 days), and has Passover start on Saturday. */
+// e.g. 5715
+types['1310'] = types['1220'];
+/* Hebrew year that starts on Tuesday, is `regular' (Heshvan has 29
+ * days and Kislev has 30 days), and has Passover start on Saturday. */
+types['1311'] = types['1221'];
+/* Hebrew year that starts on Saturday, is `complete' (Heshvan and
+ * Kislev each have 30 days), and has Passover start on Thursday. */
+types['1721'] = types['170'];
+const sedraCache = new QuickLRU({ maxSize: 400 });
+/**
+ * Convenience function to create an instance of `Sedra` or reuse a previously
+ * created and cached instance.
+ * @param hyear
+ * @param il
+ */
+function getSedra(hyear, il) {
+    const cacheKey = `${hyear}-${il ? 1 : 0}`;
+    let sedra = sedraCache.get(cacheKey);
+    if (!sedra) {
+        sedra = new Sedra(hyear, il);
+        sedraCache.set(cacheKey, sedra);
+    }
+    return sedra;
+}
+/*! @hebcal/core v6.0.7, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+const Nisan = months.NISAN;
+const Iyyar = months.IYYAR;
+const Sivan = months.SIVAN;
+const Tamuz = months.TAMUZ;
+const Av = months.AV;
+const Elul = months.ELUL;
+const Tishrei = months.TISHREI;
+const Cheshvan = months.CHESHVAN;
+const Kislev = months.KISLEV;
+const Shvat = months.SHVAT;
+const Adar2 = months.ADAR_II;
+const CHAG$1 = flags.CHAG;
+const LIGHT_CANDLES = flags.LIGHT_CANDLES;
+const YOM_TOV_ENDS = flags.YOM_TOV_ENDS;
+const CHUL_ONLY = flags.CHUL_ONLY;
+const IL_ONLY$1 = flags.IL_ONLY;
+const LIGHT_CANDLES_TZEIS$1 = flags.LIGHT_CANDLES_TZEIS;
+const MAJOR_FAST$1 = flags.MAJOR_FAST;
+const MINOR_HOLIDAY$1 = flags.MINOR_HOLIDAY;
+const EREV$1 = flags.EREV;
+const CHOL_HAMOED = flags.CHOL_HAMOED;
+const emojiPesach = '🫓';
+const emojiSukkot = '🌿🍋';
+const ROSH_HASHANA_II = 'Rosh Hashana II';
+const EREV_YOM_KIPPUR = 'Erev Yom Kippur';
+const YOM_KIPPUR = 'Yom Kippur';
+const EREV_SUKKOT = 'Erev Sukkot';
+const SUKKOT_I = 'Sukkot I';
+const SUKKOT_II = 'Sukkot II';
+const SUKKOT_III_CHM = "Sukkot III (CH''M)";
+const SUKKOT_IV_CHM = "Sukkot IV (CH''M)";
+const SUKKOT_V_CHM = "Sukkot V (CH''M)";
+const SUKKOT_VI_CHM = "Sukkot VI (CH''M)";
+const SHMINI_ATZERET = 'Shmini Atzeret';
+const SIMCHAT_TORAH = 'Simchat Torah';
+const SUKKOT_II_CHM = "Sukkot II (CH''M)";
+const SUKKOT_VII_HOSHANA_RABA = 'Sukkot VII (Hoshana Raba)';
+const CHANUKAH_1_CANDLE = 'Chanukah: 1 Candle';
+const TU_BISHVAT = 'Tu BiShvat';
+const EREV_PURIM = 'Erev Purim';
+const PURIM = 'Purim';
+const SHUSHAN_PURIM = 'Shushan Purim';
+const EREV_PESACH = 'Erev Pesach';
+const PESACH_I = 'Pesach I';
+const PESACH_II = 'Pesach II';
+const PESACH_II_CHM = "Pesach II (CH''M)";
+const PESACH_III_CHM = "Pesach III (CH''M)";
+const PESACH_IV_CHM = "Pesach IV (CH''M)";
+const PESACH_V_CHM = "Pesach V (CH''M)";
+const PESACH_VI_CHM = "Pesach VI (CH''M)";
+const PESACH_VII = 'Pesach VII';
+const PESACH_VIII = 'Pesach VIII';
+const PESACH_SHENI = 'Pesach Sheni';
+const LAG_BAOMER = 'Lag BaOmer';
+const EREV_SHAVUOT = 'Erev Shavuot';
+const SHAVUOT = 'Shavuot';
+const SHAVUOT_I = 'Shavuot I';
+const SHAVUOT_II = 'Shavuot II';
+const TU_BAV = "Tu B'Av";
+const ROSH_HASHANA_LABEHEMOT = 'Rosh Hashana LaBehemot';
+const EREV_ROSH_HASHANA = 'Erev Rosh Hashana';
+const YOM_YERUSHALAYIM = 'Yom Yerushalayim';
+const BEN_GURION_DAY = 'Ben-Gurion Day';
+const FAMILY_DAY = 'Family Day';
+const YITZHAK_RABIN_MEMORIAL_DAY = 'Yitzhak Rabin Memorial Day';
+const HERZL_DAY = 'Herzl Day';
+const JABOTINSKY_DAY = 'Jabotinsky Day';
+const SIGD = 'Sigd';
+const YOM_HAALIYAH = 'Yom HaAliyah';
+const YOM_HAALIYAH_SCHOOL_OBSERVANCE = 'Yom HaAliyah School Observance';
+const HEBREW_LANGUAGE_DAY = 'Hebrew Language Day';
+/**
+ * Transliterated names of holidays, used by `Event.getDesc()`
+ * @readonly
+ * @enum {string}
+ */
+const holidayDesc = {
+    /** Asara B'Tevet */
+    ASARA_BTEVET: "Asara B'Tevet",
+    /** Birkat Hachamah */
+    BIRKAT_HACHAMAH: 'Birkat Hachamah',
+    /** Chag HaBanot */
+    CHAG_HABANOT: 'Chag HaBanot',
+    /** Chanukah: 8th Day */
+    CHANUKAH_8TH_DAY: 'Chanukah: 8th Day',
+    /** Erev Tish'a B'Av */
+    EREV_TISHA_BAV: "Erev Tish'a B'Av",
+    /** Leil Selichot */
+    LEIL_SELICHOT: 'Leil Selichot',
+    /** Purim Katan */
+    PURIM_KATAN: 'Purim Katan',
+    /** Purim Meshulash */
+    PURIM_MESHULASH: 'Purim Meshulash',
+    /** Shabbat Chazon */
+    SHABBAT_CHAZON: 'Shabbat Chazon',
+    /** Shabbat HaChodesh */
+    SHABBAT_HACHODESH: 'Shabbat HaChodesh',
+    /** Shabbat HaGadol */
+    SHABBAT_HAGADOL: 'Shabbat HaGadol',
+    /** Shabbat Nachamu */
+    SHABBAT_NACHAMU: 'Shabbat Nachamu',
+    /** Shabbat Parah */
+    SHABBAT_PARAH: 'Shabbat Parah',
+    /** Shabbat Shekalim */
+    SHABBAT_SHEKALIM: 'Shabbat Shekalim',
+    /** Shabbat Shirah */
+    SHABBAT_SHIRAH: 'Shabbat Shirah',
+    /** Shabbat Shuva */
+    SHABBAT_SHUVA: 'Shabbat Shuva',
+    /** Shabbat Zachor */
+    SHABBAT_ZACHOR: 'Shabbat Zachor',
+    /** Shushan Purim Katan */
+    SHUSHAN_PURIM_KATAN: 'Shushan Purim Katan',
+    /** Ta'anit Bechorot */
+    TAANIT_BECHOROT: "Ta'anit Bechorot",
+    /** Ta'anit Esther */
+    TAANIT_ESTHER: "Ta'anit Esther",
+    /** Tish'a B'Av */
+    TISHA_BAV: "Tish'a B'Av",
+    /** Tzom Gedaliah */
+    TZOM_GEDALIAH: 'Tzom Gedaliah',
+    /** Tzom Tammuz */
+    TZOM_TAMMUZ: 'Tzom Tammuz',
+    /** Yom HaAtzma'ut */
+    YOM_HAATZMA_UT: "Yom HaAtzma'ut",
+    /** Yom HaShoah */
+    YOM_HASHOAH: 'Yom HaShoah',
+    /** Yom HaZikaron */
+    YOM_HAZIKARON: 'Yom HaZikaron',
+    /** Chanukah: 1 Candle */
+    CHANUKAH_1_CANDLE,
+    /** Erev Purim */
+    EREV_PURIM,
+    /** Lag BaOmer */
+    LAG_BAOMER,
+    /** Pesach Sheni */
+    PESACH_SHENI,
+    /** Rosh Hashana LaBehemot */
+    ROSH_HASHANA_LABEHEMOT,
+    /** Shushan Purim */
+    SHUSHAN_PURIM,
+    /** Tu B\'Av */
+    TU_BAV,
+    /** Tu BiShvat */
+    TU_BISHVAT
+};
+const staticHolidays = [
+    {
+        mm: Tishrei,
+        dd: 2,
+        desc: ROSH_HASHANA_II,
+        flags: CHAG$1 | YOM_TOV_ENDS,
+        emoji: '🍏🍯',
+    },
+    { mm: Tishrei, dd: 9, desc: EREV_YOM_KIPPUR, flags: EREV$1 | LIGHT_CANDLES },
+    {
+        mm: Tishrei,
+        dd: 10,
+        desc: YOM_KIPPUR,
+        flags: CHAG$1 | MAJOR_FAST$1 | YOM_TOV_ENDS,
+    },
+    {
+        mm: Tishrei,
+        dd: 14,
+        desc: EREV_SUKKOT,
+        flags: CHUL_ONLY | EREV$1 | LIGHT_CANDLES,
+        emoji: emojiSukkot,
+    },
+    {
+        mm: Tishrei,
+        dd: 15,
+        desc: SUKKOT_I,
+        flags: CHUL_ONLY | CHAG$1 | LIGHT_CANDLES_TZEIS$1,
+        emoji: emojiSukkot,
+    },
+    {
+        mm: Tishrei,
+        dd: 16,
+        desc: SUKKOT_II,
+        flags: CHUL_ONLY | CHAG$1 | YOM_TOV_ENDS,
+        emoji: emojiSukkot,
+    },
+    {
+        mm: Tishrei,
+        dd: 17,
+        desc: SUKKOT_III_CHM,
+        flags: CHUL_ONLY | CHOL_HAMOED,
+        chmDay: 1,
+        emoji: emojiSukkot,
+    },
+    {
+        mm: Tishrei,
+        dd: 18,
+        desc: SUKKOT_IV_CHM,
+        flags: CHUL_ONLY | CHOL_HAMOED,
+        chmDay: 2,
+        emoji: emojiSukkot,
+    },
+    {
+        mm: Tishrei,
+        dd: 19,
+        desc: SUKKOT_V_CHM,
+        flags: CHUL_ONLY | CHOL_HAMOED,
+        chmDay: 3,
+        emoji: emojiSukkot,
+    },
+    {
+        mm: Tishrei,
+        dd: 20,
+        desc: SUKKOT_VI_CHM,
+        flags: CHUL_ONLY | CHOL_HAMOED,
+        chmDay: 4,
+        emoji: emojiSukkot,
+    },
+    {
+        mm: Tishrei,
+        dd: 22,
+        desc: SHMINI_ATZERET,
+        flags: CHUL_ONLY | CHAG$1 | LIGHT_CANDLES_TZEIS$1,
+    },
+    {
+        mm: Tishrei,
+        dd: 23,
+        desc: SIMCHAT_TORAH,
+        flags: CHUL_ONLY | CHAG$1 | YOM_TOV_ENDS,
+    },
+    {
+        mm: Tishrei,
+        dd: 14,
+        desc: EREV_SUKKOT,
+        flags: IL_ONLY$1 | EREV$1 | LIGHT_CANDLES,
+        emoji: emojiSukkot,
+    },
+    {
+        mm: Tishrei,
+        dd: 15,
+        desc: SUKKOT_I,
+        flags: IL_ONLY$1 | CHAG$1 | YOM_TOV_ENDS,
+        emoji: emojiSukkot,
+    },
+    {
+        mm: Tishrei,
+        dd: 16,
+        desc: SUKKOT_II_CHM,
+        flags: IL_ONLY$1 | CHOL_HAMOED,
+        chmDay: 1,
+        emoji: emojiSukkot,
+    },
+    {
+        mm: Tishrei,
+        dd: 17,
+        desc: SUKKOT_III_CHM,
+        flags: IL_ONLY$1 | CHOL_HAMOED,
+        chmDay: 2,
+        emoji: emojiSukkot,
+    },
+    {
+        mm: Tishrei,
+        dd: 18,
+        desc: SUKKOT_IV_CHM,
+        flags: IL_ONLY$1 | CHOL_HAMOED,
+        chmDay: 3,
+        emoji: emojiSukkot,
+    },
+    {
+        mm: Tishrei,
+        dd: 19,
+        desc: SUKKOT_V_CHM,
+        flags: IL_ONLY$1 | CHOL_HAMOED,
+        chmDay: 4,
+        emoji: emojiSukkot,
+    },
+    {
+        mm: Tishrei,
+        dd: 20,
+        desc: SUKKOT_VI_CHM,
+        flags: IL_ONLY$1 | CHOL_HAMOED,
+        chmDay: 5,
+        emoji: emojiSukkot,
+    },
+    {
+        mm: Tishrei,
+        dd: 22,
+        desc: SHMINI_ATZERET,
+        flags: IL_ONLY$1 | CHAG$1 | YOM_TOV_ENDS,
+    },
+    {
+        mm: Tishrei,
+        dd: 21,
+        desc: SUKKOT_VII_HOSHANA_RABA,
+        flags: LIGHT_CANDLES | CHOL_HAMOED,
+        chmDay: -1,
+        emoji: emojiSukkot,
+    },
+    { mm: Shvat, dd: 15, desc: TU_BISHVAT, flags: MINOR_HOLIDAY$1, emoji: '🌳' },
+    {
+        mm: Adar2,
+        dd: 13,
+        desc: EREV_PURIM,
+        flags: EREV$1 | MINOR_HOLIDAY$1,
+        emoji: '🎭️📜',
+    },
+    { mm: Adar2, dd: 14, desc: PURIM, flags: MINOR_HOLIDAY$1, emoji: '🎭️📜' },
+    {
+        mm: Adar2,
+        dd: 15,
+        desc: SHUSHAN_PURIM,
+        flags: MINOR_HOLIDAY$1,
+        emoji: '🎭️📜',
+    },
+    // Pesach Israel
+    {
+        mm: Nisan,
+        dd: 14,
+        desc: EREV_PESACH,
+        flags: IL_ONLY$1 | EREV$1 | LIGHT_CANDLES,
+        emoji: '🫓🍷',
+    },
+    {
+        mm: Nisan,
+        dd: 15,
+        desc: PESACH_I,
+        flags: IL_ONLY$1 | CHAG$1 | YOM_TOV_ENDS,
+        emoji: emojiPesach,
+    },
+    {
+        mm: Nisan,
+        dd: 16,
+        desc: PESACH_II_CHM,
+        flags: IL_ONLY$1 | CHOL_HAMOED,
+        chmDay: 1,
+        emoji: emojiPesach,
+    },
+    {
+        mm: Nisan,
+        dd: 17,
+        desc: PESACH_III_CHM,
+        flags: IL_ONLY$1 | CHOL_HAMOED,
+        chmDay: 2,
+        emoji: emojiPesach,
+    },
+    {
+        mm: Nisan,
+        dd: 18,
+        desc: PESACH_IV_CHM,
+        flags: IL_ONLY$1 | CHOL_HAMOED,
+        chmDay: 3,
+        emoji: emojiPesach,
+    },
+    {
+        mm: Nisan,
+        dd: 19,
+        desc: PESACH_V_CHM,
+        flags: IL_ONLY$1 | CHOL_HAMOED,
+        chmDay: 4,
+        emoji: emojiPesach,
+    },
+    {
+        mm: Nisan,
+        dd: 20,
+        desc: PESACH_VI_CHM,
+        flags: IL_ONLY$1 | CHOL_HAMOED | LIGHT_CANDLES,
+        chmDay: 5,
+        emoji: emojiPesach,
+    },
+    {
+        mm: Nisan,
+        dd: 21,
+        desc: PESACH_VII,
+        flags: IL_ONLY$1 | CHAG$1 | YOM_TOV_ENDS,
+        emoji: emojiPesach,
+    },
+    // Pesach chutz l'aretz
+    {
+        mm: Nisan,
+        dd: 14,
+        desc: EREV_PESACH,
+        flags: CHUL_ONLY | EREV$1 | LIGHT_CANDLES,
+        emoji: '🫓🍷',
+    },
+    {
+        mm: Nisan,
+        dd: 15,
+        desc: PESACH_I,
+        flags: CHUL_ONLY | CHAG$1 | LIGHT_CANDLES_TZEIS$1,
+        emoji: '🫓🍷',
+    },
+    {
+        mm: Nisan,
+        dd: 16,
+        desc: PESACH_II,
+        flags: CHUL_ONLY | CHAG$1 | YOM_TOV_ENDS,
+        emoji: emojiPesach,
+    },
+    {
+        mm: Nisan,
+        dd: 17,
+        desc: PESACH_III_CHM,
+        flags: CHUL_ONLY | CHOL_HAMOED,
+        chmDay: 1,
+        emoji: emojiPesach,
+    },
+    {
+        mm: Nisan,
+        dd: 18,
+        desc: PESACH_IV_CHM,
+        flags: CHUL_ONLY | CHOL_HAMOED,
+        chmDay: 2,
+        emoji: emojiPesach,
+    },
+    {
+        mm: Nisan,
+        dd: 19,
+        desc: PESACH_V_CHM,
+        flags: CHUL_ONLY | CHOL_HAMOED,
+        chmDay: 3,
+        emoji: emojiPesach,
+    },
+    {
+        mm: Nisan,
+        dd: 20,
+        desc: PESACH_VI_CHM,
+        flags: CHUL_ONLY | CHOL_HAMOED | LIGHT_CANDLES,
+        chmDay: 4,
+        emoji: emojiPesach,
+    },
+    {
+        mm: Nisan,
+        dd: 21,
+        desc: PESACH_VII,
+        flags: CHUL_ONLY | CHAG$1 | LIGHT_CANDLES_TZEIS$1,
+        emoji: emojiPesach,
+    },
+    {
+        mm: Nisan,
+        dd: 22,
+        desc: PESACH_VIII,
+        flags: CHUL_ONLY | CHAG$1 | YOM_TOV_ENDS,
+        emoji: emojiPesach,
+    },
+    { mm: Iyyar, dd: 14, desc: PESACH_SHENI, flags: MINOR_HOLIDAY$1 },
+    { mm: Iyyar, dd: 18, desc: LAG_BAOMER, flags: MINOR_HOLIDAY$1, emoji: '🔥' },
+    {
+        mm: Sivan,
+        dd: 5,
+        desc: EREV_SHAVUOT,
+        flags: EREV$1 | LIGHT_CANDLES,
+        emoji: '⛰️🌸',
+    },
+    {
+        mm: Sivan,
+        dd: 6,
+        desc: SHAVUOT,
+        flags: IL_ONLY$1 | CHAG$1 | YOM_TOV_ENDS,
+        emoji: '⛰️🌸',
+    },
+    {
+        mm: Sivan,
+        dd: 6,
+        desc: SHAVUOT_I,
+        flags: CHUL_ONLY | CHAG$1 | LIGHT_CANDLES_TZEIS$1,
+        emoji: '⛰️🌸',
+    },
+    {
+        mm: Sivan,
+        dd: 7,
+        desc: SHAVUOT_II,
+        flags: CHUL_ONLY | CHAG$1 | YOM_TOV_ENDS,
+        emoji: '⛰️🌸',
+    },
+    { mm: Av, dd: 15, desc: TU_BAV, flags: MINOR_HOLIDAY$1, emoji: '❤️' },
+    {
+        mm: Elul,
+        dd: 1,
+        desc: ROSH_HASHANA_LABEHEMOT,
+        flags: MINOR_HOLIDAY$1,
+        emoji: '🐑',
+    },
+    {
+        mm: Elul,
+        dd: 29,
+        desc: EREV_ROSH_HASHANA,
+        flags: EREV$1 | LIGHT_CANDLES,
+        emoji: '🍏🍯',
+    },
+];
+const staticModernHolidays = [
+    { firstYear: 5727, mm: Iyyar, dd: 28, desc: YOM_YERUSHALAYIM, chul: true },
+    {
+        firstYear: 5737,
+        mm: Kislev,
+        dd: 6,
+        desc: BEN_GURION_DAY,
+        satPostponeToSun: true,
+        friPostponeToSun: true,
+    },
+    { firstYear: 5750, mm: Shvat, dd: 30, desc: FAMILY_DAY },
+    {
+        firstYear: 5758,
+        mm: Cheshvan,
+        dd: 12,
+        desc: YITZHAK_RABIN_MEMORIAL_DAY,
+        friSatMovetoThu: true,
+    },
+    { firstYear: 5764, mm: Iyyar, dd: 10, desc: HERZL_DAY, satPostponeToSun: true },
+    {
+        firstYear: 5765,
+        mm: Tamuz,
+        dd: 29,
+        desc: JABOTINSKY_DAY,
+        satPostponeToSun: true,
+    },
+    {
+        firstYear: 5769,
+        mm: Cheshvan,
+        dd: 29,
+        desc: SIGD,
+        chul: true,
+        suppressEmoji: true,
+        friSatMovetoThu: true,
+    },
+    { firstYear: 5777, mm: Nisan, dd: 10, desc: YOM_HAALIYAH, chul: true },
+    { firstYear: 5777, mm: Cheshvan, dd: 7, desc: YOM_HAALIYAH_SCHOOL_OBSERVANCE },
+    // https://www.gov.il/he/departments/policies/2012_des5234
+    {
+        firstYear: 5773,
+        mm: months.TEVET,
+        dd: 21,
+        desc: HEBREW_LANGUAGE_DAY,
+        friSatMovetoThu: true,
+    },
+];
+/*! @hebcal/core v6.0.7, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+/** Represents a built-in holiday like Pesach, Purim or Tu BiShvat */
+class HolidayEvent extends Event {
+    basename() {
+        return this.getDesc()
+            .replace(/ \d{4}$/, '')
+            .replace(/ \(CH''M\)$/, '')
+            .replace(/ \(observed\)$/, '')
+            .replace(/ \(Hoshana Raba\)$/, '')
+            .replace(/ [IV]+$/, '')
+            .replace(/: \d Candles?$/, '')
+            .replace(/: 8th Day$/, '')
+            .replace(/^Erev /, '');
+    }
+    url() {
+        const year = this.greg().getFullYear();
+        if (year < 100 || year > 2999) {
+            return undefined;
+        }
+        const url = 'https://www.hebcal.com/holidays/' +
+            this.basename().toLowerCase().replace(/'/g, '').replace(/ /g, '-') +
+            '-' +
+            this.urlDateSuffix();
+        return this.getFlags() & flags.IL_ONLY ? url + '?i=on' : url;
+    }
+    urlDateSuffix() {
+        const year = this.greg().getFullYear();
+        return String(year);
+    }
+    getEmoji() {
+        if (this.emoji) {
+            return this.emoji;
+        }
+        else if (this.getFlags() & flags.SPECIAL_SHABBAT) {
+            return '🕍';
+        }
+        else {
+            return '✡️';
+        }
+    }
+    getCategories() {
+        if (this.cholHaMoedDay) {
+            return ['holiday', 'major', 'cholhamoed'];
+        }
+        const cats = super.getCategories();
+        if (cats[0] !== 'unknown') {
+            return cats;
+        }
+        // Don't depend on flags.MINOR_HOLIDAY always being set. Look for minor holidays.
+        const desc = this.getDesc();
+        switch (desc) {
+            case holidayDesc.LAG_BAOMER:
+            case holidayDesc.LEIL_SELICHOT:
+            case holidayDesc.PESACH_SHENI:
+            case holidayDesc.EREV_PURIM:
+            case holidayDesc.PURIM_KATAN:
+            case holidayDesc.SHUSHAN_PURIM:
+            case holidayDesc.TU_BAV:
+            case holidayDesc.TU_BISHVAT:
+            case holidayDesc.ROSH_HASHANA_LABEHEMOT:
+                return ['holiday', 'minor'];
+        }
+        return ['holiday', 'major'];
+    }
+    /**
+     * Returns (translated) description of this event
+     * @param [locale] Optional locale name (defaults to empty locale)
+     */
+    render(locale) {
+        const str = super.render(locale);
+        return str.replace(/'/g, '’');
+    }
+    /**
+     * Returns a brief (translated) description of this event.
+     * For most events, this is the same as render(). For some events, it procudes
+     * a shorter text (e.g. without a time or added description).
+     * @param [locale] Optional locale name (defaults to empty locale)
+     */
+    renderBrief(locale) {
+        const str = super.renderBrief(locale);
+        return str.replace(/'/g, '’');
+    }
+}
+/**
+ * Because Asara B'Tevet often occurs twice in the same Gregorian year,
+ * we subclass HolidayEvent to generate the correct URL.
+ */
+class AsaraBTevetEvent extends HolidayEvent {
+    urlDateSuffix() {
+        const isoDate = isoDateString(this.greg());
+        return isoDate.replace(/-/g, '');
+    }
+}
+const chanukahEmoji = '🕎';
+const KEYCAP_DIGITS = [
+    '0️⃣',
+    '1️⃣',
+    '2️⃣',
+    '3️⃣',
+    '4️⃣',
+    '5️⃣',
+    '6️⃣',
+    '7️⃣',
+    '8️⃣',
+    '9️⃣',
+];
+/**
+ * Because Chanukah sometimes starts in December and ends in January,
+ * we subclass HolidayEvent to generate the correct URL.
+ */
+class ChanukahEvent extends HolidayEvent {
+    /**
+     * @param chanukahDay should be undefined for 1st night of Chanukah
+     */
+    constructor(date, desc, mask, chanukahDay) {
+        super(date, desc, mask);
+        this.chanukahDay = chanukahDay;
+        this.emoji = chanukahEmoji;
+        if (chanukahDay !== 8) {
+            const candles = chanukahDay ? chanukahDay + 1 : 1;
+            this.emoji += KEYCAP_DIGITS[candles];
+        }
+    }
+    urlDateSuffix() {
+        const dt = this.greg();
+        let year = dt.getFullYear();
+        if (dt.getMonth() === 0) {
+            year--;
+        }
+        return String(year);
+    }
+}
+/** Represents Rosh Hashana, the Jewish New Year */
+class RoshHashanaEvent extends HolidayEvent {
+    /**
+     * @private
+     * @param date Hebrew date event occurs
+     * @param hyear Hebrew year
+     * @param mask optional holiday flags
+     */
+    constructor(date, hyear, mask) {
+        super(date, `Rosh Hashana ${hyear}`, mask);
+        this.hyear = hyear;
+    }
+    /**
+     * Returns (translated) description of this event
+     * @param [locale] Optional locale name (defaults to empty locale)
+     */
+    render(locale) {
+        return Locale.gettext('Rosh Hashana', locale) + ' ' + this.hyear;
+    }
+    getEmoji() {
+        return '🍏🍯';
+    }
+}
+const roshChodeshStr = 'Rosh Chodesh';
+/** Represents Rosh Chodesh, the beginning of a new month */
+class RoshChodeshEvent extends HolidayEvent {
+    /**
+     * Constructs Rosh Chodesh event
+     * @param date Hebrew date event occurs
+     * @param monthName Hebrew month name (not translated)
+     */
+    constructor(date, monthName) {
+        super(date, `${roshChodeshStr} ${monthName}`, flags.ROSH_CHODESH);
+    }
+    /**
+     * Returns (translated) description of this event
+     * @param [locale] Optional locale name (defaults to empty locale)
+     */
+    render(locale) {
+        const monthName = this.getDesc().substring(roshChodeshStr.length + 1);
+        const monthName0 = Locale.gettext(monthName, locale);
+        const monthName1 = monthName0.replace(/'/g, '’');
+        return Locale.gettext(roshChodeshStr, locale) + ' ' + monthName1;
+    }
+    basename() {
+        return this.getDesc();
+    }
+    getEmoji() {
+        return this.emoji || '🌒';
+    }
+}
+/*! @hebcal/core v6.0.7, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+const ykk = 'Yom Kippur Katan';
+/** YKK is minor day of atonement on the day preceeding each Rosh Chodesh */
+class YomKippurKatanEvent extends HolidayEvent {
+    /**
+     * @private
+     * @param date Hebrew date event occurs
+     * @param nextMonthName name of the upcoming month
+     */
+    constructor(date, nextMonthName) {
+        super(date, `${ykk} ${nextMonthName}`, flags.MINOR_FAST | flags.YOM_KIPPUR_KATAN);
+        this.nextMonthName = nextMonthName;
+        this.memo = `Minor Day of Atonement on the day preceeding Rosh Chodesh ${nextMonthName}`;
+    }
+    basename() {
+        return this.getDesc();
+    }
+    /**
+     * @param [locale] Optional locale name (defaults to empty locale)
+     */
+    render(locale) {
+        const monthName0 = Locale.gettext(this.nextMonthName, locale);
+        const monthName = monthName0.replace(/'/g, '’');
+        return Locale.gettext(ykk, locale) + ' ' + monthName;
+    }
+    /**
+     * @param [locale] Optional locale name (defaults to empty locale)
+     */
+    renderBrief(locale) {
+        return Locale.gettext(ykk, locale);
+    }
+    url() {
+        return undefined;
+    }
+}
+/*! @hebcal/core v6.0.7, distributed under GPLv2 https://www.gnu.org/licenses/gpl-2.0.txt */
+/*
+    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/>.
+ */
+/**
+ * Returns an array of Events on this date (or `undefined` if no events)
+ * @param date Hebrew Date, Gregorian date, or absolute R.D. day number
+ * @param [il] use the Israeli schedule for holidays
+ */
+function getHolidaysOnDate(date, il) {
+    const hd = HDate.isHDate(date) ? date : new HDate(date);
+    const hdStr = hd.toString();
+    const yearMap = getHolidaysForYear_(hd.getFullYear());
+    const events = yearMap.get(hdStr);
+    // if il isn't a boolean return both diaspora + IL for day
+    {
+        return events;
+    }
+}
+const CHAG = flags.CHAG;
+const IL_ONLY = flags.IL_ONLY;
+const LIGHT_CANDLES_TZEIS = flags.LIGHT_CANDLES_TZEIS;
+const CHANUKAH_CANDLES = flags.CHANUKAH_CANDLES;
+const MINOR_FAST = flags.MINOR_FAST;
+const SPECIAL_SHABBAT = flags.SPECIAL_SHABBAT;
+const MODERN_HOLIDAY = flags.MODERN_HOLIDAY;
+const MAJOR_FAST = flags.MAJOR_FAST;
+const MINOR_HOLIDAY = flags.MINOR_HOLIDAY;
+const EREV = flags.EREV;
+const SUN = 0;
+const TUE = 2;
+const THU = 4;
+const FRI = 5;
+const SAT = 6;
+const NISAN = months.NISAN;
+const TAMUZ = months.TAMUZ;
+const AV = months.AV;
+const TISHREI = months.TISHREI;
+const KISLEV = months.KISLEV;
+const TEVET = months.TEVET;
+const ADAR_I = months.ADAR_I;
+const ADAR_II = months.ADAR_II;
+const emojiIsraelFlag = { emoji: '🇮🇱' };
+const yearCache = new QuickLRU({ maxSize: 400 });
+/**
+ * Lower-level holidays interface, which returns a `Map` of `Event`s indexed by
+ * `HDate.toString()`. These events must filtered especially for `flags.IL_ONLY`
+ * or `flags.CHUL_ONLY` depending on Israel vs. Diaspora holiday scheme.
+ * @private
+ */
+function getHolidaysForYear_(year) {
+    if (typeof year !== 'number') {
+        throw new TypeError(`bad Hebrew year: ${year}`);
+    }
+    else if (year < 1 || year > 32658) {
+        throw new RangeError(`Hebrew year ${year} out of range 1-32658`);
+    }
+    const cached = yearCache.get(year);
+    if (cached) {
+        return cached;
+    }
+    const RH = new HDate(1, TISHREI, year);
+    const pesach = new HDate(15, NISAN, year);
+    const map = new Map();
+    function add(...events) {
+        for (const ev of events) {
+            const key = ev.date.toString();
+            const arr = map.get(key);
+            if (typeof arr === 'object') {
+                if (arr[0].getFlags() & EREV) {
+                    arr.unshift(ev);
+                }
+                else {
+                    arr.push(ev);
+                }
+            }
+            else {
+                map.set(key, [ev]);
+            }
+        }
+    }
+    for (const h of staticHolidays) {
+        const hd = new HDate(h.dd, h.mm, year);
+        const ev = new HolidayEvent(hd, h.desc, h.flags);
+        if (h.emoji)
+            ev.emoji = h.emoji;
+        if (h.chmDay)
+            ev.cholHaMoedDay = h.chmDay;
+        add(ev);
+    }
+    // standard holidays that don't shift based on year
+    add(new RoshHashanaEvent(RH, year, CHAG | LIGHT_CANDLES_TZEIS));
+    // Variable date holidays
+    const tzomGedaliahDay = RH.getDay() === THU ? 4 : 3;
+    add(new HolidayEvent(new HDate(tzomGedaliahDay, TISHREI, year), holidayDesc.TZOM_GEDALIAH, MINOR_FAST));
+    // first SAT after RH
+    add(new HolidayEvent(new HDate(HDate.dayOnOrBefore(SAT, 7 + RH.abs())), holidayDesc.SHABBAT_SHUVA, SPECIAL_SHABBAT));
+    const rchTevet = HDate.shortKislev(year)
+        ? new HDate(1, TEVET, year)
+        : new HDate(30, KISLEV, year);
+    add(new HolidayEvent(rchTevet, holidayDesc.CHAG_HABANOT, MINOR_HOLIDAY));
+    add(new ChanukahEvent(new HDate(24, KISLEV, year), holidayDesc.CHANUKAH_1_CANDLE, EREV | MINOR_HOLIDAY | CHANUKAH_CANDLES, undefined));
+    // yes, we know Kislev 30-32 are wrong
+    // HDate() corrects the month automatically
+    for (let candles = 2; candles <= 8; candles++) {
+        const hd = new HDate(23 + candles, KISLEV, year);
+        add(new ChanukahEvent(hd, `Chanukah: ${candles} Candles`, MINOR_HOLIDAY | CHANUKAH_CANDLES, candles - 1));
+    }
+    add(new ChanukahEvent(new HDate(32, KISLEV, year), holidayDesc.CHANUKAH_8TH_DAY, MINOR_HOLIDAY, 8));
+    add(new AsaraBTevetEvent(new HDate(10, TEVET, year), holidayDesc.ASARA_BTEVET, MINOR_FAST));
+    const pesachAbs = pesach.abs();
+    add(new HolidayEvent(new HDate(HDate.dayOnOrBefore(SAT, pesachAbs - 43)), holidayDesc.SHABBAT_SHEKALIM, SPECIAL_SHABBAT), new HolidayEvent(new HDate(HDate.dayOnOrBefore(SAT, pesachAbs - 30)), holidayDesc.SHABBAT_ZACHOR, SPECIAL_SHABBAT), new HolidayEvent(new HDate(pesachAbs - (pesach.getDay() === TUE ? 33 : 31)), holidayDesc.TAANIT_ESTHER, MINOR_FAST));
+    const haChodeshAbs = HDate.dayOnOrBefore(SAT, pesachAbs - 14);
+    add(new HolidayEvent(new HDate(haChodeshAbs - 7), holidayDesc.SHABBAT_PARAH, SPECIAL_SHABBAT), new HolidayEvent(new HDate(haChodeshAbs), holidayDesc.SHABBAT_HACHODESH, SPECIAL_SHABBAT), new HolidayEvent(new HDate(HDate.dayOnOrBefore(SAT, pesachAbs - 1)), holidayDesc.SHABBAT_HAGADOL, SPECIAL_SHABBAT), new HolidayEvent(
+    // if the fast falls on Shabbat, move to Thursday
+    pesach.prev().getDay() === SAT
+        ? pesach.onOrBefore(THU)
+        : new HDate(14, NISAN, year), holidayDesc.TAANIT_BECHOROT, MINOR_FAST));
+    add(new HolidayEvent(new HDate(HDate.dayOnOrBefore(SAT, new HDate(1, TISHREI, year + 1).abs() - 4)), holidayDesc.LEIL_SELICHOT, MINOR_HOLIDAY, { emoji: '🕍' }));
+    if (pesach.getDay() === SUN) {
+        add(new HolidayEvent(new HDate(16, ADAR_II, year), holidayDesc.PURIM_MESHULASH, MINOR_HOLIDAY));
+    }
+    if (HDate.isLeapYear(year)) {
+        add(new HolidayEvent(new HDate(14, ADAR_I, year), holidayDesc.PURIM_KATAN, MINOR_HOLIDAY, { emoji: '🎭️' }));
+        add(new HolidayEvent(new HDate(15, ADAR_I, year), holidayDesc.SHUSHAN_PURIM_KATAN, MINOR_HOLIDAY, { emoji: '🎭️' }));
+    }
+    const nisan27dt = dateYomHaShoah(year);
+    if (nisan27dt) {
+        add(new HolidayEvent(nisan27dt, holidayDesc.YOM_HASHOAH, MODERN_HOLIDAY));
+    }
+    const yomHaZikaronDt = dateYomHaZikaron(year);
+    if (yomHaZikaronDt) {
+        add(new HolidayEvent(yomHaZikaronDt, holidayDesc.YOM_HAZIKARON, MODERN_HOLIDAY, emojiIsraelFlag), new HolidayEvent(yomHaZikaronDt.next(), holidayDesc.YOM_HAATZMA_UT, MODERN_HOLIDAY, emojiIsraelFlag));
+    }
+    for (const h of staticModernHolidays) {
+        if (year >= h.firstYear) {
+            let hd = new HDate(h.dd, h.mm, year);
+            const dow = hd.getDay();
+            if (h.friSatMovetoThu && (dow === FRI || dow === SAT)) {
+                hd = hd.onOrBefore(THU);
+            }
+            else if (h.friPostponeToSun && dow === FRI) {
+                hd = new HDate(hd.abs() + 2);
+            }
+            else if (h.satPostponeToSun && dow === SAT) {
+                hd = hd.next();
+            }
+            const mask = h.chul ? MODERN_HOLIDAY : MODERN_HOLIDAY | IL_ONLY;
+            const ev = new HolidayEvent(hd, h.desc, mask);
+            if (!h.suppressEmoji) {
+                ev.emoji = '🇮🇱';
+            }
+            add(ev);
+        }
+    }
+    let tamuz17 = new HDate(17, TAMUZ, year);
+    let tamuz17attrs;
+    if (tamuz17.getDay() === SAT) {
+        tamuz17 = new HDate(18, TAMUZ, year);
+        tamuz17attrs = { observed: true };
+    }
+    add(new HolidayEvent(tamuz17, holidayDesc.TZOM_TAMMUZ, MINOR_FAST, tamuz17attrs));
+    let av9dt = new HDate(9, AV, year);
+    let av9title = holidayDesc.TISHA_BAV;
+    let av9attrs;
+    if (av9dt.getDay() === SAT) {
+        av9dt = av9dt.next();
+        av9attrs = { observed: true };
+        av9title += ' (observed)';
+    }
+    const av9abs = av9dt.abs();
+    add(new HolidayEvent(new HDate(HDate.dayOnOrBefore(SAT, av9abs)), holidayDesc.SHABBAT_CHAZON, SPECIAL_SHABBAT), new HolidayEvent(av9dt.prev(), holidayDesc.EREV_TISHA_BAV, EREV | MAJOR_FAST, av9attrs), new HolidayEvent(av9dt, av9title, MAJOR_FAST, av9attrs), new HolidayEvent(new HDate(HDate.dayOnOrBefore(SAT, av9abs + 7)), holidayDesc.SHABBAT_NACHAMU, SPECIAL_SHABBAT));
+    const monthsInYear = HDate.monthsInYear(year);
+    for (let month = 1; month <= monthsInYear; month++) {
+        const monthName = HDate.getMonthName(month, year);
+        if ((month === NISAN
+            ? HDate.daysInMonth(HDate.monthsInYear(year - 1), year - 1)
+            : HDate.daysInMonth(month - 1, year)) === 30) {
+            add(new RoshChodeshEvent(new HDate(1, month, year), monthName));
+            add(new RoshChodeshEvent(new HDate(30, month - 1, year), monthName));
+        }
+        else if (month !== TISHREI) {
+            add(new RoshChodeshEvent(new HDate(1, month, year), monthName));
+        }
+    }
+    // Begin: Yom Kippur Katan
+    // start at Iyyar because one may not fast during Nisan
+    for (let month = months.IYYAR; month <= monthsInYear; month++) {
+        const nextMonth = month + 1;
+        // Yom Kippur Katan is not observed on the day before Rosh Hashanah.
+        // Not observed prior to Rosh Chodesh Cheshvan because Yom Kippur has just passed.
+        // Not observed before Rosh Chodesh Tevet, because that day is Hanukkah.
+        if (nextMonth === TISHREI ||
+            nextMonth === months.CHESHVAN ||
+            nextMonth === TEVET) {
+            continue;
+        }
+        let ykk = new HDate(29, month, year);
+        const dow = ykk.getDay();
+        if (dow === FRI || dow === SAT) {
+            ykk = ykk.onOrBefore(THU);
+        }
+        const nextMonthName = HDate.getMonthName(nextMonth, year);
+        const ev = new YomKippurKatanEvent(ykk, nextMonthName);
+        add(ev);
+    }
+    const sedra = getSedra(year, false);
+    const beshalachHd = sedra.find(15);
+    add(new HolidayEvent(beshalachHd, holidayDesc.SHABBAT_SHIRAH, SPECIAL_SHABBAT));
+    // Birkat Hachamah appears only once every 28 years
+    const birkatHaChama = getBirkatHaChama(year);
+    if (birkatHaChama) {
+        const hd = new HDate(birkatHaChama);
+        add(new HolidayEvent(hd, holidayDesc.BIRKAT_HACHAMAH, MINOR_HOLIDAY, { emoji: '☀️' }));
+    }
+    yearCache.set(year, map);
+    return map;
+}
+/**
+ * Birkat Hachamah appears only once every 28 years.
+ * Although almost always in Nisan, it can occur in Adar II.
+ *   - 27 Adar II 5461 (Gregorian year 1701)
+ *   - 29 Adar II 5993 (Gregorian year 2233)
+ *
+ * Due to drift, this will eventually slip into Iyyar
+ *   - 2 Iyyar 7141 (Gregorian year 3381)
+ * @private
+ */
+function getBirkatHaChama(year) {
+    const leap = HDate.isLeapYear(year);
+    const startMonth = leap ? ADAR_II : NISAN;
+    const startDay = leap ? 20 : 1;
+    const baseRd = HDate.hebrew2abs(year, startMonth, startDay);
+    for (let day = 0; day <= 40; day++) {
+        const abs = baseRd + day;
+        const elapsed = abs + 1373429;
+        if (elapsed % 10227 === 172) {
+            return abs;
+        }
+    }
+    return 0;
+}
+console.log(getHolidaysOnDate(new HDate(1, 1, 5757)));