jcal-zmanim 1.0.4

package/build/JCal/Dafyomi.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Utils_js_1 = __importDefault(require("./Utils.js"));
+const jDate_js_1 = __importDefault(require("./jDate.js"));
+'use strict';
+/** *********************************************************************************************************
+ * Computes the Day Yomi for the given day.
+ * Sample of use - to get todays daf:
+ *     const dafEng = Dafyomi.toString(new jDate(new Date()));
+ *     const dafHeb = Dafyomi.toStringHeb(new jDate(new Date()));
+ * The code was converted to javascript and tweaked by CBS.
+ * It is directly based on the C code in Danny Sadinoff's HebCal - Copyright (C) 1994.
+ * The HebCal code for dafyomi was adapted by Aaron Peromsik from Bob Newell's public domain daf.el.
+***********************************************************************************************************/
+class Dafyomi {
+    static getDaf(jdate) {
+        const absoluteDate = jdate.Abs;
+        let dafcnt = 40, cno, dno, osday, nsday, total, count, j, blatt;
+        osday = jDate_js_1.default.absSd(new Date(1923, 8, 11));
+        nsday = jDate_js_1.default.absSd(new Date(1975, 5, 24));
+        /*  No cycle, new cycle, old cycle */
+        if (absoluteDate < osday)
+            return null; /* daf yomi hadn't started yet */
+        if (absoluteDate >= nsday) {
+            cno = 8 + Utils_js_1.default.toInt(((absoluteDate - nsday) / 2711));
+            dno = (absoluteDate - nsday) % 2711;
+        }
+        else {
+            cno = 1 + Utils_js_1.default.toInt((absoluteDate - osday) / 2702);
+            dno = Utils_js_1.default.toInt((absoluteDate - osday) / 2702);
+        }
+        /* Find the daf taking note that the cycle changed slightly after cycle 7. */
+        total = blatt = 0;
+        count = -1;
+        /* Fix Shekalim for old cycles */
+        if (cno <= 7)
+            Dafyomi.masechtaList[4].daf = 13;
+        else
+            Dafyomi.masechtaList[4].daf = 22;
+        /* Find the daf */
+        j = 0;
+        while (j < dafcnt) {
+            count++;
+            total = total + Dafyomi.masechtaList[j].daf - 1;
+            if (dno < total) {
+                blatt = (Dafyomi.masechtaList[j].daf + 1) - (total - dno);
+                /* fiddle with the weird ones near the end */
+                switch (count) {
+                    case 36:
+                        blatt = blatt + 21;
+                        break;
+                    case 37:
+                        blatt = blatt + 24;
+                        break;
+                    case 38:
+                        blatt = blatt + 33;
+                        break;
+                    default:
+                        break;
+                }
+                /* Bailout */
+                j = 1 + dafcnt;
+            }
+            j++;
+        }
+        return {
+            masechet: Dafyomi.masechtaList[count],
+            daf: blatt
+        };
+    }
+    // Returns the name of the Masechta and daf number in English, For example: Sukkah, Daf 3
+    static toString(jd) {
+        const d = Dafyomi.getDaf(jd);
+        if (d !== null) {
+            return d.masechet.eng + ', Daf ' + d.daf.toString();
+        }
+    }
+    //Returns the name of the Masechta and daf number in Hebrew. For example: 'סוכה דף כ.
+    static toStringHeb(jd) {
+        const d = Dafyomi.getDaf(jd);
+        if (d !== null) {
+            return d.masechet.heb + ' דף ' + Utils_js_1.default.toJNum(d.daf);
+        }
+    }
+}
+Dafyomi.masechtaList = [
+    { eng: 'Berachos', heb: 'ברכות', daf: 64 },
+    { eng: 'Shabbos', heb: 'שבת', daf: 157 },
+    { eng: 'Eruvin', heb: 'ערובין', daf: 105 },
+    { eng: 'Pesachim', heb: 'פסחים', daf: 121 },
+    { eng: 'Shekalim', heb: 'שקלים', daf: 22 },
+    { eng: 'Yoma', heb: 'יומא', daf: 88 },
+    { eng: 'Sukkah', heb: 'סוכה', daf: 56 },
+    { eng: 'Beitzah', heb: 'ביצה', daf: 40 },
+    { eng: 'Rosh Hashana', heb: 'ראש השנה', daf: 35 },
+    { eng: 'Taanis', heb: 'תענית', daf: 31 },
+    { eng: 'Megillah', heb: 'מגילה', daf: 32 },
+    { eng: 'Moed Katan', heb: 'מועד קטן', daf: 29 },
+    { eng: 'Chagigah', heb: 'חגיגה', daf: 27 },
+    { eng: 'Yevamos', heb: 'יבמות', daf: 122 },
+    { eng: 'Kesubos', heb: 'כתובות', daf: 112 },
+    { eng: 'Nedarim', heb: 'נדרים', daf: 91 },
+    { eng: 'Nazir', heb: 'נזיר', daf: 66 },
+    { eng: 'Sotah', heb: 'סוטה', daf: 49 },
+    { eng: 'Gitin', heb: 'גיטין', daf: 90 },
+    { eng: 'Kiddushin', heb: 'קדושין', daf: 82 },
+    { eng: 'Baba Kamma', heb: 'בבא קמא', daf: 119 },
+    { eng: 'Baba Metzia', heb: 'בבא מציעא', daf: 119 },
+    { eng: 'Baba Basra', heb: 'בבא בתרא', daf: 176 },
+    { eng: 'Sanhedrin', heb: 'סנהדרין', daf: 113 },
+    { eng: 'Makkot', heb: 'מכות', daf: 24 },
+    { eng: 'Shevuot', heb: 'שבועות', daf: 49 },
+    { eng: 'Avodah Zarah', heb: 'עבודה זרה', daf: 76 },
+    { eng: 'Horayot', heb: 'הוריות', daf: 14 },
+    { eng: 'Zevachim', heb: 'זבחים', daf: 120 },
+    { eng: 'Menachos', heb: 'מנחות', daf: 110 },
+    { eng: 'Chullin', heb: 'חולין', daf: 142 },
+    { eng: 'Bechoros', heb: 'בכורות', daf: 61 },
+    { eng: 'Arachin', heb: 'ערכין', daf: 34 },
+    { eng: 'Temurah', heb: 'תמורה', daf: 34 },
+    { eng: 'Kerisos', heb: 'כריתות', daf: 28 },
+    { eng: 'Meilah', heb: 'מעילה', daf: 22 },
+    { eng: 'Kinnim', heb: 'קנים', daf: 4 },
+    { eng: 'Tamid', heb: 'תמיד', daf: 10 },
+    { eng: 'Midos', heb: 'מדות', daf: 4 },
+    { eng: 'Niddah', heb: 'נדה', daf: 73 }
+];
+exports.default = Dafyomi;

