@hebcal/leyning 8.2.9 → 9.0.1

package/dist/esm/clone.js

@@ -0,0 +1,32 @@
+/*! @hebcal/leyning v9.0.1 */
+import { calculateNumVerses } from './common.js';
+
+/**
+ * Makes a deep copy of the src object using JSON stringify and parse
+ */
+function clone(src) {
+    return JSON.parse(JSON.stringify(src));
+}
+function cloneHaftara(haft) {
+    if (!haft) {
+        return haft;
+    }
+    const dest = clone(haft);
+    if (Array.isArray(dest)) {
+        dest.map(calculateNumVerses);
+    }
+    else {
+        calculateNumVerses(dest);
+    }
+    return dest;
+}
+/**
+ * Returns the total number of verses in an array of Aliyah (or haftarah) objects
+ */
+function sumVerses(aliyot) {
+    return Array.isArray(aliyot)
+        ? aliyot.reduce((prev, cur) => prev + cur.v, 0)
+        : aliyot.v;
+}
+
+export { clone, cloneHaftara, sumVerses };

package/dist/esm/common.d.ts

@@ -0,0 +1,33 @@
+import { Aliyah } from './types';
+/**
+ * Names of the books of the Torah. BOOK[1] === 'Genesis'
+ * @readonly
+ */
+export declare const BOOK: readonly ["", "Genesis", "Exodus", "Leviticus", "Numbers", "Deuteronomy"];
+/**
+ * The number of verses in each book of the Tanakh.
+ * @readonly
+ */
+export declare const NUM_VERSES: NumVerses;
+export type NumVerses = {
+    readonly [book: string]: readonly number[];
+};
+/**
+ * Formats parsha as a string
+ * @param parsha untranslated name like 'Pinchas' or ['Pinchas'] or ['Matot','Masei']
+ */
+export declare function parshaToString(parsha: string | string[]): string;
+/**
+ * Calculates the number of verses in an aliyah or haftara based on
+ * the `b` (begin verse), `e` (end verse) and `k` (book).
+ * Modifies `aliyah` by setting the `v` field.
+ */
+export declare function calculateNumVerses(aliyah: Aliyah): number;
+/**
+ * Formats an aliyah object like "Numbers 28:9-28:15"
+ */
+export declare function formatAliyahWithBook(a: Aliyah): string;
+/**
+ * Formats an aliyah object like "Numbers 28:9-15"
+ */
+export declare function formatAliyahShort(aliyah: Aliyah, showBook: boolean): string;

package/dist/esm/common.js

