@hebcal/core 6.0.5 → 6.0.7

package/dist/src/candles.js

@@ -0,0 +1,163 @@
+/* eslint-disable max-len */
+import { months } from '@hebcal/hdate';
+import { flags } from './event';
+import { ChanukahEvent, HolidayEvent } from './HolidayEvent';
+import { Zmanim } from './zmanim';
+import { TimedEvent, CandleLightingEvent, HavdalahEvent } from './TimedEvent';
+const LIGHT_CANDLES = flags.LIGHT_CANDLES;
+const LIGHT_CANDLES_TZEIS = flags.LIGHT_CANDLES_TZEIS;
+/**
+ * @private
+ */
+export function makeCandleEvent(ev, hd, options, isFriday, isSaturday) {
+    let havdalahTitle = false;
+    let useHavdalahOffset = isSaturday;
+    let mask = ev ? ev.getFlags() : LIGHT_CANDLES;
+    if (typeof ev !== 'undefined') {
+        // if linked event && dow == FRI, use Candle lighting time & title
+        if (!isFriday) {
+            if (mask & (LIGHT_CANDLES_TZEIS | flags.CHANUKAH_CANDLES)) {
+                useHavdalahOffset = true;
+            }
+            else if (mask & flags.YOM_TOV_ENDS) {
+                havdalahTitle = true;
+                useHavdalahOffset = true;
+            }
+        }
+    }
+    else if (isSaturday) {
+        havdalahTitle = true;
+        mask = LIGHT_CANDLES_TZEIS;
+    }
+    // if Havdalah offset is 0 or undefined, we'll use tzeit time
+    const offset = useHavdalahOffset
+        ? Number(options.havdalahMins)
+        : Number(options.candleLightingMins);
+    const location = options.location;
+    const useElevation = Boolean(options.useElevation);
+    const zmanim = new Zmanim(location, hd, useElevation);
+    const time = useHavdalahOffset && !offset
+        ? zmanim.tzeit(options.havdalahDeg)
+        : zmanim.sunsetOffset(offset, true);
+    if (isNaN(time.getTime())) {
+        return undefined; // no sunset
+    }
+    if (havdalahTitle) {
+        return new HavdalahEvent(hd, mask, time, location, options.havdalahMins, ev, options);
+    }
+    else {
+        mask |= LIGHT_CANDLES;
+        return new CandleLightingEvent(hd, mask, time, location, ev, options);
+    }
+}
+const FAST_BEGINS = 'Fast begins';
+const FAST_ENDS = 'Fast ends';
+/** A fast day also contains a start and end time */
+export class FastDayEvent extends HolidayEvent {
+    constructor(linkedEvent, startEvent, endEvent) {
+        super(linkedEvent.getDate(), linkedEvent.getDesc(), linkedEvent.getFlags());
+        this.linkedEvent = linkedEvent;
+        this.startEvent = startEvent;
+        this.endEvent = endEvent;
+    }
+    render(locale) {
+        return this.linkedEvent.render(locale);
+    }
+    renderBrief(locale) {
+        return this.linkedEvent.renderBrief(locale);
+    }
+    urlDateSuffix() {
+        return this.linkedEvent.urlDateSuffix();
+    }
+    url() {
+        return this.linkedEvent.url();
+    }
+    getEmoji() {
+        return this.linkedEvent.getEmoji();
+    }
+    getCategories() {
+        return this.linkedEvent.getCategories();
+    }
+}
+/**
+ * Makes a pair of events representing fast start and end times
+ * @private
+ */
+export function makeFastStartEnd(ev, options) {
+    const desc = ev.getDesc();
+    if (desc === 'Yom Kippur') {
+        throw new RangeError('YK does not require this function');
+    }
+    const hd = ev.getDate();
+    const dt = hd.greg();
+    const location = options.location;
+    const fastEndDeg = options.fastEndDeg;
+    const useElevation = Boolean(options.useElevation);
+    const zmanim = new Zmanim(location, dt, useElevation);
+    let startEvent;
+    let endEvent;
+    if (desc === "Erev Tish'a B'Av") {
+        const sunset = zmanim.sunset();
+        if (!isNaN(sunset.getTime())) {
+            startEvent = makeTimedEvent(ev, sunset, FAST_BEGINS, options);
+        }
+    }
+    else if (desc.startsWith("Tish'a B'Av")) {
+        const tzeit = zmanim.tzeit(fastEndDeg);
+        if (!isNaN(tzeit.getTime())) {
+            endEvent = makeTimedEvent(ev, tzeit, FAST_ENDS, options);
+        }
+    }
+    else {
+        const dawn = zmanim.alotHaShachar();
+        if (!isNaN(dawn.getTime())) {
+            startEvent = makeTimedEvent(ev, dawn, FAST_BEGINS, options);
+        }
+        if (dt.getDay() !== 5 &&
+            !(hd.getDate() === 14 && hd.getMonth() === months.NISAN)) {
+            const tzeit = zmanim.tzeit(fastEndDeg);
+            if (!isNaN(tzeit.getTime())) {
+                endEvent = makeTimedEvent(ev, tzeit, FAST_ENDS, options);
+            }
+        }
+    }
+    const ev2 = new FastDayEvent(ev, startEvent, endEvent);
+    // copy properties such as memo or emoji
+    Object.assign(ev2, ev);
+    return ev2;
+}
+/**
+ * @private
+ */
+function makeTimedEvent(ev, time, desc, options) {
+    const location = options.location;
+    const hd = ev.getDate();
+    return new TimedEvent(hd, desc, ev.getFlags(), time, location, ev, options);
+}
+export class TimedChanukahEvent extends ChanukahEvent {
+    constructor(ev, eventTime, location) {
+        super(ev.getDate(), ev.getDesc(), ev.getFlags(), ev.chanukahDay);
+        this.eventTime = Zmanim.roundTime(eventTime);
+        const timeFormat = location.getTimeFormatter();
+        this.eventTimeStr = Zmanim.formatTime(this.eventTime, timeFormat);
+        this.location = location;
+        this.emoji = ev.emoji;
+    }
+}
+/**
+ * Makes a candle-lighting event for Chankah (not on Friday/Saturday).
+ * At one point this used civil dusk (6 degrees below horizon).
+ * Another source suggests 4.6667 degrees below horizon.
+ * @private
+ */
+export function makeWeekdayChanukahCandleLighting(ev, options) {
+    const hd = ev.getDate();
+    const location = options.location;
+    const useElevation = Boolean(options.useElevation);
+    const zmanim = new Zmanim(location, hd.greg(), useElevation);
+    const candleLightingTime = zmanim.beinHaShmashos();
+    if (isNaN(candleLightingTime.getTime())) {
+        return null;
+    }
+    return new TimedChanukahEvent(ev, candleLightingTime, location);
+}