package/build/JCal/Location.d.ts

@@ -0,0 +1,33 @@
+/** Represents a geographic Location. Needed for calculating Zmanim.
+If Israel is undefined, if the given coordinates are near the vicinity of Israel it will be assumed that it is in Israel.
+UTCOffset is the time zone. Israel is always 2 and the US East coast is -5. England is 0 of course.
+If UTCOffset is not specifically supplied, the longitude will be used to get a quasi-educated guess.*/
+export default class Location {
+    Name: string;
+    Israel: boolean;
+    Latitude: number;
+    Longitude: number;
+    UTCOffset: number;
+    Elevation: number;
+    CandleLighting?: number;
+    locationId?: number;
+    /**
+     * Describe a new Location.
+     * @param {String} name The name of the Location
+     * @param {Boolean} israel Is this Location in Israel?
+     * @param {Number} latitude
+     * @param {Number} longitude
+     * @param {Number} utcOffset The time zone. Israel is 2 and New York is -5.
+     * @param {Number} elevation Elevation in meters
+     * @param {Number} [candleLighting] Number of minutes before sunset the candles are lit on Friday
+     * @param {Number} [locationId] If this location is in a database, keeps track of the id
+     */
+    constructor(name: string, israel: boolean, latitude: number, longitude: number, utcOffset: number, elevation: number, candleLighting?: number, locationId?: number);
+    hasId(): boolean;
+    static clone(location: Location): Location;
+    static getCandles(location: Location): number;
+    /**Gets the Location for Jerusalem.*/
+    static getJerusalem(): Location;
+    /**Gets the Location for Lakewood NJ*/
+    static getLakewood(): Location;
+}