@@ -0,0 +1,94 @@
+/*! @hebcal/leyning v9.0.1 */
+import numverses from './numverses.json.js';
+
+/**
+ * Names of the books of the Torah. BOOK[1] === 'Genesis'
+ * @readonly
+ */
+const BOOK = [
+    '',
+    'Genesis',
+    'Exodus',
+    'Leviticus',
+    'Numbers',
+    'Deuteronomy',
+];
+/**
+ * The number of verses in each book of the Tanakh.
+ * @readonly
+ */
+const NUM_VERSES = numverses;
+/**
+ * Formats parsha as a string
+ * @param parsha untranslated name like 'Pinchas' or ['Pinchas'] or ['Matot','Masei']
+ */
+function parshaToString(parsha) {
+    if (typeof parsha === 'string') {
+        return parsha;
+    }
+    else if (!Array.isArray(parsha) ||
+        parsha.length === 0 ||
+        parsha.length > 2) {
+        throw new TypeError(`Bad parsha argument: ${parsha}`);
+    }
+    let s = parsha[0];
+    if (parsha.length === 2) {
+        s += '-' + parsha[1];
+    }
+    return s;
+}
+/**
+ * Calculates the number of verses in an aliyah or haftara based on
+ * the `b` (begin verse), `e` (end verse) and `k` (book).
+ * Modifies `aliyah` by setting the `v` field.
+ */
+function calculateNumVerses(aliyah) {
+    if (aliyah.v) {
+        return aliyah.v;
+    }
+    const chapVerseBegin = aliyah.b.split(':');
+    const chapVerseEnd = aliyah.e.split(':');
+    const c1 = parseInt(chapVerseBegin[0], 10);
+    const c2 = parseInt(chapVerseEnd[0], 10);
+    const v1 = parseInt(chapVerseBegin[1], 10);
+    const v2 = parseInt(chapVerseEnd[1], 10);
+    if (c1 === c2) {
+        aliyah.v = v2 - v1 + 1;
+    }
+    else if (typeof aliyah.k === 'string') {
+        const numv = NUM_VERSES[aliyah.k];
+        if (typeof numv !== 'object' || !numv.length) {
+            throw new ReferenceError(`Can't find numverses for ${aliyah.k}`);
+        }
+        let total = numv[c1] - v1 + 1;
+        for (let chap = c1 + 1; chap < c2; chap++) {
+            total += numv[chap];
+        }
+        total += v2;
+        aliyah.v = total;
+    }
+    return aliyah.v;
+}
+/**
+ * Formats an aliyah object like "Numbers 28:9-28:15"
+ */
+function formatAliyahWithBook(a) {
+    return `${a.k} ${a.b}-${a.e}`;
+}
+/**
+ * Formats an aliyah object like "Numbers 28:9-15"
+ */
+function formatAliyahShort(aliyah, showBook) {
+    const begin = aliyah.b;
+    const end0 = aliyah.e;
+    const prefix = showBook ? aliyah.k + ' ' : '';
+    if (begin === end0) {
+        return `${prefix}${begin}`;
+    }
+    const cv1 = begin.split(':');
+    const cv2 = end0.split(':');
+    const end = cv1[0] === cv2[0] ? cv2[1] : end0;
+    return `${prefix}${begin}-${end}`;
+}
+
+export { BOOK, NUM_VERSES, calculateNumVerses, formatAliyahShort, formatAliyahWithBook, parshaToString };

package/dist/esm/csv.d.ts

@@ -0,0 +1,14 @@
+import { Event, HolidayEvent } from '@hebcal/core';
+import { WriteStream } from 'node:fs';
+import { Leyning } from './types';
+export interface StringToBoolMap {
+    [key: string]: boolean;
+}
+export declare function getParshaDates(events: Event[]): StringToBoolMap;
+export declare function writeFullKriyahCsv(stream: WriteStream, hyear: number, il: boolean): void;
+export declare function writeFullKriyahEvent(stream: WriteStream, ev: Event, il: boolean): void;
+export declare function writeHolidayMincha(stream: WriteStream, ev: HolidayEvent, il: boolean): void;
+/**
+ * Formats reading for CSV
+ */
+export declare function writeCsvLines(stream: WriteStream, ev: Event, reading: Leyning, il: boolean, isParsha: boolean): void;

package/dist/esm/csv.js

