@hebcal/leyning 8.2.9 → 9.0.0

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.0 */
+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/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.0 */
+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.0 */
+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.0 */
+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)[];

package/dist/esm/getLeyningOnDate.js

@@ -0,0 +1,134 @@
+/*! @hebcal/leyning v9.0.0 */
+import { months, HDate } from '@hebcal/hdate';
+import { flags } from '@hebcal/core/dist/esm/event';
+import { getLeyningForHoliday, getLeyningForHolidayKey } from './getLeyningForHoliday.js';
+import { getLeyningKeyForEvent } from './getLeyningKeyForEvent.js';
+import { getLeyningForParshaHaShavua, getWeekdayReading, makeLeyningNames } from './leyning.js';
+import { makeLeyningParts, makeSummaryFromParts } from './summary.js';
+import { getSedra } from '@hebcal/core/dist/esm/sedra';
+import { getHolidaysOnDate } from '@hebcal/core/dist/esm/holidays';
+import { ParshaEvent } from '@hebcal/core/dist/esm/ParshaEvent';
+
+function findParshaHaShavua(saturday, il) {
+    const hyear = saturday.getFullYear();
+    const sedra = getSedra(hyear, il);
+    const parsha = sedra.lookup(saturday);
+    if (!parsha.chag) {
+        return parsha;
+    }
+    // Special case between YK and Simchat Torah
+    // If Vayeilech or Ha'azinu occurs between RH and YK, the following block for
+    // Monday/Thursday weekday isn't executed because the above sedra.lookup()
+    // would have already found the regular Saturday parsha.
+    if (saturday.getMonth() === months.TISHREI) {
+        const dd = saturday.getDate();
+        const simchatTorah = il ? 22 : 23;
+        if (dd > 2 && dd <= simchatTorah) {
+            return {
+                parsha: ['Vezot Haberakhah'],
+                chag: false,
+                num: 54,
+                hdate: saturday,
+            };
+        }
+    }
+    // Search for next regular parsha, which could even spill into next year
+    const endOfYear = new HDate(1, months.TISHREI, hyear + 1).abs() - 1;
+    const endAbs = endOfYear + 30;
+    for (let sat2 = saturday.abs() + 7; sat2 <= endAbs; sat2 += 7) {
+        const sedra2 = sat2 > endOfYear ? getSedra(hyear + 1, il) : sedra;
+        const parsha2 = sedra2.lookup(sat2);
+        if (!parsha2.chag) {
+            return parsha2;
+        }
+    }
+    /* NOTREACHED */
+    throw new Error(`can't findParshaHaShavua for ${saturday}/${il}`);
+}
+function getLeyningOnDate(hdate, il, wantarray = false) {
+    const dow = hdate.getDay();
+    const arr = [];
+    let hasParshaHaShavua = false;
+    if (dow === 6) {
+        const hyear = hdate.getFullYear();
+        const sedra = getSedra(hyear, il);
+        const parsha = sedra.lookup(hdate);
+        if (!parsha.chag) {
+            const parshaEvent = new ParshaEvent(hdate, parsha.parsha, il);
+            const reading = getLeyningForParshaHaShavua(parshaEvent, il);
+            if (wantarray) {
+                hasParshaHaShavua = true;
+                arr.push(reading);
+            }
+            else {
+                return reading;
+            }
+        }
+    }
+    const events = getHolidaysOnDate(hdate, il) || [];
+    let hasFullKriyah = false;
+    for (const ev of events) {
+        const specialShabbat = Boolean(ev.getFlags() & (flags.SPECIAL_SHABBAT | flags.ROSH_CHODESH));
+        if (hasParshaHaShavua && specialShabbat) {
+            continue;
+        }
+        const reading = getLeyningForHoliday(ev, il);
+        if (reading) {
+            // Skip duplicate readings from overlapping events (eg, Rosh Chodesh + Chanukah)
+            if (arr.some(r => r.name.en === reading.name.en))
+                continue;
+            const fk = reading.fullkriyah;
+            if (fk) {
+                hasFullKriyah = true;
+            }
+            const specialMaftirOnly = hasParshaHaShavua && hasFullKriyah && fk.M && !fk['1'];
+            if (!specialMaftirOnly) {
+                arr.push(reading);
+            }
+            const mincha = getMincha(ev, il);
+            if (mincha) {
+                arr.push(mincha);
+            }
+            // Special case for Erev Simchat Torah - the only time we read Torah at night
+            const desc = ev.getDesc();
+            if ((il && desc === 'Sukkot VII (Hoshana Raba)') ||
+                (!il && desc === 'Shmini Atzeret')) {
+                const erevST = getLeyningForHolidayKey('Erev Simchat Torah');
+                arr.push(erevST);
+            }
+        }
+    }
+    if (!hasFullKriyah && (dow === 1 || dow === 4)) {
+        const saturday = hdate.onOrAfter(6);
+        const parsha = findParshaHaShavua(saturday, il);
+        const aliyot = getWeekdayReading(parsha.parsha);
+        const parts = makeLeyningParts(aliyot);
+        const reading = {
+            name: makeLeyningNames(parsha.parsha),
+            parsha: parsha.parsha,
+            parshaNum: parsha.num,
+            weekday: aliyot,
+            summary: makeSummaryFromParts(parts),
+        };
+        arr.unshift(reading);
+    }
+    return wantarray ? arr : arr[0];
+}
+const minchaSuffix = ' (Mincha)';
+function getMincha(ev, il) {
+    const desc = ev.getDesc() + minchaSuffix;
+    const reading1 = getLeyningForHolidayKey(desc, ev.cholHaMoedDay, il);
+    if (reading1) {
+        return reading1;
+    }
+    const desc2 = getLeyningKeyForEvent(ev, il);
+    if (desc2) {
+        const reading2 = getLeyningForHolidayKey(desc2 + minchaSuffix, ev.cholHaMoedDay, il);
+        if (reading2) {
+            return reading2;
+        }
+    }
+    return undefined;
+}
+
+export { getLeyningOnDate };