package/build/JCal/Location.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/** Represents a geographic Location. Needed for calculating Zmanim.
+If Israel is undefined, if the given coordinates are near the vicinity of Israel it will be assumed that it is in Israel.
+UTCOffset is the time zone. Israel is always 2 and the US East coast is -5. England is 0 of course.
+If UTCOffset is not specifically supplied, the longitude will be used to get a quasi-educated guess.*/
+class Location {
+    /**
+     * Describe a new Location.
+     * @param {String} name The name of the Location
+     * @param {Boolean} israel Is this Location in Israel?
+     * @param {Number} latitude
+     * @param {Number} longitude
+     * @param {Number} utcOffset The time zone. Israel is 2 and New York is -5.
+     * @param {Number} elevation Elevation in meters
+     * @param {Number} [candleLighting] Number of minutes before sunset the candles are lit on Friday
+     * @param {Number} [locationId] If this location is in a database, keeps track of the id
+     */
+    constructor(name, israel, latitude, longitude, utcOffset, elevation, candleLighting, locationId) {
+        //If the israel argument was not set at all.
+        if (typeof israel === 'undefined' || israel === null) {
+            //If the user is within Israels general coordinates,
+            //we feel pretty safe assuming they are in Israel.
+            //Where else on the map is the user? (Note, the probablity of our users Jewishness: 99.99%)
+            //Sinai, Lebanon, Syria, Jordan, in a submarine under the Mediterannian ...
+            israel = (latitude > 29.45 && latitude < 33 && longitude < -34.23 && longitude > -35.9);
+        }
+        if (israel) {
+            //Israel has only one immutable time zone
+            utcOffset = 2;
+        }
+        //If the utcOffset argument was not set at all.
+        else if (typeof utcOffset === 'undefined' || utcOffset === null) {
+            //Try to determine the "correct" time zone using the simple fact that Greenwich is both TZ 0 and longitude 0.
+            //Even though technically this is the way it should be,
+            //it will be often incorrect as time zones are almost always tweaked to accomadate the closest border.
+            utcOffset = -Math.round(longitude / 15);
+        }
+        this.Name = (name || 'Unknown Location');
+        this.Israel = !!israel;
+        this.Latitude = latitude;
+        this.Longitude = longitude;
+        this.UTCOffset = utcOffset || 0;
+        this.Elevation = elevation || 0;
+        this.CandleLighting = candleLighting || Location.getCandles(this);
+        this.locationId = locationId;
+    }
+    hasId() {
+        return !!this.locationId;
+    }
+    static clone(location) {
+        return new Location(location.Name, location.Israel, location.Latitude, location.Longitude, location.UTCOffset, location.Elevation, location.CandleLighting || 0, location.locationId || 0);
+    }
+    static getCandles(location) {
+        if (location.CandleLighting) {
+            return location.CandleLighting;
+        }
+        else if (!location.Israel) {
+            return 18;
+        }
+        else {
+            const special = [{ names: ['jerusalem', 'yerush', 'petach', 'petah', 'petak', 'beit shemesh', 'ירושלים', 'פתח תקוה', 'בית שמש'], min: 40 },
+                { names: ['haifa', 'chaifa', 'be\'er sheva', 'beersheba', 'חיפה', 'באר שבע'], min: 22 }], loclc = location.Name.toLowerCase(), city = special.find(sp => {
+                return sp.names.find(spi => {
+                    return loclc.indexOf(spi) > -1;
+                });
+            });
+            return city ? city.min : 30;
+        }
+    }
+    /**Gets the Location for Jerusalem.*/
+    static getJerusalem() {
+        return new Location('Jerusalem', true, 31.78, -35.22, 2, 800, 40, 28);
+    }
+    /**Gets the Location for Lakewood NJ*/
+    static getLakewood() {
+        return new Location('Lakewood NJ', false, 40.1, 74.23, -5, 0, 18, 185);
+    }
+}
+exports.default = Location;