@@ -0,0 +1,153 @@
+/*! @hebcal/leyning v9.0.1 */
+import { flags, HebrewCalendar, HolidayEvent, Event } from '@hebcal/core';
+import { formatAliyahWithBook } from './common.js';
+import { getLeyningForHoliday, getLeyningForHolidayKey } from './getLeyningForHoliday.js';
+import { getLeyningKeyForEvent } from './getLeyningKeyForEvent.js';
+import { getLeyningForParshaHaShavua } from './leyning.js';
+
+const fmt = new Intl.DateTimeFormat('en-US', {
+    year: 'numeric',
+    month: 'short',
+    day: '2-digit',
+});
+function fmtDate(dt) {
+    const s = fmt.format(dt).split(' ');
+    return s[1].substring(0, 2) + '-' + s[0] + '-' + s[2];
+}
+function getParshaDates(events) {
+    const parshaEvents = events.filter(ev => ev.getFlags() === flags.PARSHA_HASHAVUA);
+    const emptyMap = {};
+    const parshaDates = parshaEvents.reduce((set, ev) => {
+        set[ev.getDate().toString()] = true;
+        return set;
+    }, emptyMap);
+    return parshaDates;
+}
+function writeFullKriyahCsv(stream, hyear, il) {
+    const events0 = HebrewCalendar.calendar({
+        year: hyear,
+        isHebrewYear: true,
+        sedrot: true,
+        il: il,
+    });
+    const events = events0.filter((ev) => ev.getDesc() !== 'Rosh Chodesh Tevet');
+    const parshaDates = getParshaDates(events);
+    stream.write('"Date","Parashah","Aliyah","Reading","Verses"\r\n');
+    for (const ev of events) {
+        if (ev.getFlags() === flags.PARSHA_HASHAVUA ||
+            !parshaDates[ev.getDate().toString()]) {
+            writeFullKriyahEvent(stream, ev, il);
+        }
+    }
+}
+function ignore(ev) {
+    const mask = ev.getFlags();
+    if (mask === flags.SPECIAL_SHABBAT) {
+        return true;
+    }
+    if (mask !== flags.ROSH_CHODESH) {
+        return false;
+    }
+    return ev.getDate().getDay() === 6;
+}
+function writeFullKriyahEvent(stream, ev, il) {
+    if (ignore(ev)) {
+        return;
+    }
+    const mask = ev.getFlags();
+    const isParsha = mask === flags.PARSHA_HASHAVUA;
+    const reading = isParsha
+        ? getLeyningForParshaHaShavua(ev, il)
+        : getLeyningForHoliday(ev, il);
+    if (reading) {
+        writeCsvLines(stream, ev, reading, il, isParsha);
+        if (!isParsha) {
+            writeHolidayMincha(stream, ev, il);
+            const desc = ev.getDesc();
+            if ((il && desc === 'Sukkot VII (Hoshana Raba)') ||
+                (!il && desc === 'Shmini Atzeret')) {
+                const ev2 = new HolidayEvent(ev.getDate(), 'Erev Simchat Torah', flags.EREV);
+                writeFullKriyahEvent(stream, ev2, il);
+            }
+        }
+    }
+}
+function writeHolidayMincha(stream, ev, il) {
+    const desc = ev.getDesc();
+    const minchaDesc1 = desc + ' (Mincha)';
+    const readingMincha1 = getLeyningForHolidayKey(minchaDesc1, ev.cholHaMoedDay, il);
+    const readingMincha = readingMincha1 ||
+        getLeyningForHolidayKey(getLeyningKeyForEvent(ev, il) + ' (Mincha)', ev.cholHaMoedDay, il);
+    if (readingMincha) {
+        const minchaEv = new Event(ev.getDate(), minchaDesc1, flags.USER_EVENT);
+        writeCsvLines(stream, minchaEv, readingMincha, il, false);
+    }
+}
+/**
+ * Formats reading for CSV
+ */
+function writeCsvLines(stream, ev, reading, il, isParsha) {
+    const parsha = isParsha
+        ? ev.basename()
+        : getLeyningKeyForEvent(ev, il) || ev.render();
+    const date = fmtDate(ev.getDate().greg());
+    const lines = getFullKriyahLines(reading);
+    for (const s of lines) {
+        const code = s[0].charCodeAt(0);
+        if (code < 48 || code > 57) {
+            s[0] = `"${s[0]}"`;
+        }
+        stream.write(`${date},"${parsha}",${s[0]},"${s[1]}",${s[2]}\r\n`);
+    }
+    stream.write('\r\n');
+}
+function getFullKriyahLines(reading) {
+    var _a, _b, _c;
+    const lines = [];
+    if (reading.fullkriyah) {
+        for (const [num, a] of Object.entries(reading.fullkriyah)) {
+            if (typeof a !== 'undefined') {
+                const k = num === 'M' ? 'maf' : num;
+                let aliyah = formatAliyahWithBook(a);
+                if ((_a = reading.reason) === null || _a === void 0 ? void 0 : _a[num]) {
+                    aliyah += ' | ' + reading.reason[num];
+                }
+                lines.push([k, aliyah, a.v || '']);
+            }
+        }
+    }
+    if (reading.haftara) {
+        let haftara = reading.haftara.replace(/,/g, ';');
+        if ((_b = reading.reason) === null || _b === void 0 ? void 0 : _b.haftara) {
+            haftara += ' | ' + reading.reason.haftara;
+        }
+        const title = reading.sephardic ? 'Haftara for Ashkenazim' : 'Haftara';
+        lines.push([title, haftara, reading.haftaraNumV || '']);
+    }
+    if (reading.sephardic) {
+        let sephardic = reading.sephardic.replace(/,/g, ';');
+        if ((_c = reading.reason) === null || _c === void 0 ? void 0 : _c.sephardic) {
+            sephardic += ' | ' + reading.reason.sephardic;
+        }
+        lines.push([
+            'Haftara for Sephardim',
+            sephardic,
+            reading.sephardicNumV || '',
+        ]);
+    }
+    if (reading.triHaftara) {
+        const haftara = reading.triHaftara.replace(/,/g, ';');
+        lines.push(['Alternate Haftara', haftara, reading.triHaftaraNumV || '']);
+    }
+    if (reading.megillah) {
+        for (const [num, a] of Object.entries(reading.megillah)) {
+            if (typeof a !== 'undefined') {
+                const aliyah = formatAliyahWithBook(a);
+                lines.push([`Megillah Ch. ${num}`, aliyah, a.v || '']);
+            }
+        }
+    }
+    return lines;
+}
+
+export { getParshaDates, writeCsvLines, writeFullKriyahCsv, writeFullKriyahEvent, writeHolidayMincha };

