@hebcal/core 6.0.5 → 6.0.7

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

@@ -0,0 +1,2359 @@
+"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 = 1;
+const IYYAR = 2;
+const SIVAN = 3;
+const TAMUZ = 4;
+const AV = 5;
+const ELUL = 6;
+const TISHREI = 7;
+const CHESHVAN = 8;
+const KISLEV = 9;
+const TEVET = 10;
+const SHVAT = 11;
+const ADAR_I = 12;
+const ADAR_II = 13;
+/**
+ * Hebrew months of the year (NISAN=1, TISHREI=7)
+ * @readonly
+ * @enum {number}
+ */
+const months = {
+    /** Elul / אלול */
+    ELUL,
+    /** Tishrei / תִּשְׁרֵי */
+    TISHREI,
+    /** Adar Sheini (only on leap years) / אדר ב׳ */
+    ADAR_II,
+};
+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) {
+        for (let m = TISHREI; m <= monthsInYear(year); m++) {
+            tempabs += daysInMonth(m, year);
+        }
+        for (let m = NISAN; m < month; m++) {
+            tempabs += daysInMonth(m, year);
+        }
+    }
+    else {
+        for (let m = TISHREI; m < month; m++) {
+            tempabs += daysInMonth(m, year);
+        }
+    }
+    return EPOCH + elapsedDays(year) + tempabs - 1;
+}
+/**
+ * @private
+ */
+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:
+        case TAMUZ:
+        case ELUL:
+        case TEVET:
+        case ADAR_II:
+            return 29;
+    }
+    if ((month === ADAR_I && !isLeapYear(year)) ||
+        (month === CHESHVAN && !longCheshvan(year)) ||
+        (month === KISLEV && 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;
+        case 'i':
+            return IYYAR;
+        case 'e':
+            return ELUL;
+        case 'c':
+        case 'ח':
+            return CHESHVAN;
+        case 'k':
+        case 'כ':
+            return KISLEV;
+        case 's':
+            switch (c[1]) {
+                case 'i':
+                    return SIVAN;
+                case 'h':
+                    return SHVAT;
+            }
+            break;
+        case 't':
+            switch (c[1]) {
+                case 'a':
+                    return TAMUZ;
+                case 'i':
+                    return TISHREI;
+                case 'e':
+                    return TEVET;
+            }
+            break;
+        case 'a':
+            switch (c[1]) {
+                case 'v':
+                    return AV;
+                case 'd':
+                    if (/(1|[^i]i|a|א)$/i.test(c)) {
+                        return ADAR_I;
+                    }
+                    return ADAR_II; // else assume sheini
+            }
+            break;
+        case 'ס':
+            return SIVAN;
+        case 'ט':
+            return TEVET;
+        case 'ש':
+            return SHVAT;
+        case 'א':
+            switch (c[1]) {
+                case 'ב':
+                    return AV;
+                case 'ד':
+                    if (/(1|[^i]i|a|א)$/i.test(c)) {
+                        return ADAR_I;
+                    }
+                    return ADAR_II; // else assume sheini
+                case 'י':
+                    return IYYAR;
+                case 'ל':
+                    return ELUL;
+            }
+            break;
+        case 'ת':
+            switch (c[1]) {
+                case 'מ':
+                    return TAMUZ;
+                case 'ש':
+                    return TISHREI;
+            }
+            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 */
+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 */
+/*
+    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 = '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, 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, 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, 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;
+}
+const sedra = getSedra(5757, false);
+console.log(sedra.lookup(729122).parsha);