package/build/JCal/Molad.d.ts

@@ -0,0 +1,39 @@
+import jDate from './jDate.js';
+import { Time } from '../jcal-zmanim.js';
+/**
+ * Gets the molad for the given jewish month and year.
+ * Algorithm was adapted from Hebcal by Danny Sadinoff
+ *
+ * Example of use:
+ * const moladString = Molad.getString(5776, 10);
+ */
+export default class Molad {
+    /**
+     *
+     * @param {Number} month
+     * @param {Number} year
+     * @returns {{jDate:jDate,time:Time,chalakim:number}}
+     */
+    static getMolad(month: number, year: number): {
+        jDate: jDate;
+        time: Time;
+        chalakim: number;
+    };
+    /**
+     * Returns the time of the molad as a string in the format: Monday Night, 8:33 PM and 12 Chalakim
+     * The molad is always in Jerusalem so we use the Jerusalem sunset times
+     * to determine whether to display "Night" or "Motzai Shabbos" etc. (check this...)
+     * @param {Number} year
+     * @param {Number} month
+     */
+    static getString(year: number, month: number): string;
+    time(sunset: any, time: any): void;
+    /**
+     * Returns the time of the molad as a string in the format: ליל שני 20:33 12 חלקים
+     * The molad is always in Jerusalem so we use the Jerusalem sunset times
+     * to determine whether to display "ליל/יום" or "מוצאי שב"ק" etc.
+     * @param {Number} year
+     * @param {Number} month
+     */
+    static getStringHeb(year: number, month: number): string;
+}