package/dist/esm/festival.d.ts

@@ -0,0 +1,9 @@
+import { JsonFestivalLeyning } from './internalTypes';
+/**
+ * Is there a special festival Torah Reading for `holiday`?
+ */
+export declare function hasFestival(holiday: string): boolean;
+/**
+ * Returns the raw metadata for festival reading for `holiday`
+ */
+export declare function lookupFestival(holiday: string): JsonFestivalLeyning | undefined;

package/dist/esm/festival.js

@@ -0,0 +1,42 @@
+/*! @hebcal/leyning v9.0.1 */
+import { BOOK } from './common.js';
+import { clone } from './clone.js';
+import festivals0 from './holiday-readings.json.js';
+
+const festivals = festivals0;
+/**
+ * Is there a special festival Torah Reading for `holiday`?
+ */
+function hasFestival(holiday) {
+    return typeof festivals[holiday] === 'object';
+}
+/**
+ * Returns the raw metadata for festival reading for `holiday`
+ */
+function lookupFestival(holiday) {
+    let src = festivals[holiday];
+    if (typeof src === 'undefined') {
+        return undefined;
+    }
+    if (src.alias) {
+        const tmp = festivals[src.key];
+        if (typeof tmp === 'undefined') {
+            throw new Error(`Leyning alias ${holiday} => ${src.key} not found`);
+        }
+        src = tmp;
+    }
+    const result = src.fullkriyah ? clone(src) : src;
+    if (result.fullkriyah) {
+        for (const aliyah of Object.values(result.fullkriyah)) {
+            if (typeof aliyah.k === 'number') {
+                aliyah.k = BOOK[aliyah.k];
+            }
+        }
+    }
+    if (src.note) {
+        result.note = src.note;
+    }
+    return result;
+}
+
+export { hasFestival, lookupFestival };

package/dist/esm/getLeyningForHoliday.d.ts

@@ -0,0 +1,17 @@
+import { Event } from '@hebcal/core/dist/esm/event';
+import { Leyning } from './types';
+/**
+ * Looks up leyning for a given holiday key. Key should be an
+ * (untranslated) string used in holiday-readings.json. Returns some
+ * of full kriyah aliyot, special Maftir, special Haftarah
+ * @param key name from `holiday-readings.json` to find
+ */
+export declare function getLeyningForHolidayKey(key?: string, cholHaMoedDay?: number, il?: boolean): Leyning | undefined;
+/**
+ * Looks up leyning for a given holiday. Returns some
+ * of full kriyah aliyot, special Maftir, special Haftarah
+ * @param ev the Hebcal event associated with this leyning
+ * @param [il] true if Israel holiday scheme
+ * @returns map of aliyot
+ */
+export declare function getLeyningForHoliday(ev: Event, il?: boolean): Leyning | undefined;