package/dist/src/event.d.ts

@@ -0,0 +1,188 @@
+import { HDate } from '@hebcal/hdate';
+import './locale';
+/**
+ * Holiday flags for Event. These flags are typically
+ * combined using bitwise arithmetic to form a mask.
+ * @readonly
+ * @enum {number}
+ */
+export declare const flags: {
+    /** Chag, yontiff, yom tov */
+    readonly CHAG: 1;
+    /** Light candles 18 minutes before sundown */
+    readonly LIGHT_CANDLES: 2;
+    /** End of holiday (end of Yom Tov)  */
+    readonly YOM_TOV_ENDS: 4;
+    /** Observed only in the Diaspora (chutz l'aretz)  */
+    readonly CHUL_ONLY: 8;
+    /** Observed only in Israel */
+    readonly IL_ONLY: 16;
+    /** Light candles in the evening at Tzeit time (3 small stars) */
+    readonly LIGHT_CANDLES_TZEIS: 32;
+    /** Candle-lighting for Chanukah */
+    readonly CHANUKAH_CANDLES: 64;
+    /** Rosh Chodesh, beginning of a new Hebrew month */
+    readonly ROSH_CHODESH: 128;
+    /** Minor fasts like Tzom Tammuz, Ta'anit Esther, ... */
+    readonly MINOR_FAST: 256;
+    /** Shabbat Shekalim, Zachor, ... */
+    readonly SPECIAL_SHABBAT: 512;
+    /** Weekly sedrot on Saturdays */
+    readonly PARSHA_HASHAVUA: 1024;
+    /** Daily page of Talmud (Bavli) */
+    readonly DAF_YOMI: 2048;
+    /** Days of the Omer */
+    readonly OMER_COUNT: 4096;
+    /** Yom HaShoah, Yom HaAtzma'ut, ... */
+    readonly MODERN_HOLIDAY: 8192;
+    /** Yom Kippur and Tish'a B'Av */
+    readonly MAJOR_FAST: 16384;
+    /** On the Saturday before Rosh Chodesh */
+    readonly SHABBAT_MEVARCHIM: 32768;
+    /** Molad */
+    readonly MOLAD: 65536;
+    /** Yahrzeit or Hebrew Anniversary */
+    readonly USER_EVENT: 131072;
+    /** Daily Hebrew date ("11th of Sivan, 5780") */
+    readonly HEBREW_DATE: 262144;
+    /** A holiday that's not major, modern, rosh chodesh, or a fast day */
+    readonly MINOR_HOLIDAY: 524288;
+    /** Evening before a major or minor holiday */
+    readonly EREV: 1048576;
+    /** Chol haMoed, intermediate days of Pesach or Sukkot */
+    readonly CHOL_HAMOED: 2097152;
+    /** Mishna Yomi */
+    readonly MISHNA_YOMI: 4194304;
+    /** Yom Kippur Katan, minor day of atonement on the day preceeding each Rosh Chodesh */
+    readonly YOM_KIPPUR_KATAN: 8388608;
+    /** Daily page of Jerusalem Talmud (Yerushalmi) */
+    readonly YERUSHALMI_YOMI: 16777216;
+    /** Nach Yomi */
+    readonly NACH_YOMI: 33554432;
+    /** Daily Learning */
+    readonly DAILY_LEARNING: 67108864;
+    /** Yizkor */
+    readonly YIZKOR: 134217728;
+};
+/**
+ * Represents an Event with a title, date, and flags.
+ *
+ * Events are used to represent holidays, candle-lighting times,
+ * Torah readings, and more.
+ *
+ * To get the title of the event a language other than English
+ * with Sephardic transliterations, use the `render()` method.
+ */
+export declare class Event {
+    /** Hebrew date of this event */
+    readonly date: HDate;
+    /**
+     * Untranslated title of this event. Note that these description
+     * strings are always in English and will remain stable across releases.
+     * To get the title of the event in another language, use the
+     * `render()` method.
+     */
+    readonly desc: string;
+    /** Bitmask of optional event flags. See {@link flags} */
+    readonly mask: number;
+    /** Optional emoji character such as ✡️, 🕯️, 🕎, 🕍, 🌒 */
+    emoji?: string;
+    /** Optional longer description or memo text */
+    memo?: string;
+    /** Alarms are used by iCalendar feeds */
+    alarm?: Date | string | boolean;
+    /**
+     * Constructs Event
+     * @param date Hebrew date event occurs
+     * @param desc Description (not translated)
+     * @param [mask=0] optional bitmask of holiday flags (see {@link flags})
+     * @param [attrs={}] optional additional attributes (e.g. `eventTimeStr`, `cholHaMoedDay`)
+     */
+    constructor(date: HDate, desc: string, mask?: number, attrs?: object);
+    /**
+     * Hebrew date of this event
+     */
+    getDate(): HDate;
+    /**
+     * Gregorian date of this event
+     */
+    greg(): Date;
+    /**
+     * Untranslated title of this event. Note that these description
+     * strings are always in English and will remain stable across releases.
+     * To get the title of the event in another language, use the
+     * `render()` method.
+     */
+    getDesc(): string;
+    /**
+     * Bitmask of optional event flags. See {@link flags}
+     */
+    getFlags(): number;
+    /**
+     * Returns (translated) description of this event
+     * @example
+     * const ev = new Event(new HDate(6, 'Sivan', 5749), 'Shavuot', flags.CHAG);
+     * ev.render('en'); // 'Shavuot'
+     * ev.render('he'); // 'שָׁבוּעוֹת'
+     * ev.render('ashkenazi'); // 'Shavuos'
+     * @param [locale] Optional locale name (defaults to empty locale)
+     */
+    render(locale?: string): string;
+    /**
+     * Returns a brief (translated) description of this event.
+     * For most events, this is the same as render(). For some events, it procudes
+     * a shorter text (e.g. without a time or added description).
+     * @param [locale] Optional locale name (defaults to empty locale)
+     */
+    renderBrief(locale?: string): string;
+    /**
+     * Optional holiday-specific Emoji or `null`.
+     */
+    getEmoji(): string | null;
+    /**
+     * Returns a simplified (untranslated) description for this event. For example,
+     * the `HolidayEvent` class supports
+     * "Erev Pesach" => "Pesach", and "Sukkot III (CH''M)" => "Sukkot".
+     * For many holidays the basename and the event description are the same.
+     */
+    basename(): string;
+    /**
+     * Returns a URL to hebcal.com or sefaria.org for more detail on the event.
+     * Returns `undefined` for events with no detail page.
+     */
+    url(): string | undefined;
+    /**
+     * Is this event observed in Israel?
+     * @example
+     * const ev1 = new Event(new HDate(7, 'Sivan', 5749), 'Shavuot II', flags.CHAG | flags.CHUL_ONLY);
+     * ev1.observedInIsrael(); // false
+     * const ev2 = new Event(new HDate(26, 'Kislev', 5749), 'Chanukah: 3 Candles', 0);
+     * ev2.observedInIsrael(); // true
+     */
+    observedInIsrael(): boolean;
+    /**
+     * Is this event observed in the Diaspora?
+     * @example
+     * const ev1 = new Event(new HDate(7, 'Sivan', 5749), 'Shavuot II', flags.CHAG | flags.CHUL_ONLY);
+     * ev1.observedInDiaspora(); // true
+     * const ev2 = new Event(new HDate(26, 'Kislev', 5749), 'Chanukah: 3 Candles', 0);
+     * ev2.observedInDiaspora(); // true
+     */
+    observedInDiaspora(): boolean;
+    /**
+     * Is this event observed in Israel/Diaspora?
+     * @example
+     * const ev1 = new Event(new HDate(7, 'Sivan', 5749), 'Shavuot II', flags.CHAG | flags.CHUL_ONLY);
+     * ev1.observedIn(false); // true
+     * ev1.observedIn(true); // false
+     * const ev2 = new Event(new HDate(26, 'Kislev', 5749), 'Chanukah: 3 Candles', 0);
+     * ev2.observedIn(false); // true
+     * ev2.observedIn(true); // true
+     * @param il
+     */
+    observedIn(il: boolean): boolean;
+    /**
+     * Returns a list of event categories
+     */
+    getCategories(): string[];
+}