package/build/JCal/Molad.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Utils_js_1 = __importDefault(require("./Utils.js"));
+const jDate_js_1 = __importDefault(require("./jDate.js"));
+const Location_js_1 = __importDefault(require("./Location.js"));
+/**
+ * Gets the molad for the given jewish month and year.
+ * Algorithm was adapted from Hebcal by Danny Sadinoff
+ *
+ * Example of use:
+ * const moladString = Molad.getString(5776, 10);
+ */
+class Molad {
+    /**
+     *
+     * @param {Number} month
+     * @param {Number} year
+     * @returns {{jDate:jDate,time:Time,chalakim:number}}
+     */
+    static getMolad(month, year) {
+        let totalMonths, partsElapsed, hoursElapsed, parts, monthAdj = month - 7;
+        if (monthAdj < 0) {
+            monthAdj += jDate_js_1.default.monthsJYear(year);
+        }
+        totalMonths = Utils_js_1.default.toInt(monthAdj + 235 * Utils_js_1.default.toInt((year - 1) / 19) + 12 * ((year - 1) % 19) +
+            ((((year - 1) % 19) * 7) + 1) / 19);
+        partsElapsed = 204 + (793 * (totalMonths % 1080));
+        hoursElapsed = 5 + (12 * totalMonths) + 793 * Utils_js_1.default.toInt(totalMonths / 1080) +
+            Utils_js_1.default.toInt(partsElapsed / 1080) - 6;
+        parts = Utils_js_1.default.toInt((partsElapsed % 1080) + 1080 * (hoursElapsed % 24));
+        return {
+            jDate: new jDate_js_1.default((1 + (29 * Utils_js_1.default.toInt(totalMonths))) + Utils_js_1.default.toInt((hoursElapsed / 24))),
+            time: { hour: Utils_js_1.default.toInt(hoursElapsed) % 24, minute: Utils_js_1.default.toInt((parts % 1080) / 18), second: 0 },
+            chalakim: parts % 18
+        };
+    }
+    /**
+     * Returns the time of the molad as a string in the format: Monday Night, 8:33 PM and 12 Chalakim
+     * The molad is always in Jerusalem so we use the Jerusalem sunset times
+     * to determine whether to display "Night" or "Motzai Shabbos" etc. (check this...)
+     * @param {Number} year
+     * @param {Number} month
+     */
+    static getString(year, month) {
+        const molad = Molad.getMolad(month, year), zmanim = molad.jDate.getSunriseSunset(Location_js_1.default.getJerusalem()), isNight = Utils_js_1.default.isTimeAfter(zmanim.sunset, molad.time), dow = molad.jDate.getDayOfWeek();
+        let str = '';
+        if (!zmanim.sunset || isNaN(zmanim.sunset.hour)) {
+            str += Utils_js_1.default.dowEng[dow];
+        }
+        else if (dow === 6 && isNight) {
+            str += 'Motzai Shabbos,';
+        }
+        else if (dow === 5 && isNight) {
+            str += 'Shabbos Night,';
+        }
+        else {
+            str += Utils_js_1.default.dowEng[dow] + (isNight ? ' Night' : '');
+        }
+        str += ' ' + Utils_js_1.default.getTimeString(molad.time) + ' and ' +
+            molad.chalakim.toString() + ' Chalakim';
+        return str;
+    }
+    time(sunset, time) {
+        throw new Error('Method not implemented.');
+    }
+    /**
+     * Returns the time of the molad as a string in the format: ליל שני 20:33 12 חלקים
+     * The molad is always in Jerusalem so we use the Jerusalem sunset times
+     * to determine whether to display "ליל/יום" or "מוצאי שב"ק" etc.
+     * @param {Number} year
+     * @param {Number} month
+     */
+    static getStringHeb(year, month) {
+        const molad = Molad.getMolad(month, year), zmanim = molad.jDate.getSunriseSunset(Location_js_1.default.getJerusalem()), isNight = Utils_js_1.default.isTimeAfter(zmanim.sunset, molad.time) &&
+            Utils_js_1.default.isTimeAfter(molad.time, zmanim.sunrise), dow = molad.jDate.getDayOfWeek();
+        let str = '';
+        if (dow === 6) {
+            str += (isNight ? 'מוצאי שב"ק' : 'יום שב"ק');
+        }
+        else if (dow === 5) {
+            str += (isNight ? 'ליל שב"ק' : 'ערב שב"ק');
+        }
+        else {
+            str += (isNight ? 'ליל' : 'יום') +
+                Utils_js_1.default.dowHeb[dow].replace('יום', '');
+        }
+        str += ' ' + Utils_js_1.default.getTimeString(molad.time, 1, true) + ' ' +
+            molad.chalakim.toString() + ' חלקים';
+        return str;
+    }
+}
+exports.default = Molad;

package/build/JCal/PirkeiAvos.d.ts

@@ -0,0 +1,13 @@
+import jDate from './jDate.js';
+/****************************************************************************************************************
+ * Computes the Perek/Prakim of the week for the given Shabbos.
+ * Returns an array of prakim (integers) (either one or two) for the given Jewish Date
+ * Sample of use to get todays sedra in Israel:
+ *     const prakim = PirkeiAvos.getPrakim(new jDate(), true);
+ *     const str = 'Pirkei Avos: ' + prakim.map(s => `${Utils.toSuffixed(s)} Perek`).join(' and ');
+ * ***************************************************************************************************************/
+export default class PirkeiAvos {
+    static getPrakim(jd: jDate, israel: boolean): number[];
+    static _get1stPerek: (jd: jDate, israel: boolean) => number;
+    static _ellul: (jd: jDate, israel: boolean) => number[];
+}