package/dist/esm/getLeyningForHoliday.js

@@ -0,0 +1,106 @@
+/*! @hebcal/leyning v9.0.1 */
+import { flags } from '@hebcal/core/dist/esm/event';
+import './locale.js';
+import { calculateNumVerses, NUM_VERSES } from './common.js';
+import { clone, cloneHaftara, sumVerses } from './clone.js';
+import { lookupFestival } from './festival.js';
+import { HOLIDAY_IGNORE_MASK, getLeyningKeyForEvent } from './getLeyningKeyForEvent.js';
+import { makeLeyningParts, makeSummaryFromParts } from './summary.js';
+import { Locale } from '@hebcal/core/dist/esm/locale';
+
+/**
+ * Looks up leyning for a given holiday key. Key should be an
+ * (untranslated) string used in holiday-readings.json. Returns some
+ * of full kriyah aliyot, special Maftir, special Haftarah
+ * @param key name from `holiday-readings.json` to find
+ */
+function getLeyningForHolidayKey(key, cholHaMoedDay, il) {
+    if (typeof key !== 'string') {
+        return undefined;
+    }
+    const src = lookupFestival(key);
+    if (typeof src === 'undefined') {
+        return undefined;
+    }
+    const israelOnly = src.il;
+    if (typeof israelOnly === 'boolean' &&
+        typeof il === 'boolean' &&
+        il !== israelOnly) {
+        return undefined;
+    }
+    const leyning = {
+        name: {
+            en: key,
+            he: Locale.lookupTranslation(key, 'he'),
+        },
+    };
+    if (src.fullkriyah) {
+        leyning.fullkriyah = clone(src.fullkriyah);
+        if (key === 'Sukkot Shabbat Chol ha-Moed' && cholHaMoedDay) {
+            leyning.fullkriyah['M'] = leyning.fullkriyah[`M-day${cholHaMoedDay}`];
+            for (let day = 1; day <= 5; day++) {
+                delete leyning.fullkriyah[`M-day${day}`];
+            }
+        }
+        if (typeof leyning.fullkriyah['1'] === 'object') {
+            const parts = makeLeyningParts(leyning.fullkriyah);
+            leyning.summary = makeSummaryFromParts(parts);
+            if (parts.length > 1) {
+                leyning.summaryParts = parts;
+            }
+        }
+        Object.values(leyning.fullkriyah).map(aliyah => calculateNumVerses(aliyah));
+    }
+    if (src.haft) {
+        const haft = (leyning.haft = cloneHaftara(src.haft));
+        leyning.haftara = makeSummaryFromParts(haft);
+        leyning.haftaraNumV = sumVerses(haft);
+    }
+    if (src.seph) {
+        const seph = (leyning.seph = cloneHaftara(src.seph));
+        leyning.sephardic = makeSummaryFromParts(seph);
+        leyning.sephardicNumV = sumVerses(seph);
+    }
+    let megillah = src.megillah;
+    if (il && key === 'Pesach I (on Shabbat)')
+        megillah = 'Song of Songs';
+    if (megillah) {
+        const chaps = NUM_VERSES[megillah];
+        const m = {};
+        for (let i = 1; i < chaps.length; i++) {
+            const numv = chaps[i];
+            m[`${i}`] = { k: megillah, b: `${i}:1`, e: `${i}:${numv}`, v: numv };
+        }
+        leyning.megillah = m;
+    }
+    if (src.note) {
+        leyning.note = src.note;
+    }
+    return leyning;
+}
+/**
+ * Looks up leyning for a given holiday. Returns some
+ * of full kriyah aliyot, special Maftir, special Haftarah
+ * @param ev the Hebcal event associated with this leyning
+ * @param [il] true if Israel holiday scheme
+ * @returns map of aliyot
+ */
+function getLeyningForHoliday(ev, il = false) {
+    if (typeof ev !== 'object' || typeof ev.getFlags !== 'function') {
+        throw new TypeError(`Bad event argument: ${JSON.stringify(ev)}`);
+    }
+    else if (typeof ev.eventTime !== 'undefined') {
+        return undefined;
+    }
+    else if (ev.getFlags() & flags.PARSHA_HASHAVUA) {
+        throw new TypeError(`Event should be a holiday: ${ev.getDesc()}`);
+    }
+    else if (ev.getFlags() & HOLIDAY_IGNORE_MASK) {
+        return undefined;
+    }
+    const key = getLeyningKeyForEvent(ev, il);
+    const leyning = getLeyningForHolidayKey(key, ev.cholHaMoedDay, il);
+    return leyning;
+}
+
+export { getLeyningForHoliday, getLeyningForHolidayKey };

