jcal-zmanim 1.1.6 → 1.1.8

package/dist/Utils.js

@@ -1,13 +1,43 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Utils = exports.DaysOfWeekHeb = exports.DaysOfWeekEng = exports.SecularMonthsEng = exports.JewishMonthsHeb = exports.JewishMonthsEng = exports.DaysOfWeek = void 0;
-const Zmanim_1 = __importDefault(require("./JCal/Zmanim"));
-const jDate_1 = __importDefault(require("./JCal/jDate"));
-const __DEV__ = process.env.NODE_ENV === 'development';
-exports.DaysOfWeek = Object.freeze({
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import Zmanim from './JCal/Zmanim.js';
+import jDate from './JCal/jDate.js';
+var __DEV__ = process.env.NODE_ENV === 'development';
+export var DaysOfWeek = Object.freeze({
     SUNDAY: 0,
     MONDAY: 1,
     TUESDAY: 2,
@@ -16,7 +46,7 @@ exports.DaysOfWeek = Object.freeze({
     FRIDAY: 5,
     SHABBOS: 6,
 });
-exports.JewishMonthsEng = [
+export var JewishMonthsEng = [
     '',
     'Nissan',
     'Iyar',
@@ -32,7 +62,7 @@ exports.JewishMonthsEng = [
     'Adar',
     'Adar Sheini',
 ];
-exports.JewishMonthsHeb = [
+export var JewishMonthsHeb = [
     '',
     'ניסן',
     'אייר',
@@ -48,7 +78,7 @@ exports.JewishMonthsHeb = [
     'אדר',
     'אדר שני',
 ];
-exports.SecularMonthsEng = [
+export var SecularMonthsEng = [
     'January',
     'February',
     'March',
@@ -62,7 +92,7 @@ exports.SecularMonthsEng = [
     'November',
     'December',
 ];
-exports.DaysOfWeekEng = [
+export var DaysOfWeekEng = [
     'Sunday',
     'Monday',
     'Tuesday',
@@ -71,7 +101,7 @@ exports.DaysOfWeekEng = [
     'Erev Shabbos',
     'Shabbos Kodesh',
 ];
-exports.DaysOfWeekHeb = [
+export var DaysOfWeekHeb = [
     'יום ראשון',
     'יום שני',
     'יום שלישי',
@@ -80,20 +110,22 @@ exports.DaysOfWeekHeb = [
     'ערב שבת קודש',
     'שבת קודש',
 ];
-class Utils {
+var Utils = /** @class */ (function () {
+    function Utils() {
+    }
     /**
      * Gets the Jewish representation of a number (365 = שס"ה)
      * Minimum number is 1 and maximum is 9999.
      * @param {Number} number
      */
-    static toJewishNumber(number) {
+    Utils.toJewishNumber = function (number) {
         if (number < 1) {
             throw 'Min value is 1';
         }
         if (number > 9999) {
             throw 'Max value is 9999';
         }
-        let n = number, retval = '';
+        var n = number, retval = '';
         if (n >= 1000) {
             retval += Utils.jsd[Utils.toInt((n - (n % 1000)) / 1000) - 1] + "'";
             n = n % 1000;
@@ -127,50 +159,50 @@ class Utils {
             retval = retval.slice(0, -1) + '"' + retval[retval.length - 1];
         }
         return retval;
-    }
+    };
     /**
      * Returns the javascript date in the format: Thursday, the 3rd of January 2018.
      * @param {Date} date
      * @param {Boolean} hideDayOfWeek
      * @param {Boolean} dontCapitalize
      */
-    static toStringDate(date, hideDayOfWeek, dontCapitalize) {
+    Utils.toStringDate = function (date, hideDayOfWeek, dontCapitalize) {
         if (!date)
             return;
         return ((hideDayOfWeek
             ? dontCapitalize
                 ? 't'
                 : 'T'
-            : exports.DaysOfWeekEng[date.getDay()] + ', t') +
+            : DaysOfWeekEng[date.getDay()] + ', t') +
             'he ' +
             Utils.toSuffixed(date.getDate()) +
             ' of ' +
-            exports.SecularMonthsEng[date.getMonth()] +
+            SecularMonthsEng[date.getMonth()] +
             ' ' +
             date.getFullYear().toString());
-    }
+    };
     /**
      * Returns the javascript date in the format: 1/3/2020.
      * @param {Date} date
      * @param {Boolean} monthFirst
      */
-    static toShortStringDate(date, monthFirst) {
+    Utils.toShortStringDate = function (date, monthFirst) {
         if (!date)
             return;
-        const dayNum = date.getDate(), monthNum = date.getMonth() + 1;
+        var dayNum = date.getDate(), monthNum = date.getMonth() + 1;
         return ((monthFirst
-            ? `${monthNum}/${dayNum}`
-            : `${dayNum < 10 ? '0' : ''}${dayNum}/${monthNum < 10 ? '0' : ''}${monthNum}`) +
+            ? "".concat(monthNum, "/").concat(dayNum)
+            : "".concat(dayNum < 10 ? '0' : '').concat(dayNum, "/").concat(monthNum < 10 ? '0' : '').concat(monthNum)) +
             '/' +
             date.getFullYear().toString());
-    }
+    };
     /**
      * Add two character suffix to number. e.g. 21st, 102nd, 93rd, 500th
      * @param {Number} num
      */
-    static toSuffixed(num) {
-        const t = num.toString();
-        let suffix = 'th';
+    Utils.toSuffixed = function (num) {
+        var t = num.toString();
+        var suffix = 'th';
         if (t.length === 1 || t[t.length - 2] !== '1') {
             switch (t[t.length - 1]) {
                 case '1':
@@ -185,14 +217,14 @@ class Utils {
             }
         }
         return t + suffix;
-    }
+    };
     /**
      * Returns if the given full secular year has a February 29th
      * @param {Number} year
      */
-    static isSecularLeapYear(year) {
+    Utils.isSecularLeapYear = function (year) {
         return !(year % 400) || (!!(year % 100) && !(year % 4));
-    }
+    };
     /**
      * Get day of week using Javascripts getDay function.
      * Important note: months starts at 1 not 0 like javascript
@@ -201,18 +233,18 @@ class Utils {
      * @param {Number} month
      * @param {Number} day
      */
-    static getSdDOW(year, month, day) {
+    Utils.getSdDOW = function (year, month, day) {
         return new Date(year, month - 1, day).getDay();
-    }
+    };
     /**
      * Makes sure hour is between 0 and 23 and minute is between 0 and 59.
      * Overlaps get added/subtracted.
      * The argument needs to be an object in the format {hour : 12, minute : 42, second : 18}
      * @param {Time} time
      */
-    static fixTime(time) {
+    Utils.fixTime = function (time) {
         //make a copy - javascript sends object parameters by reference
-        const result = {
+        var result = {
             hour: time.hour,
             minute: time.minute,
             second: time.second || 0,
@@ -240,7 +272,7 @@ class Utils {
             result.hour = result.hour % 24;
         }
         return result;
-    }
+    };
     /**
      * Add the given number of minutes to the given time.
      * The argument needs to be an object in the format {hour : 12, minute : 42, second : 18 }
@@ -248,7 +280,7 @@ class Utils {
      * @param {Time} time
      * @param {Number} minutes
      */
-    static addMinutes(time, minutes) {
+    Utils.addMinutes = function (time, minutes) {
         if (!time)
             return time;
         return (time &&
@@ -257,7 +289,7 @@ class Utils {
                 minute: time.minute + (minutes || 0),
                 second: time.second,
             }));
-    }
+    };
     /**
      * Add the given number of seconds to the given time.
      * The argument needs to be an object in the format {hour : 12, minute :42, second : 18}
@@ -265,13 +297,13 @@ class Utils {
      * @param {Time} time
      * @param {Number} seconds
      */
-    static addSeconds(time, seconds) {
+    Utils.addSeconds = function (time, seconds) {
         return Utils.fixTime({
             hour: time.hour,
             minute: time.minute,
             second: (time.second || 0) + seconds,
         });
-    }
+    };
     /**
      * Gets the time difference between two times of day.
      * If showNegative is falsey, assumes that the earlier time is always before the later time.
@@ -282,8 +314,9 @@ class Utils {
      * @param {Boolean} [showNegative] show negative values or assume second value is next day?
      * @returns{{hour:number, minute:number, second:number, sign:1|-1}}
      */
-    static timeDiff(earlierTime, laterTime, showNegative = false) {
-        const earlySec = Utils.totalSeconds(earlierTime), laterSec = Utils.totalSeconds(laterTime), time = Utils.fixTime({
+    Utils.timeDiff = function (earlierTime, laterTime, showNegative) {
+        if (showNegative === void 0) { showNegative = false; }
+        var earlySec = Utils.totalSeconds(earlierTime), laterSec = Utils.totalSeconds(laterTime), time = Utils.fixTime({
             hour: 0,
             minute: 0,
             second: earlySec <= laterSec
@@ -292,98 +325,98 @@ class Utils {
                     ? earlySec - laterSec
                     : 86400 - earlySec + laterSec,
         });
-        return Object.assign(Object.assign({}, time), { sign: earlySec <= laterSec || !showNegative ? 1 : -1 });
-    }
+        return __assign(__assign({}, time), { sign: earlySec <= laterSec || !showNegative ? 1 : -1 });
+    };
     /**
      * Gets the total number of minutes in the given time.
      * @param {Time} time An object in the format {hour : 12, minute :42, second : 18}
      */
-    static totalMinutes(time) {
+    Utils.totalMinutes = function (time) {
         return time ? time.hour * 60 + time.minute : 0;
-    }
+    };
     /**
      * Gets the total number of seconds in the given time.
      * @param {Time} time An object in the format {hour : 12, minute :42, second : 18}
      */
-    static totalSeconds(time) {
+    Utils.totalSeconds = function (time) {
         return time ? Utils.totalMinutes(time) * 60 + (time.second || 0) : 0;
-    }
+    };
     /**
      * Returns the time of the given javascript date as an object in the format of {hour : 23, minute :42, second: 18 }
      * @param {Date} sdate
      * @returns {{hour :number, minute :number, second:number }}
      */
-    static timeFromDate(sdate) {
+    Utils.timeFromDate = function (sdate) {
         return {
             hour: sdate.getHours(),
             minute: sdate.getMinutes(),
             second: sdate.getSeconds(),
         };
-    }
+    };
     /**
      * Determines if the second given time is after (or at) the first given time
      * @param {{hour :number, minute :number, second:number }} beforeTime
      * @param {{hour :number, minute :number, second:number }} afterTime
      */
-    static isTimeAfter(beforeTime, afterTime) {
+    Utils.isTimeAfter = function (beforeTime, afterTime) {
         if (!beforeTime || !afterTime)
             return false;
         return Utils.totalSeconds(afterTime) >= Utils.totalSeconds(beforeTime);
-    }
+    };
     /**
      * Returns the given time interval in a formatted string.
      * @param {{hour:number, minute:number,second:number,sign?: 1 | -1}} time An object in the format {hour : 23, minute :42, second: 18 }
      */
-    static getTimeIntervalTextStringHeb(time) {
-        let t = '';
+    Utils.getTimeIntervalTextStringHeb = function (time) {
+        var t = '';
         if (time.hour > 0) {
-            t += `${time.hour.toString()} ${time.hour === 1 ? 'שעה' : 'שעות'}`;
+            t += "".concat(time.hour.toString(), " ").concat(time.hour === 1 ? 'שעה' : 'שעות');
         }
         if (time.minute > 0) {
             if (t.length) {
                 t += ' ';
             }
-            t += `${time.minute.toString()} ${time.minute === 1 ? 'דקה' : 'דקות'}`;
+            t += "".concat(time.minute.toString(), " ").concat(time.minute === 1 ? 'דקה' : 'דקות');
         }
         if ((time.second || 0) > 0) {
             if (t.length) {
                 t += ' ';
             }
-            t += `${Math.trunc(time.second || 0).toString()} ${time.second === 1 ? 'שנייה' : 'שניות'}`;
+            t += "".concat(Math.trunc(time.second || 0).toString(), " ").concat(time.second === 1 ? 'שנייה' : 'שניות');
         }
         return t;
-    }
+    };
     /**
      * Returns the given time interval in a formatted string.
      * @param {{hour:number, minute:number,second:number,sign?: 1 | -1}} time An object in the format {hour : 23, minute :42, second: 18 }
      */
-    static getTimeIntervalTextString(time) {
-        let t = '';
+    Utils.getTimeIntervalTextString = function (time) {
+        var t = '';
         if (time.hour > 0) {
-            t += `${time.hour.toString()} ${time.hour === 1 ? 'hour' : 'hours'}`;
+            t += "".concat(time.hour.toString(), " ").concat(time.hour === 1 ? 'hour' : 'hours');
         }
         if (time.minute > 0) {
             if (t.length) {
                 t += ' ';
             }
-            t += `${time.minute.toString()} ${time.minute === 1 ? 'minute' : 'minutes'}`;
+            t += "".concat(time.minute.toString(), " ").concat(time.minute === 1 ? 'minute' : 'minutes');
         }
         if ((time.second || 0) > 0) {
             if (t.length) {
                 t += ' ';
             }
-            t += `${Math.trunc(time.second || 0).toString()} ${time.second === 1 ? 'second' : 'seconds'}`;
+            t += "".concat(Math.trunc(time.second || 0).toString(), " ").concat(time.second === 1 ? 'second' : 'seconds');
         }
         return t;
-    }
+    };
     /**
      * Returns the nusach for Sefiras Ha'omer for the given day and minhag
      * @param {number} dayOfOmer The day of the Omer for which to get the nusach for
      * @param {'ashkenaz'|'sefard'|'sefardi'} nusach Should it be La'Omer ("sefard") or Ba'Omer ("ashkenaz") or "sefardi" (Eidot Hamizrach)?
      */
-    static getOmerNusach(dayOfOmer, nusach) {
-        const weeks = Utils.toInt(dayOfOmer / 7), days = dayOfOmer % 7;
-        let txt = 'היום ';
+    Utils.getOmerNusach = function (dayOfOmer, nusach) {
+        var weeks = Utils.toInt(dayOfOmer / 7), days = dayOfOmer % 7;
+        var txt = 'היום ';
         if (dayOfOmer === 1) {
             txt += 'יום אחד ';
         }
@@ -438,7 +471,7 @@ class Utils {
             txt += 'בעומר';
         }
         return txt;
-    }
+    };
     /**
      * Returns the given time in a formatted string.
      * @param {Time} time An object in the format {hour : 23, minute :42, second: 18 }
@@ -446,8 +479,8 @@ class Utils {
      * @param {Boolean} [army] If falsey, the returned string will be: 11:42:18 PM otherwise it will be 23:42:18
      * @param {Boolean} [roundUp] If falsey, the numbers will converted to a whole number by rounding down, otherwise, up.
      */
-    static getTimeString(time, sign, army, roundUp) {
-        const round = roundUp ? Math.ceil : Math.floor;
+    Utils.getTimeString = function (time, sign, army, roundUp) {
+        var round = roundUp ? Math.ceil : Math.floor;
         time = {
             hour: round(time.hour),
             minute: round(time.minute),
@@ -482,26 +515,26 @@ class Utils {
                     : (time.second || 0).toString()) +
                 (time.hour < 12 ? ' AM' : ' PM'));
         }
-    }
+    };
     /**
      * Gets the UTC offset in whole hours for the users time zone.
      * Note: this is not affected by DST - unlike javascripts getTimezoneOffset() function which gives you the current offset.
      */
-    static currUtcOffset() {
-        const date = new Date(), jan = new Date(date.getFullYear(), 0, 1), jul = new Date(date.getFullYear(), 6, 1);
+    Utils.currUtcOffset = function () {
+        var date = new Date(), jan = new Date(date.getFullYear(), 0, 1), jul = new Date(date.getFullYear(), 6, 1);
         return -Utils.toInt(Math.max(jan.getTimezoneOffset(), jul.getTimezoneOffset()) / 60);
-    }
+    };
     /** Determines if the given date is within DST on the users system */
-    static isDateDST(date) {
+    Utils.isDateDST = function (date) {
         return (-Utils.toInt(date.getTimezoneOffset() / 60) !==
             Utils.currUtcOffset());
-    }
+    };
     /**
      * Determines if the given date is within DST in the given location
      * Note: This may not be correct if the user has set the Location to a
      * time zone outside Israel or the USA which is not the current system time zone.
      */
-    static isDST(location, date) {
+    Utils.isDST = function (location, date) {
         //If the current system time zone is the same as the given locations time zone
         if (location.UTCOffset === Utils.currUtcOffset()) {
             //We can use the system data to determine if the given date is within DST
@@ -513,13 +546,13 @@ class Utils {
         else {
             return Utils.isUSA_DST(date);
         }
-    }
+    };
     /**
      * Determines if the given javascript date is during DST according to the USA rules
      * @param {Date} date A javascript Date object
      */
-    static isUSA_DST(date) {
-        const year = date.getFullYear(), month = date.getMonth() + 1, day = date.getDate(), hour = date.getHours();
+    Utils.isUSA_DST = function (date) {
+        var year = date.getFullYear(), month = date.getMonth() + 1, day = date.getDate(), hour = date.getHours();
         if (month < 3 || month == 12) {
             return false;
         }
@@ -530,7 +563,7 @@ class Utils {
         else if (month === 3) {
             //March
             //Gets day of week on March 1st
-            const firstDOW = Utils.getSdDOW(year, 3, 1), 
+            var firstDOW = Utils.getSdDOW(year, 3, 1), 
             //Gets date of second Sunday
             targetDate = firstDOW == 0 ? 8 : 7 - ((firstDOW + 7) % 7) + 8;
             return day > targetDate || (day === targetDate && hour >= 2);
@@ -538,19 +571,19 @@ class Utils {
         //DST ends at 2 AM on the first Sunday in November //dt.Month == 11 / November
         else {
             //Gets day of week on November 1st
-            const firstDOW = Utils.getSdDOW(year, 11, 1), 
+            var firstDOW = Utils.getSdDOW(year, 11, 1), 
             //Gets date of first Sunday
             targetDate = firstDOW === 0 ? 1 : 7 - ((firstDOW + 7) % 7) + 1;
             return day < targetDate || (day === targetDate && hour < 2);
         }
-    }
+    };
     //
     /**
      * Determines if the given Javascript date is during DST according to the current (5776) Israeli rules
      * @param {Date} date A Javascript Date object
      */
-    static isIsrael_DST(date) {
-        const year = date.getFullYear(), month = date.getMonth() + 1, day = date.getDate(), hour = date.getHours();
+    Utils.isIsrael_DST = function (date) {
+        var year = date.getFullYear(), month = date.getMonth() + 1, day = date.getDate(), hour = date.getHours();
         if (month > 10 || month < 3) {
             return false;
         }
@@ -561,91 +594,91 @@ class Utils {
         else if (month === 3) {
             //March
             //Gets date of the Friday before the last Sunday
-            const lastFriday = 31 - Utils.getSdDOW(year, 3, 31) - 2;
+            var lastFriday = 31 - Utils.getSdDOW(year, 3, 31) - 2;
             return day > lastFriday || (day === lastFriday && hour >= 2);
         }
         //DST ends at 2 AM on the last Sunday in October //dt.Month === 10 / October
         else {
             //Gets date of last Sunday in October
-            const lastSunday = 31 - Utils.getSdDOW(year, 10, 31);
+            var lastSunday = 31 - Utils.getSdDOW(year, 10, 31);
             return day < lastSunday || (day === lastSunday && hour < 2);
         }
-    }
+    };
     /** The current time in Israel - determined by the current users system time and time zone offset*/
-    static getSdNowInIsrael() {
-        const now = new Date(), 
+    Utils.getSdNowInIsrael = function () {
+        var now = new Date(), 
         //first determine the hour differential between this user and Israel time
         israelTimeOffset = 2 + -Utils.currUtcOffset();
         //This will give us the current correct date and time in Israel
         now.setHours(now.getHours() + israelTimeOffset);
         return now;
-    }
+    };
     /**
      * Adds the given number of days to the given javascript date and returns the new date
      * @param {Date} sdate
      * @param {Number} days
      */
-    static addDaysToSdate(sdate, days) {
+    Utils.addDaysToSdate = function (sdate, days) {
         return new Date(sdate.valueOf() + 8.64e7 * days);
-    }
+    };
     /**
      * Compares two js dates to se if they both refer to the same day - time is ignored.
      * @param {Date} sdate1
      * @param {Date} sdate2
      */
-    static isSameSdate(sdate1, sdate2) {
+    Utils.isSameSdate = function (sdate1, sdate2) {
         return (sdate1 && sdate2 && sdate1.toDateString() === sdate2.toDateString());
-    }
+    };
     /**
      * Compares two jDates to se if they both refer to the same day - time is ignored.
      * @param {jDate} jdate1
      * @param {jDate} jdate2
      */
-    static isSameJdate(jdate1, jdate2) {
+    Utils.isSameJdate = function (jdate1, jdate2) {
         return (jdate1 &&
             jdate2 &&
             jdate1.Abs &&
             jdate2.Abs &&
             jdate1.Abs === jdate2.Abs);
-    }
+    };
     /**
      * Compares two jDates to see if they both refer to the same Jewish Month.
      * @param {jDate} jdate1
      * @param {jDate} jdate2
      */
-    static isSameJMonth(jdate1, jdate2) {
+    Utils.isSameJMonth = function (jdate1, jdate2) {
         return jdate1.Month === jdate2.Month && jdate1.Year === jdate2.Year;
-    }
+    };
     /**
      * Compares two dates to se if they both refer to the same Secular Month.
      * @param {Date} sdate1
      * @param {Date} sdate2
      */
-    static isSameSMonth(sdate1, sdate2) {
+    Utils.isSameSMonth = function (sdate1, sdate2) {
         return (sdate1.getMonth() === sdate2.getMonth() &&
             sdate1.getFullYear() === sdate2.getFullYear());
-    }
+    };
     /**
      * Determines if the time of the given Date() is after sunset at the given Location
      * @param {Date} sdate
      * @param {Location} location
      */
-    static isAfterSunset(sdate, location) {
-        const shkia = Zmanim_1.default.getSunTimes(sdate, location).sunset, now = Utils.timeFromDate(sdate);
+    Utils.isAfterSunset = function (sdate, location) {
+        var shkia = Zmanim.getSunTimes(sdate, location).sunset, now = Utils.timeFromDate(sdate);
         return shkia && Utils.isTimeAfter(shkia, now);
-    }
+    };
     /**
      * Gets the current Jewish Date at the given Location
      * @param {Location} location
      */
-    static nowAtLocation(location) {
-        let sdate = new Date();
+    Utils.nowAtLocation = function (location) {
+        var sdate = new Date();
         //if isAfterSunset a day is added.
         if (Utils.isAfterSunset(sdate, location)) {
             sdate.setDate(sdate.getDate() + 1);
         }
-        return new jDate_1.default(sdate);
-    }
+        return new jDate(sdate);
+    };
     /**
      * Converts the given complex number to an integer by removing the decimal part.
      * Returns same results as Math.floor for positive numbers and Math.ceil for negative ones.
@@ -654,46 +687,50 @@ class Utils {
      * In performance tests, this function was found to be quicker than the alternatives.
      * @param {Number} float The complex number to convert to an integer
      */
-    static toInt(float) {
+    Utils.toInt = function (float) {
         return float | 0;
-    }
+    };
     /***
     * Takes either a jDate or a Date and returns both
     * @param date {Date |jDate}
     * @returns {{ sdate:Date, jdate:jDate }}
     */
-    static bothDates(date) {
-        const jdate = date instanceof Date
-            ? new jDate_1.default(date)
+    Utils.bothDates = function (date) {
+        var jdate = date instanceof Date
+            ? new jDate(date)
             : date;
-        const sdate = date instanceof Date
+        var sdate = date instanceof Date
             ? date
             : jdate.getDate();
-        return { sdate, jdate };
-    }
+        return { sdate: sdate, jdate: jdate };
+    };
     /** Returns true if "thing" is either a string primitive or String object.*/
-    static isString(thing) {
+    Utils.isString = function (thing) {
         return typeof thing === 'string' || thing instanceof String;
-    }
+    };
     /** Returns true if "thing" is either a number primitive or a Number object.*/
-    static isNumber(thing) {
+    Utils.isNumber = function (thing) {
         return typeof thing === 'number' || thing instanceof Number;
-    }
+    };
     /** Returns true if "thing" is a Date object containing a valid date.*/
-    static isValidDate(thing) {
+    Utils.isValidDate = function (thing) {
         return thing instanceof Date && !isNaN(thing.valueOf());
-    }
+    };
     /** Returns whether or not the given, array, string, or argument list contains the given item or substring.
      *
      * This function is awfully similar to Array.includes, but has the added plus of accepting any number or type of arguments.*/
-    static has(o, ...arr) {
+    Utils.has = function (o) {
+        var arr = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            arr[_i - 1] = arguments[_i];
+        }
         if (arr.length === 1 && (Array.isArray(arr[0]) || Utils.isString(arr[0]))) {
             return arr[0].includes(o);
         }
         else {
             return arr.includes(o);
         }
-    }
+    };
     /** Returns the first value unless it is undefined, null or NaN.
      *
      * This is very useful for boolean, string and integer parameters
@@ -702,7 +739,7 @@ class Utils {
      * Similar purpose to default parameters with the difference being that this function will return
      * the second value if the first is NaN or null, while default params will give give you the NaN or the null.
      */
-    static setDefault(paramValue, defValue) {
+    Utils.setDefault = function (paramValue, defValue) {
         if (typeof paramValue === 'undefined' ||
             paramValue === null ||
             isNaN(paramValue)) {
@@ -711,7 +748,7 @@ class Utils {
         else {
             return paramValue;
         }
-    }
+    };
     /**
      * Returns an array containing a range of integers.
      * @param {Number} [start] The number to start at. The start number is included in the results.
@@ -720,53 +757,66 @@ class Utils {
      * Unlike Pythons range function, The end number is included in the results.
      * @returns {[Number]}
      */
-    static range(start, end) {
-        const startNumber = typeof (end) === 'undefined' ? 1 : start, endNumber = typeof (end) === 'undefined' ? start : end;
-        return Array.from({ length: endNumber - startNumber + 1 }, (v, i) => startNumber + i);
-    }
+    Utils.range = function (start, end) {
+        var startNumber = typeof (end) === 'undefined' ? 1 : start, endNumber = typeof (end) === 'undefined' ? start : end;
+        return Array.from({ length: endNumber - startNumber + 1 }, function (v, i) { return startNumber + i; });
+    };
     /**
      * Log message to console
      * @param {string} txt
      */
-    static log(txt, ...optionalItems) {
+    Utils.log = function (txt) {
+        var optionalItems = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            optionalItems[_i - 1] = arguments[_i];
+        }
         if (__DEV__) {
-            console.log(txt, ...optionalItems);
+            console.log.apply(console, __spreadArray([txt], __read(optionalItems), false));
         }
-    }
+    };
     /**
      * Warn message to console
      * @param {string} txt
      */
-    static warn(txt, ...optionalItems) {
+    Utils.warn = function (txt) {
+        var optionalItems = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            optionalItems[_i - 1] = arguments[_i];
+        }
         if (__DEV__) {
-            console.warn(txt, ...optionalItems);
+            console.warn.apply(console, __spreadArray([txt], __read(optionalItems), false));
         }
-    }
+    };
     /**
      * Error message to console
      * @param {*} txt
      */
-    static error(txt, ...optionalItems) {
-        if (__DEV__) {
-            console.error(txt, ...optionalItems);
+    Utils.error = function (txt) {
+        var optionalItems = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            optionalItems[_i - 1] = arguments[_i];
         }
-    }
-}
-exports.Utils = Utils;
-Utils.jsd = ['א', 'ב', 'ג', 'ד', 'ה', 'ו', 'ז', 'ח', 'ט'];
-Utils.jtd = ['י', 'כ', 'ל', 'מ', 'נ', 'ס', 'ע', 'פ', 'צ'];
-Utils.jhd = ['ק', 'ר', 'ש', 'ת'];
-Utils.jsnum = [
-    '',
-    'אחד',
-    'שנים',
-    'שלשה',
-    'ארבעה',
-    'חמשה',
-    'ששה',
-    'שבעה',
-    'שמונה',
-    'תשעה',
-];
-Utils.jtnum = ['', 'עשר', 'עשרים', 'שלושים', 'ארבעים'];
+        if (__DEV__) {
+            console.error.apply(console, __spreadArray([txt], __read(optionalItems), false));
+        }
+    };
+    Utils.jsd = ['א', 'ב', 'ג', 'ד', 'ה', 'ו', 'ז', 'ח', 'ט'];
+    Utils.jtd = ['י', 'כ', 'ל', 'מ', 'נ', 'ס', 'ע', 'פ', 'צ'];
+    Utils.jhd = ['ק', 'ר', 'ש', 'ת'];
+    Utils.jsnum = [
+        '',
+        'אחד',
+        'שנים',
+        'שלשה',
+        'ארבעה',
+        'חמשה',
+        'ששה',
+        'שבעה',
+        'שמונה',
+        'תשעה',
+    ];
+    Utils.jtnum = ['', 'עשר', 'עשרים', 'שלושים', 'ארבעים'];
+    return Utils;
+}());
+export { Utils };
 //# sourceMappingURL=Utils.js.map