package/build/JCal/PirkeiAvos.js

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const jDate_js_1 = __importDefault(require("./jDate.js"));
+const Utils_js_1 = __importDefault(require("./Utils.js"));
+'use strict';
+/****************************************************************************************************************
+ * Computes the Perek/Prakim of the week for the given Shabbos.
+ * Returns an array of prakim (integers) (either one or two) for the given Jewish Date
+ * Sample of use to get todays sedra in Israel:
+ *     const prakim = PirkeiAvos.getPrakim(new jDate(), true);
+ *     const str = 'Pirkei Avos: ' + prakim.map(s => `${Utils.toSuffixed(s)} Perek`).join(' and ');
+ * ***************************************************************************************************************/
+class PirkeiAvos {
+    static getPrakim(jd, israel) {
+        if (jd.getDayOfWeek() !== 6) {
+            return [];
+        }
+        const jMonth = jd.Month, jDay = jd.Day;
+        //Pirkei Avos is from after Pesach until Rosh Hashana
+        if ((jMonth === 1 && jDay > (israel ? 21 : 22)) ||
+            //All Shabbosim through Iyar, Sivan, Tamuz, Av - besides for the day/s of Shavuos and Tisha B'Av
+            ((jMonth > 1 && jMonth < 6 &&
+                (!((jMonth === 3 && jDay === 6) || (!israel && jMonth === 3 && jDay === 7))) &&
+                (!(jMonth === 5 && jDay === 9))))) {
+            return [PirkeiAvos._get1stPerek(jd, israel)];
+        }
+        //Ellul can have multiple prakim
+        else if (jMonth === 6) {
+            return PirkeiAvos._ellul(jd, israel);
+        }
+        //No Pirkei Avos
+        else {
+            return [];
+        }
+    }
+}
+PirkeiAvos._get1stPerek = function (jd, israel) {
+    const jYear = jd.Year, jMonth = jd.Month, jDay = jd.Day, pes1 = new jDate_js_1.default(jYear, 1, 15), 
+    //How many days after the first day of pesach was the first shabbos after pesach
+    shb1 = (israel ? 7 : 8) + (6 - pes1.getDayOfWeek()), 
+    //What number shabbos after pesach is the current date
+    cShb = ((jMonth === 1 && jDay === (shb1 + 15)) ? 1 :
+        Utils_js_1.default.toInt((jd.Abs - (pes1.Abs + shb1)) / 7) + 1);
+    let prk = cShb % 6;
+    if (prk === 0)
+        prk = 6;
+    //If the second day of Shavuos was on Shabbos, we missed a week.
+    //The second day of Pesach is always the same day as the first day of Shavuos.
+    //So if Pesach was on Thursday, Shavuos will be on Friday and Shabbos in Chu"l.
+    //Pesach can never come out on Friday, so in E. Yisroel Shavuos is never on Shabbos.
+    if ((!israel) && pes1.getDayOfWeek() === 4 && (jMonth > 3 || (jMonth === 3 && jDay > 6))) {
+        prk = prk === 1 ? 6 : prk - 1;
+    }
+    //If Tisha B'Av was on Shabbos, we missed a week. The first day of Pesach is always the same day of the week as Tisha b'av.
+    if (pes1.getDayOfWeek() === 6 && (jMonth > 5 || (jMonth === 5 && jDay > 9))) {
+        prk = prk === 1 ? 6 : prk - 1;
+    }
+    return prk;
+};
+PirkeiAvos._ellul = function (jd, israel) {
+    let prakim;
+    const jYear = jd.Year, jDay = jd.Day, 
+    //The fist day of Ellul.
+    //The year/month/day/absoluteDay constructor for JDate is used for efficiency.
+    day1 = new jDate_js_1.default(jYear, 6, 1, jd.Abs - jd.Day + 1), day1DOW = day1.getDayOfWeek(), shabbos1Day = day1DOW === 6 ? 1 : ((6 - (day1DOW + 6) % 6) + 1), shabbos1Date = new jDate_js_1.default(jYear, 6, shabbos1Day, day1.Abs + shabbos1Day - 1), 
+    //Which shabbos in Ellul are we working out now?
+    cShb = jDay === shabbos1Day ? 1 : Utils_js_1.default.toInt((jDay - shabbos1Day) / 7) + 1;
+    switch (PirkeiAvos._get1stPerek(shabbos1Date, israel)) {
+        case 1:
+            switch (cShb) {
+                case 1:
+                    prakim = [1];
+                    break;
+                case 2:
+                    prakim = [2];
+                    break;
+                case 3:
+                    prakim = [3, 4];
+                    break;
+                case 4:
+                    prakim = [5, 6];
+                    break;
+            }
+            break;
+        case 2:
+            switch (cShb) {
+                case 1:
+                    prakim = [2];
+                    break;
+                case 2:
+                    prakim = [3];
+                    break;
+                case 3:
+                    prakim = [4];
+                    break;
+                case 4:
+                    prakim = [5, 6];
+                    break;
+            }
+            break;
+        case 3:
+            switch (cShb) {
+                case 1:
+                    prakim = [3];
+                    break;
+                case 2:
+                    prakim = [4];
+                    break;
+                case 3:
+                    prakim = [5];
+                    break;
+                case 4:
+                    prakim = [6];
+                    break;
+            }
+            break;
+        case 4:
+            //This can only happen in Chutz La'aretz
+            switch (cShb) {
+                case 1:
+                    prakim = [4, 5];
+                    break;
+                case 2:
+                    prakim = [6, 1];
+                    break;
+                case 3:
+                    prakim = [2, 3];
+                    break;
+                case 4:
+                    prakim = [4, 5, 6];
+                    break;
+            }
+            break;
+        case 5:
+            switch (cShb) {
+                case 1:
+                    prakim = [5, 6];
+                    break;
+                case 2:
+                    prakim = [1, 2];
+                    break;
+                case 3:
+                    prakim = [3, 4];
+                    break;
+                case 4:
+                    prakim = [5, 6];
+                    break;
+            }
+            break;
+        case 6:
+            switch (cShb) {
+                case 1:
+                    prakim = [6];
+                    break;
+                case 2:
+                    prakim = [1, 2];
+                    break;
+                case 3:
+                    prakim = [3, 4];
+                    break;
+                case 4:
+                    prakim = [5, 6];
+                    break;
+            }
+            break;
+    }
+    return prakim || [];
+};
+exports.default = PirkeiAvos;