package/dist/esm/getLeyningKeyForEvent.d.ts

@@ -0,0 +1,9 @@
+import { Event } from '@hebcal/core/dist/esm/event';
+export declare const HOLIDAY_IGNORE_MASK: number;
+/**
+ * Based on the event date, type and title, finds the relevant leyning key
+ * @param ev event
+ * @param [il] true if Israel holiday scheme
+ * @returns key to look up in holiday-reading.json
+ */
+export declare function getLeyningKeyForEvent(ev: Event, il?: boolean): string | undefined;

package/dist/esm/getLeyningKeyForEvent.js

@@ -0,0 +1,141 @@
+/*! @hebcal/leyning v9.0.1 */
+import { months, HDate } from '@hebcal/hdate';
+import { flags } from '@hebcal/core/dist/esm/event';
+import { hasFestival } from './festival.js';
+
+const HOLIDAY_IGNORE_MASK = flags.DAF_YOMI |
+    flags.OMER_COUNT |
+    flags.SHABBAT_MEVARCHIM |
+    flags.MOLAD |
+    flags.USER_EVENT |
+    flags.HEBREW_DATE |
+    flags.MISHNA_YOMI |
+    flags.MODERN_HOLIDAY |
+    flags.YERUSHALMI_YOMI;
+/**
+ * Based on the event date, type and title, finds the relevant leyning key
+ * @param ev event
+ * @param [il] true if Israel holiday scheme
+ * @returns key to look up in holiday-reading.json
+ */
+function getLeyningKeyForEvent(ev, il = false) {
+    if (typeof ev.eventTime !== 'undefined') {
+        return undefined;
+    }
+    const mask = ev.getFlags();
+    if (mask & HOLIDAY_IGNORE_MASK) {
+        return undefined;
+    }
+    // Skip all Erevs except for Simchat Torah
+    const desc = ev.getDesc();
+    if (mask & flags.EREV && !hasFestival(desc)) {
+        return undefined;
+    }
+    const hd = ev.getDate();
+    const day = hd.getDate();
+    const dow = hd.abs() % 7;
+    const month = hd.getMonth();
+    const isShabbat = dow === 6;
+    const isRoshChodesh = day === 1 || day === 30;
+    const holiday = ev.basename();
+    const isPesach = holiday === 'Pesach';
+    if (il && isPesach) {
+        if (isShabbat) {
+            return day === 15 || day === 21
+                ? desc + ' (on Shabbat)'
+                : 'Pesach Shabbat Chol ha-Moed';
+        }
+        return desc;
+    }
+    if (day === 1 && month === months.TISHREI) {
+        return isShabbat ? 'Rosh Hashana I (on Shabbat)' : 'Rosh Hashana I';
+    }
+    const cholHaMoedDay = ev.cholHaMoedDay;
+    if (typeof cholHaMoedDay === 'number') {
+        // Sukkot or Pesach
+        if (isShabbat) {
+            return holiday + ' Shabbat Chol ha-Moed';
+        }
+        else if (desc === 'Sukkot VII (Hoshana Raba)') {
+            return 'Sukkot Final Day (Hoshana Raba)';
+        }
+        if (isPesach && cholHaMoedDay) {
+            if (dow === 0 && desc === "Pesach IV (CH''M)") {
+                return 'Pesach Chol ha-Moed Day 2 on Sunday';
+            }
+            else if (dow === 1 && desc === "Pesach V (CH''M)") {
+                return 'Pesach Chol ha-Moed Day 3 on Monday';
+            }
+        }
+        return `${holiday} Chol ha-Moed Day ${cholHaMoedDay}`;
+    }
+    const chanukahDay = ev.chanukahDay;
+    if (typeof chanukahDay === 'number') {
+        if (isShabbat && isRoshChodesh) {
+            return 'Shabbat Rosh Chodesh Chanukah';
+        }
+        else if (isRoshChodesh && chanukahDay === 7) {
+            return 'Chanukah Day 7 (on Rosh Chodesh)';
+        }
+        else if (isShabbat) {
+            return `Chanukah Day ${chanukahDay} (on Shabbat)`;
+        }
+        else {
+            return `Chanukah Day ${chanukahDay}`;
+        }
+    }
+    if (isRoshChodesh &&
+        (desc === 'Shabbat HaChodesh' || desc === 'Shabbat Shekalim')) {
+        return desc + ' (on Rosh Chodesh)';
+    }
+    if (il && desc === 'Shmini Atzeret') {
+        return 'Simchat Torah' + (isShabbat ? ' (on Shabbat)' : '');
+    }
+    if (desc === 'Chag HaBanot') {
+        return undefined;
+    }
+    if (isShabbat && 'Shabbat' !== desc.substring(0, 7)) {
+        if (isRoshChodesh) {
+            if (desc === 'Rosh Chodesh Tevet') {
+                return 'Shabbat Rosh Chodesh Chanukah';
+            }
+            return 'Shabbat Rosh Chodesh';
+        }
+        const desc2 = desc + ' (on Shabbat)';
+        if (hasFestival(desc2)) {
+            return desc2;
+        }
+    }
+    if (hasFestival(desc)) {
+        return desc;
+    }
+    if (isShabbat) {
+        const tommorow = hd.next().getDate();
+        if (tommorow === 30 || tommorow === 1) {
+            return 'Shabbat Machar Chodesh';
+        }
+    }
+    if (desc === 'Rosh Hashana LaBehemot') {
+        return undefined;
+    }
+    if (desc === 'Rosh Chodesh Tevet') {
+        if (isShabbat) {
+            return 'Shabbat Rosh Chodesh Chanukah';
+        }
+        if (day === 30 || HDate.shortKislev(hd.getFullYear())) {
+            return 'Chanukah Day 6'; // 30th of Kislev or 1st of Tevet
+        }
+        else {
+            return 'Chanukah Day 7 (on Rosh Chodesh)'; // 1st of Tevet
+        }
+    }
+    if (isRoshChodesh) {
+        return desc;
+    }
+    if (desc === "Tish'a B'Av (observed)") {
+        return "Tish'a B'Av";
+    }
+    return undefined;
+}
+
+export { HOLIDAY_IGNORE_MASK, getLeyningKeyForEvent };

