@hebcal/core 6.0.6 → 6.0.7

package/dist/src/hebcal.js

@@ -0,0 +1,332 @@
+/*
+    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/>.
+ */
+import { getBirthdayHD, getYahrzeitHD, HDate } from '@hebcal/hdate';
+import './locale'; // Adds Hebrew and Ashkenazic translations
+import { version as pkgVersion } from './pkgVersion';
+import { flags } from './event';
+import { getSedra } from './sedra';
+import { hallel_ } from './hallel';
+import { getHolidaysForYear_, getHolidaysForYearArray, getHolidaysOnDate, } from './holidays';
+import { reformatTimeStr } from './reformatTimeStr';
+import { tachanun } from './tachanun';
+import { calendar } from './calendar';
+/**
+ * HebrewCalendar is the main interface to the `@hebcal/core` library.
+ * This namespace is used to calculate holidays, rosh chodesh, candle lighting & havdalah times,
+ * Parashat HaShavua, Daf Yomi, days of the omer, and the molad.
+ * Event names can be rendered in several languges using the `locale` option.
+ */
+export class HebrewCalendar {
+    constructor() { }
+    /**
+     * Calculates holidays and other Hebrew calendar events based on {@link CalOptions}.
+     *
+     * Each holiday is represented by an {@link Event} object which includes a date,
+     * a description, flags and optional attributes.
+     * If given no options, returns holidays for the Diaspora for the current Gregorian year.
+     *
+     * The date range returned by this function can be controlled by:
+     * * `options.year` - Gregorian (e.g. 1993) or Hebrew year (e.g. 5749)
+     * * `options.isHebrewYear` - to interpret `year` as Hebrew year
+     * * `options.numYears` - generate calendar for multiple years (default 1)
+     * * `options.month` - Gregorian or Hebrew month (to filter results to a single month)
+     *
+     * Alternatively, specify start and end days with `Date` or {@link HDate} instances:
+     * * `options.start` - use specific start date (requires `end` date)
+     * * `options.end` - use specific end date (requires `start` date)
+     *
+     * Unless `options.noHolidays == true`, default holidays include:
+     * * Major holidays - Rosh Hashana, Yom Kippur, Pesach, Sukkot, etc.
+     * * Minor holidays - Purim, Chanukah, Tu BiShvat, Lag BaOmer, etc.
+     * * Minor fasts - Ta'anit Esther, Tzom Gedaliah, etc. (unless `options.noMinorFast`)
+     * * Special Shabbatot - Shabbat Shekalim, Zachor, etc. (unless `options.noSpecialShabbat`)
+     * * Modern Holidays - Yom HaShoah, Yom HaAtzma'ut, etc. (unless `options.noModern`)
+     * * Rosh Chodesh (unless `options.noRoshChodesh`)
+     *
+     * Holiday and Torah reading schedules differ between Israel and the Disapora.
+     * Set `options.il=true` to use the Israeli schedule.
+     *
+     * Additional non-default event types can be specified:
+     * * Parashat HaShavua - weekly Torah Reading on Saturdays (`options.sedrot`)
+     * * Counting of the Omer (`options.omer`)
+     * * Shabbat Mevarchim HaChodesh on Saturday before Rosh Chodesh (`options.shabbatMevarchim`)
+     * * Molad announcement on Saturday before Rosh Chodesh (`options.molad`)
+     * * Yom Kippur Katan (`options.yomKippurKatan`)
+     * * Yizkor (`options.yizkor`)
+     *
+     * Daily Study of texts are supported by the
+     * {@link https://github.com/hebcal/hebcal-learning @hebcal/learning} package,
+     * for example:
+     * * Babylonian Talmud Daf Yomi (`options.dailyLearning.dafYomi`)
+     * * Jerusalem Talmud (Yerushalmi) Yomi (`options.dailyLearning.yerushalmi`)
+     * * Mishna Yomi (`options.dailyLearning.mishnaYomi`)
+     * * Nach Yomi (`options.dailyLearning.nachYomi`)
+     *
+     * Candle-lighting and Havdalah times are approximated using latitude and longitude
+     * specified by the {@link Location} class. The `Location` class contains a small
+     * database of cities with their associated geographic information and time-zone information.
+     * If you ever have any doubts about Hebcal's times, consult your local halachic authority.
+     * If you enter geographic coordinates above the arctic circle or antarctic circle,
+     * the times are guaranteed to be wrong.
+     *
+     * To add candle-lighting options, set `options.candlelighting=true` and set
+     * `options.location` to an instance of `Location`. By default, candle lighting
+     * time is 18 minutes before sundown (40 minutes for Jerusalem,
+     * 30 minutes for Haifa and Zikhron Ya'akov) and Havdalah is
+     * calculated according to Tzeit Hakochavim - Nightfall (the point when 3 small stars
+     * are observable in the night time sky with the naked eye). The default Havdalah
+     * option (Tzeit Hakochavim) is calculated when the sun is 8.5° below the horizon.
+     * These defaults can be changed using these options:
+     * * `options.candleLightingMins` - minutes before sundown to light candles
+     * * `options.havdalahMins` - minutes after sundown for Havdalah (typical values are 42, 50, or 72).
+     *    Havdalah times are suppressed when `options.havdalahMins=0`.
+     * * `options.havdalahDeg` - degrees for solar depression for Havdalah.
+     *    Default is 8.5 degrees for 3 small stars. Use 7.083 degrees for 3 medium-sized stars.
+     *    Havdalah times are suppressed when `options.havdalahDeg=0`.
+     *
+     * If both `options.candlelighting=true` and `options.location` is specified,
+     * Chanukah candle-lighting times and minor fast start/end times will also be generated.
+     * Chanukah candle-lighting is at Bein HaShmashos (13.5 minutes before
+     * the sun is 7.083° below the horizon in the evening)
+     * on weekdays, at regular candle-lighting time on Fridays, and at regular Havdalah time on
+     * Saturday night (see above).
+     *
+     * Minor fasts begin at Alot HaShachar (sun is 16.1° below the horizon in the morning) and
+     * end when 3 medium-sized stars are observable in the night sky (sun is 7.083° below the horizon
+     * in the evening).
+     *
+     * Two options also exist for generating an Event with the Hebrew date:
+     * * `options.addHebrewDates` - print the Hebrew date for the entire date range
+     * * `options.addHebrewDatesForEvents` - print the Hebrew date for dates with some events
+     *
+     * Lastly, translation and transliteration of event titles is controlled by
+     * `options.locale` and the {@link Locale} API.
+     * `@hebcal/core` supports three locales by default:
+     * * `en` - default, Sephardic transliterations (e.g. "Shabbat")
+     * * `ashkenazi` - Ashkenazi transliterations (e.g. "Shabbos")
+     * * `he` - Hebrew (e.g. "שַׁבָּת")
+     *
+     * Additional locales (such as `ru` or `fr`) are supported by the
+     * {@link https://github.com/hebcal/hebcal-locales @hebcal/locales} package
+     *
+     * @example
+     * import {HebrewCalendar, HDate, Location, Event} from '@hebcal/core';
+     * const options: CalOptions = {
+     *   year: 1981,
+     *   isHebrewYear: false,
+     *   candlelighting: true,
+     *   location: Location.lookup('San Francisco'),
+     *   sedrot: true,
+     *   omer: true,
+     * };
+     * const events = HebrewCalendar.calendar(options);
+     * for (const ev of events) {
+     *   const hd = ev.getDate();
+     *   const date = hd.greg();
+     *   console.log(date.toLocaleDateString(), ev.render('en'), hd.toString());
+     * }
+     */
+    static calendar(options = {}) {
+        return calendar(options);
+    }
+    /**
+     * Calculates a birthday or anniversary (non-yahrzeit).
+     * `hyear` must be after original `gdate` of anniversary.
+     * Returns `undefined` when requested year preceeds or is same as original year.
+     *
+     * Hebcal uses the algorithm defined in "Calendrical Calculations"
+     * by Edward M. Reingold and Nachum Dershowitz.
+     *
+     * The birthday of someone born in Adar of an ordinary year or Adar II of
+     * a leap year is also always in the last month of the year, be that Adar
+     * or Adar II. The birthday in an ordinary year of someone born during the
+     * first 29 days of Adar I in a leap year is on the corresponding day of Adar;
+     * in a leap year, the birthday occurs in Adar I, as expected.
+     *
+     * Someone born on the thirtieth day of Marcheshvan, Kislev, or Adar I
+     * has his birthday postponed until the first of the following month in
+     * years where that day does not occur. [Calendrical Calculations p. 111]
+     * @example
+     * import {HebrewCalendar} from '@hebcal/core';
+     * const dt = new Date(2014, 2, 2); // '2014-03-02' == '30 Adar I 5774'
+     * const hd = HebrewCalendar.getBirthdayOrAnniversary(5780, dt); // '1 Nisan 5780'
+     * console.log(hd.greg().toLocaleDateString('en-US')); // '3/26/2020'
+     * @param hyear Hebrew year
+     * @param gdate Gregorian or Hebrew date of event
+     * @returns anniversary occurring in `hyear`
+     */
+    static getBirthdayOrAnniversary(hyear, gdate) {
+        const dt = getBirthdayHD(hyear, gdate);
+        if (typeof dt === 'undefined') {
+            return dt;
+        }
+        return new HDate(dt);
+    }
+    /**
+     * Calculates yahrzeit.
+     * `hyear` must be after original `gdate` of death.
+     * Returns `undefined` when requested year preceeds or is same as original year.
+     *
+     * Hebcal uses the algorithm defined in "Calendrical Calculations"
+     * by Edward M. Reingold and Nachum Dershowitz.
+     *
+     * The customary anniversary date of a death is more complicated and depends
+     * also on the character of the year in which the first anniversary occurs.
+     * There are several cases:
+     *
+     * * If the date of death is Marcheshvan 30, the anniversary in general depends
+     *   on the first anniversary; if that first anniversary was not Marcheshvan 30,
+     *   use the day before Kislev 1.
+     * * If the date of death is Kislev 30, the anniversary in general again depends
+     *   on the first anniversary — if that was not Kislev 30, use the day before
+     *   Tevet 1.
+     * * If the date of death is Adar II, the anniversary is the same day in the
+     *   last month of the Hebrew year (Adar or Adar II).
+     * * If the date of death is Adar I 30, the anniversary in a Hebrew year that
+     *   is not a leap year (in which Adar only has 29 days) is the last day in
+     *   Shevat.
+     * * In all other cases, use the normal (that is, same month number) anniversary
+     *   of the date of death. [Calendrical Calculations p. 113]
+     * @example
+     * import {HebrewCalendar} from '@hebcal/core';
+     * const dt = new Date(2014, 2, 2); // '2014-03-02' == '30 Adar I 5774'
+     * const hd = HebrewCalendar.getYahrzeit(5780, dt); // '30 Sh\'vat 5780'
+     * console.log(hd.greg().toLocaleDateString('en-US')); // '2/25/2020'
+     * @param hyear Hebrew year
+     * @param gdate Gregorian or Hebrew date of death
+     * @returns anniversary occurring in hyear
+     */
+    static getYahrzeit(hyear, gdate) {
+        const dt = getYahrzeitHD(hyear, gdate);
+        if (typeof dt === 'undefined') {
+            return dt;
+        }
+        return new HDate(dt);
+    }
+    /**
+     * Lower-level holidays interface, which returns a `Map` of `Event`s indexed by
+     * `HDate.toString()`. These events must filtered especially for `flags.IL_ONLY`
+     * or `flags.CHUL_ONLY` depending on Israel vs. Diaspora holiday scheme.
+     * @param year Hebrew year
+     */
+    static getHolidaysForYear(year) {
+        return getHolidaysForYear_(year);
+    }
+    /**
+     * Returns an array of holidays for the year
+     * @param year Hebrew year
+     * @param il use the Israeli schedule for holidays
+     */
+    static getHolidaysForYearArray(year, il) {
+        return getHolidaysForYearArray(year, il);
+    }
+    /**
+     * Returns an array of Events on this date (or `undefined` if no events)
+     * @param date Hebrew Date, Gregorian date, or absolute R.D. day number
+     * @param [il] use the Israeli schedule for holidays
+     */
+    static getHolidaysOnDate(date, il) {
+        return getHolidaysOnDate(date, il);
+    }
+    /**
+     * Eruv Tavshilin
+     */
+    static eruvTavshilin(date, il) {
+        if (date.getDay() < 3 || date.getDay() > 4) {
+            return false;
+        }
+        const today = new HDate(date);
+        const friday = today.after(5);
+        const tomorrow = today.next();
+        if (!isChag(friday, il) || isChag(today, il) || !isChag(tomorrow, il)) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Helper function to format a 23-hour (00:00-23:59) time in US format ("8:13pm") or
+     * keep as "20:13" for any other locale/country. Uses {@link CalOptions} to determine
+     * locale.
+     * If `options.hour12` is `false`, locale is ignored and always returns 24-hour time.
+     * If `options.hour12` is `true`, locale is ignored and always returns 12-hour time.
+     * @param timeStr - original time like "20:30"
+     * @param suffix - "p" or "pm" or " P.M.". Add leading space if you want it
+     * @param options
+     */
+    static reformatTimeStr(timeStr, suffix, options) {
+        return reformatTimeStr(timeStr, suffix, options);
+    }
+    static version() {
+        return pkgVersion;
+    }
+    /**
+     * Convenience function to create an instance of `Sedra` or reuse a previously
+     * created and cached instance.
+     */
+    static getSedra(hyear, il) {
+        return getSedra(hyear, il);
+    }
+    /**
+     * Return a number containing information on what Hallel is said on that day.
+     *
+     * Whole Hallel is said on Chanukah, the first Yom Tov of Pesach, Shavuot, Sukkot,
+     * Yom Ha'atzmaut, and Yom Yerushalayim.
+     *
+     * Half Hallel is said on Rosh Chodesh (not Rosh Hashanah), and the last 6 days of Pesach.
+     *
+     * The number is one of the following values:
+     *
+     * 0 - No Hallel
+     * 1 - Half Hallel
+     * 2 - Whole Hallel
+     */
+    static hallel(hdate, il) {
+        const events = getHolidaysForYearArray(hdate.getFullYear(), il);
+        return hallel_(events, hdate);
+    }
+    /**
+     * Return details on what Tachanun (or Tzidchatcha on Shabbat) is said on `hdate`.
+     *
+     * Tachanun is not said on Rosh Chodesh, the month of Nisan, Lag Baomer,
+     * Rosh Chodesh Sivan until Isru Chag, Tisha B'av, 15 Av, Erev Rosh Hashanah,
+     * Rosh Hashanah, Erev Yom Kippur until after Simchat Torah, Chanukah,
+     * Tu B'shvat, Purim and Shushan Purim, and Purim and Shushan Purim Katan.
+     *
+     * In some congregations Tachanun is not said until from Rosh Chodesh Sivan
+     * until 14th Sivan, Sukkot until after Rosh Chodesh Cheshvan, Pesach Sheini,
+     * Yom Ha'atzmaut, and Yom Yerushalayim.
+     *
+     * Tachanun is not said at Mincha on days before it is not said at Shacharit.
+     *
+     * Tachanun is not said at Shacharit on Shabbat, but is at Mincha, usually.
+     */
+    static tachanun(hdate, il) {
+        return tachanun(hdate, il);
+    }
+}
+/**
+ * @private
+ */
+function isChag(date, il) {
+    const events = getHolidaysOnDate(date, il) || [];
+    const chag = events.filter(ev => ev.getFlags() & flags.CHAG);
+    return chag.length !== 0;
+}

package/dist/src/holidays.d.ts

@@ -0,0 +1,22 @@
+import { HDate } from '@hebcal/hdate';
+import { HolidayEvent } from './HolidayEvent';
+/**
+ * Returns an array of Events on this date (or `undefined` if no events)
+ * @param date Hebrew Date, Gregorian date, or absolute R.D. day number
+ * @param [il] use the Israeli schedule for holidays
+ */
+export declare function getHolidaysOnDate(date: HDate | Date | number, il?: boolean): HolidayEvent[] | undefined;
+export type HolidayYearMap = Map<string, HolidayEvent[]>;
+/**
+ * Lower-level holidays interface, which returns a `Map` of `Event`s indexed by
+ * `HDate.toString()`. These events must filtered especially for `flags.IL_ONLY`
+ * or `flags.CHUL_ONLY` depending on Israel vs. Diaspora holiday scheme.
+ * @private
+ */
+export declare function getHolidaysForYear_(year: number): HolidayYearMap;
+/**
+ * Returns an array of holidays for the year
+ * @param year Hebrew year
+ * @param il use the Israeli schedule for holidays
+ */
+export declare function getHolidaysForYearArray(year: number, il: boolean): HolidayEvent[];

package/dist/src/holidays.js

@@ -0,0 +1,288 @@
+/*
+    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/>.
+ */
+import { HDate, months } from '@hebcal/hdate';
+import QuickLRU from 'quick-lru';
+import { flags } from './event';
+import { dateYomHaShoah, dateYomHaZikaron } from './modern';
+import { getSedra } from './sedra';
+import { staticHolidays, staticModernHolidays, holidayDesc as hdesc, } from './staticHolidays';
+import { YomKippurKatanEvent } from './YomKippurKatanEvent';
+import { HolidayEvent, ChanukahEvent, AsaraBTevetEvent, RoshHashanaEvent, RoshChodeshEvent, } from './HolidayEvent';
+/**
+ * Returns an array of Events on this date (or `undefined` if no events)
+ * @param date Hebrew Date, Gregorian date, or absolute R.D. day number
+ * @param [il] use the Israeli schedule for holidays
+ */
+export function getHolidaysOnDate(date, il) {
+    const hd = HDate.isHDate(date) ? date : new HDate(date);
+    const hdStr = hd.toString();
+    const yearMap = getHolidaysForYear_(hd.getFullYear());
+    const events = yearMap.get(hdStr);
+    // if il isn't a boolean return both diaspora + IL for day
+    if (typeof il === 'undefined' || typeof events === 'undefined') {
+        return events;
+    }
+    const filtered = events.filter(ev => ev.observedIn(il));
+    return filtered;
+}
+const CHAG = flags.CHAG;
+const IL_ONLY = flags.IL_ONLY;
+const LIGHT_CANDLES_TZEIS = flags.LIGHT_CANDLES_TZEIS;
+const CHANUKAH_CANDLES = flags.CHANUKAH_CANDLES;
+const MINOR_FAST = flags.MINOR_FAST;
+const SPECIAL_SHABBAT = flags.SPECIAL_SHABBAT;
+const MODERN_HOLIDAY = flags.MODERN_HOLIDAY;
+const MAJOR_FAST = flags.MAJOR_FAST;
+const MINOR_HOLIDAY = flags.MINOR_HOLIDAY;
+const EREV = flags.EREV;
+const SUN = 0;
+const TUE = 2;
+const THU = 4;
+const FRI = 5;
+const SAT = 6;
+const NISAN = months.NISAN;
+const TAMUZ = months.TAMUZ;
+const AV = months.AV;
+const TISHREI = months.TISHREI;
+const KISLEV = months.KISLEV;
+const TEVET = months.TEVET;
+const ADAR_I = months.ADAR_I;
+const ADAR_II = months.ADAR_II;
+const emojiIsraelFlag = { emoji: '🇮🇱' };
+const yearCache = new QuickLRU({ maxSize: 400 });
+/**
+ * Lower-level holidays interface, which returns a `Map` of `Event`s indexed by
+ * `HDate.toString()`. These events must filtered especially for `flags.IL_ONLY`
+ * or `flags.CHUL_ONLY` depending on Israel vs. Diaspora holiday scheme.
+ * @private
+ */
+export function getHolidaysForYear_(year) {
+    if (typeof year !== 'number') {
+        throw new TypeError(`bad Hebrew year: ${year}`);
+    }
+    else if (year < 1 || year > 32658) {
+        throw new RangeError(`Hebrew year ${year} out of range 1-32658`);
+    }
+    const cached = yearCache.get(year);
+    if (cached) {
+        return cached;
+    }
+    const RH = new HDate(1, TISHREI, year);
+    const pesach = new HDate(15, NISAN, year);
+    const map = new Map();
+    function add(...events) {
+        for (const ev of events) {
+            const key = ev.date.toString();
+            const arr = map.get(key);
+            if (typeof arr === 'object') {
+                if (arr[0].getFlags() & EREV) {
+                    arr.unshift(ev);
+                }
+                else {
+                    arr.push(ev);
+                }
+            }
+            else {
+                map.set(key, [ev]);
+            }
+        }
+    }
+    for (const h of staticHolidays) {
+        const hd = new HDate(h.dd, h.mm, year);
+        const ev = new HolidayEvent(hd, h.desc, h.flags);
+        if (h.emoji)
+            ev.emoji = h.emoji;
+        if (h.chmDay)
+            ev.cholHaMoedDay = h.chmDay;
+        add(ev);
+    }
+    // standard holidays that don't shift based on year
+    add(new RoshHashanaEvent(RH, year, CHAG | LIGHT_CANDLES_TZEIS));
+    // Variable date holidays
+    const tzomGedaliahDay = RH.getDay() === THU ? 4 : 3;
+    add(new HolidayEvent(new HDate(tzomGedaliahDay, TISHREI, year), hdesc.TZOM_GEDALIAH, MINOR_FAST));
+    // first SAT after RH
+    add(new HolidayEvent(new HDate(HDate.dayOnOrBefore(SAT, 7 + RH.abs())), hdesc.SHABBAT_SHUVA, SPECIAL_SHABBAT));
+    const rchTevet = HDate.shortKislev(year)
+        ? new HDate(1, TEVET, year)
+        : new HDate(30, KISLEV, year);
+    add(new HolidayEvent(rchTevet, hdesc.CHAG_HABANOT, MINOR_HOLIDAY));
+    add(new ChanukahEvent(new HDate(24, KISLEV, year), hdesc.CHANUKAH_1_CANDLE, EREV | MINOR_HOLIDAY | CHANUKAH_CANDLES, undefined));
+    // yes, we know Kislev 30-32 are wrong
+    // HDate() corrects the month automatically
+    for (let candles = 2; candles <= 8; candles++) {
+        const hd = new HDate(23 + candles, KISLEV, year);
+        add(new ChanukahEvent(hd, `Chanukah: ${candles} Candles`, MINOR_HOLIDAY | CHANUKAH_CANDLES, candles - 1));
+    }
+    add(new ChanukahEvent(new HDate(32, KISLEV, year), hdesc.CHANUKAH_8TH_DAY, MINOR_HOLIDAY, 8));
+    add(new AsaraBTevetEvent(new HDate(10, TEVET, year), hdesc.ASARA_BTEVET, MINOR_FAST));
+    const pesachAbs = pesach.abs();
+    add(new HolidayEvent(new HDate(HDate.dayOnOrBefore(SAT, pesachAbs - 43)), hdesc.SHABBAT_SHEKALIM, SPECIAL_SHABBAT), new HolidayEvent(new HDate(HDate.dayOnOrBefore(SAT, pesachAbs - 30)), hdesc.SHABBAT_ZACHOR, SPECIAL_SHABBAT), new HolidayEvent(new HDate(pesachAbs - (pesach.getDay() === TUE ? 33 : 31)), hdesc.TAANIT_ESTHER, MINOR_FAST));
+    const haChodeshAbs = HDate.dayOnOrBefore(SAT, pesachAbs - 14);
+    add(new HolidayEvent(new HDate(haChodeshAbs - 7), hdesc.SHABBAT_PARAH, SPECIAL_SHABBAT), new HolidayEvent(new HDate(haChodeshAbs), hdesc.SHABBAT_HACHODESH, SPECIAL_SHABBAT), new HolidayEvent(new HDate(HDate.dayOnOrBefore(SAT, pesachAbs - 1)), hdesc.SHABBAT_HAGADOL, SPECIAL_SHABBAT), new HolidayEvent(
+    // if the fast falls on Shabbat, move to Thursday
+    pesach.prev().getDay() === SAT
+        ? pesach.onOrBefore(THU)
+        : new HDate(14, NISAN, year), hdesc.TAANIT_BECHOROT, MINOR_FAST));
+    add(new HolidayEvent(new HDate(HDate.dayOnOrBefore(SAT, new HDate(1, TISHREI, year + 1).abs() - 4)), hdesc.LEIL_SELICHOT, MINOR_HOLIDAY, { emoji: '🕍' }));
+    if (pesach.getDay() === SUN) {
+        add(new HolidayEvent(new HDate(16, ADAR_II, year), hdesc.PURIM_MESHULASH, MINOR_HOLIDAY));
+    }
+    if (HDate.isLeapYear(year)) {
+        add(new HolidayEvent(new HDate(14, ADAR_I, year), hdesc.PURIM_KATAN, MINOR_HOLIDAY, { emoji: '🎭️' }));
+        add(new HolidayEvent(new HDate(15, ADAR_I, year), hdesc.SHUSHAN_PURIM_KATAN, MINOR_HOLIDAY, { emoji: '🎭️' }));
+    }
+    const nisan27dt = dateYomHaShoah(year);
+    if (nisan27dt) {
+        add(new HolidayEvent(nisan27dt, hdesc.YOM_HASHOAH, MODERN_HOLIDAY));
+    }
+    const yomHaZikaronDt = dateYomHaZikaron(year);
+    if (yomHaZikaronDt) {
+        add(new HolidayEvent(yomHaZikaronDt, hdesc.YOM_HAZIKARON, MODERN_HOLIDAY, emojiIsraelFlag), new HolidayEvent(yomHaZikaronDt.next(), hdesc.YOM_HAATZMA_UT, MODERN_HOLIDAY, emojiIsraelFlag));
+    }
+    for (const h of staticModernHolidays) {
+        if (year >= h.firstYear) {
+            let hd = new HDate(h.dd, h.mm, year);
+            const dow = hd.getDay();
+            if (h.friSatMovetoThu && (dow === FRI || dow === SAT)) {
+                hd = hd.onOrBefore(THU);
+            }
+            else if (h.friPostponeToSun && dow === FRI) {
+                hd = new HDate(hd.abs() + 2);
+            }
+            else if (h.satPostponeToSun && dow === SAT) {
+                hd = hd.next();
+            }
+            const mask = h.chul ? MODERN_HOLIDAY : MODERN_HOLIDAY | IL_ONLY;
+            const ev = new HolidayEvent(hd, h.desc, mask);
+            if (!h.suppressEmoji) {
+                ev.emoji = '🇮🇱';
+            }
+            add(ev);
+        }
+    }
+    let tamuz17 = new HDate(17, TAMUZ, year);
+    let tamuz17attrs;
+    if (tamuz17.getDay() === SAT) {
+        tamuz17 = new HDate(18, TAMUZ, year);
+        tamuz17attrs = { observed: true };
+    }
+    add(new HolidayEvent(tamuz17, hdesc.TZOM_TAMMUZ, MINOR_FAST, tamuz17attrs));
+    let av9dt = new HDate(9, AV, year);
+    let av9title = hdesc.TISHA_BAV;
+    let av9attrs;
+    if (av9dt.getDay() === SAT) {
+        av9dt = av9dt.next();
+        av9attrs = { observed: true };
+        av9title += ' (observed)';
+    }
+    const av9abs = av9dt.abs();
+    add(new HolidayEvent(new HDate(HDate.dayOnOrBefore(SAT, av9abs)), hdesc.SHABBAT_CHAZON, SPECIAL_SHABBAT), new HolidayEvent(av9dt.prev(), hdesc.EREV_TISHA_BAV, EREV | MAJOR_FAST, av9attrs), new HolidayEvent(av9dt, av9title, MAJOR_FAST, av9attrs), new HolidayEvent(new HDate(HDate.dayOnOrBefore(SAT, av9abs + 7)), hdesc.SHABBAT_NACHAMU, SPECIAL_SHABBAT));
+    const monthsInYear = HDate.monthsInYear(year);
+    for (let month = 1; month <= monthsInYear; month++) {
+        const monthName = HDate.getMonthName(month, year);
+        if ((month === NISAN
+            ? HDate.daysInMonth(HDate.monthsInYear(year - 1), year - 1)
+            : HDate.daysInMonth(month - 1, year)) === 30) {
+            add(new RoshChodeshEvent(new HDate(1, month, year), monthName));
+            add(new RoshChodeshEvent(new HDate(30, month - 1, year), monthName));
+        }
+        else if (month !== TISHREI) {
+            add(new RoshChodeshEvent(new HDate(1, month, year), monthName));
+        }
+    }
+    // Begin: Yom Kippur Katan
+    // start at Iyyar because one may not fast during Nisan
+    for (let month = months.IYYAR; month <= monthsInYear; month++) {
+        const nextMonth = month + 1;
+        // Yom Kippur Katan is not observed on the day before Rosh Hashanah.
+        // Not observed prior to Rosh Chodesh Cheshvan because Yom Kippur has just passed.
+        // Not observed before Rosh Chodesh Tevet, because that day is Hanukkah.
+        if (nextMonth === TISHREI ||
+            nextMonth === months.CHESHVAN ||
+            nextMonth === TEVET) {
+            continue;
+        }
+        let ykk = new HDate(29, month, year);
+        const dow = ykk.getDay();
+        if (dow === FRI || dow === SAT) {
+            ykk = ykk.onOrBefore(THU);
+        }
+        const nextMonthName = HDate.getMonthName(nextMonth, year);
+        const ev = new YomKippurKatanEvent(ykk, nextMonthName);
+        add(ev);
+    }
+    const sedra = getSedra(year, false);
+    const beshalachHd = sedra.find(15);
+    add(new HolidayEvent(beshalachHd, hdesc.SHABBAT_SHIRAH, SPECIAL_SHABBAT));
+    // Birkat Hachamah appears only once every 28 years
+    const birkatHaChama = getBirkatHaChama(year);
+    if (birkatHaChama) {
+        const hd = new HDate(birkatHaChama);
+        add(new HolidayEvent(hd, hdesc.BIRKAT_HACHAMAH, MINOR_HOLIDAY, { emoji: '☀️' }));
+    }
+    yearCache.set(year, map);
+    return map;
+}
+/**
+ * Birkat Hachamah appears only once every 28 years.
+ * Although almost always in Nisan, it can occur in Adar II.
+ *   - 27 Adar II 5461 (Gregorian year 1701)
+ *   - 29 Adar II 5993 (Gregorian year 2233)
+ *
+ * Due to drift, this will eventually slip into Iyyar
+ *   - 2 Iyyar 7141 (Gregorian year 3381)
+ * @private
+ */
+function getBirkatHaChama(year) {
+    const leap = HDate.isLeapYear(year);
+    const startMonth = leap ? ADAR_II : NISAN;
+    const startDay = leap ? 20 : 1;
+    const baseRd = HDate.hebrew2abs(year, startMonth, startDay);
+    for (let day = 0; day <= 40; day++) {
+        const abs = baseRd + day;
+        const elapsed = abs + 1373429;
+        if (elapsed % 10227 === 172) {
+            return abs;
+        }
+    }
+    return 0;
+}
+/**
+ * Returns an array of holidays for the year
+ * @param year Hebrew year
+ * @param il use the Israeli schedule for holidays
+ */
+export function getHolidaysForYearArray(year, il) {
+    const yearMap = getHolidaysForYear_(year);
+    const startAbs = HDate.hebrew2abs(year, TISHREI, 1);
+    const endAbs = HDate.hebrew2abs(year + 1, TISHREI, 1) - 1;
+    let events = [];
+    for (let absDt = startAbs; absDt <= endAbs; absDt++) {
+        const hd = new HDate(absDt);
+        const holidays = yearMap.get(hd.toString());
+        if (holidays) {
+            const filtered = holidays.filter(ev => ev.observedIn(il));
+            events = events.concat(filtered);
+        }
+    }
+    return events;
+}

package/dist/src/index.d.ts

@@ -0,0 +1,26 @@
+export { version } from './pkgVersion';
+export { gematriya, gematriyaStrToNum } from '@hebcal/hdate';
+export { greg, months, HDate, Locale, Headers, StringArrayMap, LocaleData, MonthName, } from '@hebcal/hdate';
+import './locale';
+export { CalOptions, DailyLearningValue } from './CalOptions';
+export { HebrewDateEvent } from './HebrewDateEvent';
+export { Event, flags } from './event';
+export { GeoLocation, NOAACalculator } from '@hebcal/noaa';
+export { Location } from './location';
+export { Zmanim } from './zmanim';
+export { isAssurBemlacha } from './isAssurBemlacha';
+export { TimedEvent, CandleLightingEvent, HavdalahEvent } from './TimedEvent';
+export { FastDayEvent, TimedChanukahEvent } from './candles';
+export { Molad, MoladEvent } from './molad';
+export { OmerEvent, OmerLang } from './omer';
+export { TachanunResult } from './tachanun';
+export { Sedra, SedraResult, parshiot, getSedra } from './sedra';
+export { ParshaEvent } from './ParshaEvent';
+export { parshaYear } from './parshaYear';
+export { HolidayEvent, ChanukahEvent, AsaraBTevetEvent, RoshChodeshEvent, RoshHashanaEvent, } from './HolidayEvent';
+export { HolidayYearMap, getHolidaysOnDate } from './holidays';
+export { MevarchimChodeshEvent } from './MevarchimChodeshEvent';
+export { YomKippurKatanEvent } from './YomKippurKatanEvent';
+export { holidayDesc } from './staticHolidays';
+export { DailyLearning } from './DailyLearning';
+export { HebrewCalendar } from './hebcal';