package/build/JCal/Sedra.d.ts

@@ -0,0 +1,63 @@
+import jDate from './jDate.js';
+/**
+ * Computes the Sedra/Sedras of the week for the given day.
+ * The property "sedras" an array of sedras (either one or two) for the given Jewish Date
+ * Sample of use to get todays sedra in Israel:
+ *     const sedras = new Sedra(new jDate(new Date(), true)).toString();
+ * The code was converted to javascript and tweaked by CBS.
+ * It is directly based on the C code in Danny Sadinoff's HebCal - Copyright (C) 1994.
+ * Portions of that code are Copyright (c) 2002 Michael J. Radwin. All Rights Reserved.
+ * Many of the algorithms were taken from hebrew calendar routines implemented by Nachum Dershowitz
+ * @property sedras {[{ eng: String, heb: String }]}
+ */
+export default class Sedra {
+    sedras: {
+        eng: string;
+        heb: string;
+    }[];
+    /**
+     * @param {jDate} jd
+     * @param {boolean} israel
+     */
+    constructor(jd: jDate, israel: boolean);
+    /**
+     * Gets the sedra/s as a string. If there are two, they are seperated by a " - "
+     */
+    toString(): string;
+    /**
+     * Gets the sedra/s as a string. If there are two, they are seperated by a " - "
+     */
+    toStringHeb(): string;
+    static lastCalculatedYear: {
+        firstSatInYear: number;
+        sedraArray?: number[];
+        year: number;
+        israel: boolean;
+    } | null;
+    static sedraList: {
+        eng: string;
+        heb: string;
+    }[];
+    static shabbos_short: number[];
+    static shabbos_long: number[];
+    static mon_short: number[];
+    static mon_long: number[];
+    static thu_normal: number[];
+    static thu_normal_Israel: number[];
+    static thu_long: number[];
+    static shabbos_short_leap: number[];
+    static shabbos_long_leap: number[];
+    static mon_short_leap: number[];
+    static mon_short_leap_Israel: number[];
+    static mon_long_leap: number[];
+    static mon_long_leap_Israel: number[];
+    static thu_short_leap: number[];
+    static thu_long_leap: number[];
+    static getDayOnOrBefore(day_of_week: number, date: number): number;
+    static getSedraOrder(year: number, israel: boolean): {
+        firstSatInYear: number;
+        sedraArray?: number[] | undefined;
+        year: number;
+        israel: boolean;
+    };
+}