package/dist/src/event.js

@@ -0,0 +1,233 @@
+import { HDate, Locale } from '@hebcal/hdate';
+import './locale'; // Adds Hebrew and Ashkenazic translations
+/**
+ * Holiday flags for Event. These flags are typically
+ * combined using bitwise arithmetic to form a mask.
+ * @readonly
+ * @enum {number}
+ */
+export const flags = {
+    /** Chag, yontiff, yom tov */
+    CHAG: 0x000001,
+    /** Light candles 18 minutes before sundown */
+    LIGHT_CANDLES: 0x000002,
+    /** End of holiday (end of Yom Tov)  */
+    YOM_TOV_ENDS: 0x000004,
+    /** Observed only in the Diaspora (chutz l'aretz)  */
+    CHUL_ONLY: 0x000008,
+    /** Observed only in Israel */
+    IL_ONLY: 0x000010,
+    /** Light candles in the evening at Tzeit time (3 small stars) */
+    LIGHT_CANDLES_TZEIS: 0x000020,
+    /** Candle-lighting for Chanukah */
+    CHANUKAH_CANDLES: 0x000040,
+    /** Rosh Chodesh, beginning of a new Hebrew month */
+    ROSH_CHODESH: 0x000080,
+    /** Minor fasts like Tzom Tammuz, Ta'anit Esther, ... */
+    MINOR_FAST: 0x000100,
+    /** Shabbat Shekalim, Zachor, ... */
+    SPECIAL_SHABBAT: 0x000200,
+    /** Weekly sedrot on Saturdays */
+    PARSHA_HASHAVUA: 0x000400,
+    /** Daily page of Talmud (Bavli) */
+    DAF_YOMI: 0x000800,
+    /** Days of the Omer */
+    OMER_COUNT: 0x001000,
+    /** Yom HaShoah, Yom HaAtzma'ut, ... */
+    MODERN_HOLIDAY: 0x002000,
+    /** Yom Kippur and Tish'a B'Av */
+    MAJOR_FAST: 0x004000,
+    /** On the Saturday before Rosh Chodesh */
+    SHABBAT_MEVARCHIM: 0x008000,
+    /** Molad */
+    MOLAD: 0x010000,
+    /** Yahrzeit or Hebrew Anniversary */
+    USER_EVENT: 0x020000,
+    /** Daily Hebrew date ("11th of Sivan, 5780") */
+    HEBREW_DATE: 0x040000,
+    /** A holiday that's not major, modern, rosh chodesh, or a fast day */
+    MINOR_HOLIDAY: 0x080000,
+    /** Evening before a major or minor holiday */
+    EREV: 0x100000,
+    /** Chol haMoed, intermediate days of Pesach or Sukkot */
+    CHOL_HAMOED: 0x200000,
+    /** Mishna Yomi */
+    MISHNA_YOMI: 0x400000,
+    /** Yom Kippur Katan, minor day of atonement on the day preceeding each Rosh Chodesh */
+    YOM_KIPPUR_KATAN: 0x800000,
+    /** Daily page of Jerusalem Talmud (Yerushalmi) */
+    YERUSHALMI_YOMI: 0x1000000,
+    /** Nach Yomi */
+    NACH_YOMI: 0x2000000,
+    /** Daily Learning */
+    DAILY_LEARNING: 0x4000000,
+    /** Yizkor */
+    YIZKOR: 0x8000000,
+};
+const flagToCategory = [
+    [flags.MAJOR_FAST, 'holiday', 'major', 'fast'],
+    [flags.CHANUKAH_CANDLES, 'holiday', 'major'],
+    [flags.HEBREW_DATE, 'hebdate'],
+    [flags.MINOR_FAST, 'holiday', 'fast'],
+    [flags.MINOR_HOLIDAY, 'holiday', 'minor'],
+    [flags.MODERN_HOLIDAY, 'holiday', 'modern'],
+    [flags.MOLAD, 'molad'],
+    [flags.OMER_COUNT, 'omer'],
+    [flags.PARSHA_HASHAVUA, 'parashat'], // backwards-compat
+    [flags.ROSH_CHODESH, 'roshchodesh'],
+    [flags.SHABBAT_MEVARCHIM, 'mevarchim'],
+    [flags.SPECIAL_SHABBAT, 'holiday', 'shabbat'],
+    [flags.USER_EVENT, 'user'],
+    [flags.YIZKOR, 'yizkor'],
+];
+/**
+ * Represents an Event with a title, date, and flags.
+ *
+ * Events are used to represent holidays, candle-lighting times,
+ * Torah readings, and more.
+ *
+ * To get the title of the event a language other than English
+ * with Sephardic transliterations, use the `render()` method.
+ */
+export class Event {
+    /**
+     * Constructs Event
+     * @param date Hebrew date event occurs
+     * @param desc Description (not translated)
+     * @param [mask=0] optional bitmask of holiday flags (see {@link flags})
+     * @param [attrs={}] optional additional attributes (e.g. `eventTimeStr`, `cholHaMoedDay`)
+     */
+    constructor(date, desc, mask = 0, attrs) {
+        if (!HDate.isHDate(date)) {
+            throw new TypeError(`Invalid Event date: ${date}`);
+        }
+        else if (typeof desc !== 'string') {
+            throw new TypeError(`Invalid Event description: ${desc}`);
+        }
+        this.date = date;
+        this.desc = desc;
+        this.mask = +mask;
+        if (typeof attrs === 'object' && attrs !== null) {
+            Object.assign(this, attrs);
+        }
+    }
+    /**
+     * Hebrew date of this event
+     */
+    getDate() {
+        return this.date;
+    }
+    /**
+     * Gregorian date of this event
+     */
+    greg() {
+        return this.date.greg();
+    }
+    /**
+     * Untranslated title of this event. Note that these description
+     * strings are always in English and will remain stable across releases.
+     * To get the title of the event in another language, use the
+     * `render()` method.
+     */
+    getDesc() {
+        return this.desc;
+    }
+    /**
+     * Bitmask of optional event flags. See {@link flags}
+     */
+    getFlags() {
+        return this.mask;
+    }
+    /**
+     * Returns (translated) description of this event
+     * @example
+     * const ev = new Event(new HDate(6, 'Sivan', 5749), 'Shavuot', flags.CHAG);
+     * ev.render('en'); // 'Shavuot'
+     * ev.render('he'); // 'שָׁבוּעוֹת'
+     * ev.render('ashkenazi'); // 'Shavuos'
+     * @param [locale] Optional locale name (defaults to empty locale)
+     */
+    render(locale) {
+        return Locale.gettext(this.desc, locale);
+    }
+    /**
+     * Returns a brief (translated) description of this event.
+     * For most events, this is the same as render(). For some events, it procudes
+     * a shorter text (e.g. without a time or added description).
+     * @param [locale] Optional locale name (defaults to empty locale)
+     */
+    renderBrief(locale) {
+        return this.render(locale);
+    }
+    /**
+     * Optional holiday-specific Emoji or `null`.
+     */
+    getEmoji() {
+        return this.emoji || null;
+    }
+    /**
+     * Returns a simplified (untranslated) description for this event. For example,
+     * the `HolidayEvent` class supports
+     * "Erev Pesach" => "Pesach", and "Sukkot III (CH''M)" => "Sukkot".
+     * For many holidays the basename and the event description are the same.
+     */
+    basename() {
+        return this.getDesc();
+    }
+    /**
+     * Returns a URL to hebcal.com or sefaria.org for more detail on the event.
+     * Returns `undefined` for events with no detail page.
+     */
+    url() {
+        return undefined;
+    }
+    /**
+     * Is this event observed in Israel?
+     * @example
+     * const ev1 = new Event(new HDate(7, 'Sivan', 5749), 'Shavuot II', flags.CHAG | flags.CHUL_ONLY);
+     * ev1.observedInIsrael(); // false
+     * const ev2 = new Event(new HDate(26, 'Kislev', 5749), 'Chanukah: 3 Candles', 0);
+     * ev2.observedInIsrael(); // true
+     */
+    observedInIsrael() {
+        return !(this.mask & flags.CHUL_ONLY);
+    }
+    /**
+     * Is this event observed in the Diaspora?
+     * @example
+     * const ev1 = new Event(new HDate(7, 'Sivan', 5749), 'Shavuot II', flags.CHAG | flags.CHUL_ONLY);
+     * ev1.observedInDiaspora(); // true
+     * const ev2 = new Event(new HDate(26, 'Kislev', 5749), 'Chanukah: 3 Candles', 0);
+     * ev2.observedInDiaspora(); // true
+     */
+    observedInDiaspora() {
+        return !(this.mask & flags.IL_ONLY);
+    }
+    /**
+     * Is this event observed in Israel/Diaspora?
+     * @example
+     * const ev1 = new Event(new HDate(7, 'Sivan', 5749), 'Shavuot II', flags.CHAG | flags.CHUL_ONLY);
+     * ev1.observedIn(false); // true
+     * ev1.observedIn(true); // false
+     * const ev2 = new Event(new HDate(26, 'Kislev', 5749), 'Chanukah: 3 Candles', 0);
+     * ev2.observedIn(false); // true
+     * ev2.observedIn(true); // true
+     * @param il
+     */
+    observedIn(il) {
+        return il ? this.observedInIsrael() : this.observedInDiaspora();
+    }
+    /**
+     * Returns a list of event categories
+     */
+    getCategories() {
+        const mask = this.getFlags();
+        for (const attrs of flagToCategory) {
+            const attr0 = attrs[0];
+            if (mask & attr0) {
+                return attrs.slice(1);
+            }
+        }
+        return ['unknown'];
+    }
+}