package/dist/esm/getLeyningOnDate.d.ts

@@ -0,0 +1,21 @@
+import { HDate } from '@hebcal/hdate';
+import { Leyning, LeyningWeekday } from './types';
+/**
+ * Looks up leyning for a regular Shabbat, Monday/Thursday weekday or holiday.
+ *
+ * If `hdate` coincides with a holiday that has Torah reading, returns the
+ * reading for that day (see {@link getLeyningForHoliday})
+ *
+ * Otherwise, if `hdate` is a Saturday, returns {@link getLeyningForParshaHaShavua}
+ *
+ * Otherwise, if `hdate` is a Monday or Thursday, returns {@link Leyning} for the
+ * Parashat haShavua, containing only the `weekday` aliyot (no `fullkriyah`).
+ *
+ * Otherwise, returns `undefined`.
+ *
+ * @param {HDate} hdate Hebrew Date
+ * @param {boolean} il in Israel
+ * @param {boolean} [wantarray] to return an array of 0 or more readings
+ */
+export declare function getLeyningOnDate(hdate: HDate, il: boolean, wantarray?: false): Leyning | LeyningWeekday | undefined;
+export declare function getLeyningOnDate(hdate: HDate, il: boolean, wantarray: true): (Leyning | LeyningWeekday)[];