package/dist/src/getStartAndEnd.d.ts

@@ -0,0 +1,6 @@
+import { CalOptions } from './CalOptions';
+/**
+ * Parse options object to determine start & end days
+ * @private
+ */
+export declare function getStartAndEnd(options: CalOptions): number[];

package/dist/src/getStartAndEnd.js

@@ -0,0 +1,97 @@
+import { greg2abs, isDate, daysInGregMonth, HDate, months } from '@hebcal/hdate';
+const TISHREI = months.TISHREI;
+/**
+ * Gets the R.D. days for a number, Date, or HDate
+ * @private
+ */
+function getAbs(d) {
+    if (typeof d === 'number')
+        return d;
+    if (isDate(d))
+        return greg2abs(d);
+    if (HDate.isHDate(d))
+        return d.abs();
+    throw new TypeError(`Invalid date type: ${d}`);
+}
+function getYear(options) {
+    if (typeof options.year !== 'undefined') {
+        return Number(options.year);
+    }
+    return options.isHebrewYear
+        ? new HDate().getFullYear()
+        : new Date().getFullYear();
+}
+/**
+ * Parse options object to determine start & end days
+ * @private
+ */
+export function getStartAndEnd(options) {
+    if ((options.start && !options.end) || (options.end && !options.start)) {
+        throw new TypeError('Both options.start and options.end are required');
+    }
+    else if (options.start && options.end) {
+        return [getAbs(options.start), getAbs(options.end)];
+    }
+    const isHebrewYear = Boolean(options.isHebrewYear);
+    const theYear = getYear(options);
+    if (isNaN(theYear)) {
+        throw new RangeError(`Invalid year ${options.year}`);
+    }
+    else if (isHebrewYear && theYear < 1) {
+        throw new RangeError(`Invalid Hebrew year ${theYear}`);
+    }
+    const theMonth = getMonth(options);
+    const numYears = Number(options.numYears) || 1;
+    if (isHebrewYear) {
+        return startEndHebrew(theMonth, theYear, numYears);
+    }
+    else {
+        return startEndGregorian(theMonth, theYear, numYears);
+    }
+}
+function getMonth(options) {
+    if (options.month) {
+        if (options.isHebrewYear) {
+            return HDate.monthNum(options.month);
+        }
+        else if (typeof options.month === 'number') {
+            return options.month;
+        }
+    }
+    return NaN;
+}
+function startEndGregorian(theMonth, theYear, numYears) {
+    const gregMonth = theMonth ? theMonth - 1 : 0;
+    const startGreg = new Date(theYear, gregMonth, 1);
+    if (theYear < 100) {
+        startGreg.setFullYear(theYear);
+    }
+    const startAbs = greg2abs(startGreg);
+    let endAbs;
+    if (theMonth) {
+        endAbs = startAbs + daysInGregMonth(theMonth, theYear) - 1;
+    }
+    else {
+        const endYear = theYear + numYears;
+        const endGreg = new Date(endYear, 0, 1);
+        if (endYear < 100) {
+            endGreg.setFullYear(endYear);
+        }
+        endAbs = greg2abs(endGreg) - 1;
+    }
+    return [startAbs, endAbs];
+}
+function startEndHebrew(theMonth, theYear, numYears) {
+    const startDate = new HDate(1, theMonth || TISHREI, theYear);
+    let startAbs = startDate.abs();
+    const endAbs = theMonth
+        ? startAbs + startDate.daysInMonth()
+        : new HDate(1, TISHREI, theYear + numYears).abs() - 1;
+    // for full Hebrew year, start on Erev Rosh Hashana which
+    // is technically in the previous Hebrew year
+    // (but conveniently lets us get candle-lighting time for Erev)
+    if (!theMonth && theYear > 1) {
+        startAbs--;
+    }
+    return [startAbs, endAbs];
+}

package/dist/src/hallel.d.ts

@@ -0,0 +1,6 @@
+import { HDate } from '@hebcal/hdate';
+import { Event } from './event';
+/**
+ * @private
+ */
+export declare function hallel_(events: Event[], hdate: HDate): number;