@hebcal/core 6.0.8 → 6.1.0

package/dist/src/moladBase.js

@@ -0,0 +1,78 @@
+import { HDate, isLeapYear } from '@hebcal/hdate';
+/*
+ * Includes code ported from KosherJava, copyright 2004 Eliyahu Hershfeld,
+ * released under LGPL 2.1.
+ */
+/**
+ * the Jewish epoch using the RD (Rata Die/Fixed Date or Reingold Dershowitz) day used in Calendrical Calculations.
+ * Day 1 is January 1, 0001 of the Gregorian calendar
+ */
+const JEWISH_EPOCH = -1373429;
+/** The number of _chalakim_ (18) in a minute. */
+const CHALAKIM_PER_MINUTE = 18;
+/** The number of _chalakim_ (1080) in an hour. */
+const CHALAKIM_PER_HOUR = 1080;
+/** The number of _chalakim_ (25,920) in a 24-hour day. */
+const CHALAKIM_PER_DAY = 25920; // 24 * 1080
+/** The number of _chalakim_ in an average Jewish month. A month has 29 days, 12 hours and 793
+ * _chalakim_ (44 minutes and 3.3 seconds) for a total of 765,433 _chalakim_ */
+const CHALAKIM_PER_MONTH = 765433; // (29 * 24 + 12) * 1080 + 793
+/**
+ * Days from the beginning of Sunday till _molad BaHaRaD_. Calculated as 1 day, 5 hours and 204 _chalakim_ =
+ * (24 + 5) * 1080 + 204 = 31524
+ */
+const CHALAKIM_MOLAD_TOHU = 31524;
+/**
+ * Converts the NISSAN-based constants used by this class to numeric month starting from
+ * TISHREI. This is required for _molad_ calculations.
+ */
+function getJewishMonthOfYear(year, month) {
+    const leap = isLeapYear(year);
+    return ((month + (leap ? 6 : 5)) % (leap ? 13 : 12)) + 1;
+}
+/**
+ * Returns the number of _chalakim_ (parts - 1080 to the hour) from
+ * the original hypothetical _Molad Tohu_ to the year and month
+ * passed in.
+ */
+function getChalakimSinceMoladTohu(year, month) {
+    // Jewish lunar month = 29 days, 12 hours and 793 chalakim
+    // chalakim since Molad Tohu BeHaRaD - 1 day, 5 hours and 204 chalakim
+    const monthOfYear = getJewishMonthOfYear(year, month);
+    const monthsElapsed = 235 * Math.trunc((year - 1) / 19) + // Months in complete 19-year lunar (Metonic) cycles so far
+        12 * ((year - 1) % 19) + // Regular months in this cycle
+        Math.trunc((7 * ((year - 1) % 19) + 1) / 19) + // Leap months this cycle
+        (monthOfYear - 1); // add elapsed months till the start of the molad of the month
+    // return chalakim prior to BeHaRaD + number of chalakim since
+    return CHALAKIM_MOLAD_TOHU + CHALAKIM_PER_MONTH * monthsElapsed;
+}
+/**
+ * Returns the number of days from the Jewish epoch from the number of chalakim from the epoch passed in.
+ * @param chalakim the number of _chalakim_ since the beginning of Sunday prior to BaHaRaD
+ * @return the number of days from the Jewish epoch
+ */
+function moladToAbsDate(chalakim) {
+    return Math.trunc(chalakim / CHALAKIM_PER_DAY) + JEWISH_EPOCH;
+}
+export function calculateMolad(year, month) {
+    const chalakim = getChalakimSinceMoladTohu(year, month);
+    const absDate = moladToAbsDate(chalakim);
+    let hd = new HDate(absDate);
+    const conjunctionDay = Math.trunc(chalakim / CHALAKIM_PER_DAY);
+    const conjunctionParts = Math.trunc(chalakim - conjunctionDay * CHALAKIM_PER_DAY);
+    let adjustedChalakim = conjunctionParts;
+    let hour = Math.trunc(adjustedChalakim / CHALAKIM_PER_HOUR);
+    adjustedChalakim = adjustedChalakim - hour * CHALAKIM_PER_HOUR;
+    const minutes = Math.trunc(adjustedChalakim / CHALAKIM_PER_MINUTE);
+    if (hour >= 6) {
+        hd = hd.next();
+    }
+    hour = (hour + 18) % 24;
+    const m = {
+        hdate: hd,
+        hour,
+        minutes,
+        chalakim: adjustedChalakim - minutes * CHALAKIM_PER_MINUTE,
+    };
+    return m;
+}

package/dist/src/moladDate.d.ts

@@ -0,0 +1,12 @@
+import 'temporal-polyfill/global';
+import { MoladBase } from './moladBase';
+/**
+ * Returns the molad in UTC as a Temporal.ZonedDateTime.
+ * This method subtracts 20.94 minutes (20 minutes and 56.496 seconds) from the computed time (Har Habayis with a longitude
+ * of 35.2354° is 5.2354° away from the %15 timezone longitude) to get to standard time. This method
+ * intentionally uses standard time and not daylight savings time.
+ *
+ * @return the ZonedDateTime representing the moment of the molad in UTC
+
+ */
+export declare function getMoladAsDate(molad: MoladBase): Temporal.ZonedDateTime;

package/dist/src/moladDate.js

@@ -0,0 +1,58 @@
+import 'temporal-polyfill/global';
+import { getTimezoneOffset } from '@hebcal/hdate';
+/** constant for milliseconds in a minute (60,000) */
+const MINUTE_MILLIS = 60 * 1000;
+/**
+ * A method that will return the location's local mean time offset in milliseconds from local <a
+ * href="https://en.wikipedia.org/wiki/Standard_time">standard time</a>. The globe is split into 360&deg;, with
+ * 15&deg; per hour of the day. For a local that is at a longitude that is evenly divisible by 15 (longitude % 15 ==
+ * 0), at solar {@link com.kosherjava.zmanim.AstronomicalCalendar#getSunTransit() noon} (with adjustment for the <a
+ * href="https://en.wikipedia.org/wiki/Equation_of_time">equation of time</a>) the sun should be directly overhead,
+ * so a user who is 1&deg; west of this will have noon at 4 minutes after standard time noon, and conversely, a user
+ * who is 1&deg; east of the 15&deg; longitude will have noon at 11:56 AM. Lakewood, N.J., whose longitude is
+ * -74.222, is 0.778 away from the closest multiple of 15 at -75&deg;. This is multiplied by 4 to yield 3 minutes
+ * and 10 seconds earlier than standard time. The offset returned does not account for the <a
+ * href="https://en.wikipedia.org/wiki/Daylight_saving_time">Daylight saving time</a> offset since this class is
+ * unaware of dates.
+ *
+ * @return the offset in milliseconds not accounting for Daylight saving time. A positive value will be returned
+ *         East of the 15&deg; timezone line, and a negative value West of it.
+ */
+function getLocalMeanTimeOffset(dt, longitude, tzid) {
+    const offset = -1 * getTimezoneOffset(tzid, dt);
+    const d = longitude * 4 * MINUTE_MILLIS - offset * MINUTE_MILLIS;
+    return Math.trunc(d);
+}
+/**
+ * Returns the molad in UTC as a Temporal.ZonedDateTime.
+ * This method subtracts 20.94 minutes (20 minutes and 56.496 seconds) from the computed time (Har Habayis with a longitude
+ * of 35.2354&deg; is 5.2354&deg; away from the %15 timezone longitude) to get to standard time. This method
+ * intentionally uses standard time and not daylight savings time.
+ *
+ * @return the ZonedDateTime representing the moment of the molad in UTC
+
+ */
+export function getMoladAsDate(molad) {
+    const moladSeconds = (molad.chalakim * 10) / 3;
+    const millis = Math.trunc(1000 * (moladSeconds - Math.trunc(moladSeconds)));
+    const dt = molad.hdate.greg();
+    // The raw molad Date (point in time) must be generated using standard time. Using "Asia/Jerusalem" timezone will result in the time
+    // being incorrectly off by an hour in the summer due to DST. Proper adjustment for the actual time in DST will be done by the date
+    // formatter class used to display the Date.
+    const tzid = 'Etc/GMT+2';
+    const zdt = Temporal.ZonedDateTime.from({
+        year: dt.getFullYear(),
+        month: dt.getMonth() + 1,
+        day: dt.getDate(),
+        hour: molad.hour,
+        minute: molad.minutes,
+        second: Math.trunc(moladSeconds),
+        millisecond: millis,
+        timeZone: tzid,
+    });
+    const longitude = 35.2354; // Har Habayis longitude
+    const offset = getLocalMeanTimeOffset(dt, longitude, tzid);
+    // subtract local time difference of 20.94 minutes (20 minutes and 56.496 seconds) to get to Standard time
+    const zdt2 = zdt.subtract({ milliseconds: offset });
+    return zdt2.withTimeZone('UTC');
+}

package/dist/src/omer.d.ts

@@ -11,7 +11,6 @@ export declare class OmerEvent extends Event {
     private readonly weekNumber;
     private readonly daysWithinWeeks;
     readonly omer: number;
-    emoji?: string;
     /**
      * @param date
      * @param omerDay

package/dist/src/omer.js

@@ -75,7 +75,7 @@ function omerTodayIsEn(omerDay) {
         const day7 = daysWithinWeeks === 7;
         const numWeeks = day7 ? weekNumber : weekNumber - 1;
         const weeksStr = numWeeks === 1 ? 'week' : 'weeks';
-        str += `, which is ${numWeeks} ${weeksStr}`;
+        str += `, which are ${numWeeks} ${weeksStr}`;
         if (!day7) {
             const daysStr = daysWithinWeeks === 1 ? 'day' : 'days';
             str += ` and ${daysWithinWeeks} ${daysStr}`;
@@ -185,6 +185,9 @@ function omerTodayIsHe(omerDay) {
 }
 /** Represents a day 1-49 of counting the Omer from Pesach to Shavuot */
 export class OmerEvent extends Event {
+    weekNumber;
+    daysWithinWeeks;
+    omer;
     /**
      * @param date
      * @param omerDay
@@ -225,7 +228,7 @@ export class OmerEvent extends Event {
      * @param [locale] Optional locale name (defaults to empty locale)
      */
     render(locale) {
-        locale = locale !== null && locale !== void 0 ? locale : 'en';
+        locale = locale ?? 'en';
         if (typeof locale === 'string') {
             locale = locale.toLowerCase();
         }
@@ -281,7 +284,7 @@ export class OmerEvent extends Event {
      *  or `הַיוֹם עֲשָׂרָה יָמִים, שְׁהֵם שָׁבוּעַ אֶחָד וְשְׁלוֹשָׁה יָמִים לָעוֹמֶר`
      */
     getTodayIs(locale) {
-        locale = locale !== null && locale !== void 0 ? locale : 'en';
+        locale = locale ?? 'en';
         if (typeof locale === 'string') {
             locale = locale.toLowerCase();
         }

package/dist/src/parshaName.js

@@ -1,7 +1,7 @@
 import { Locale } from './locale';
 /** @private */
 export function renderParshaName(parsha, locale) {
-    const locale0 = locale !== null && locale !== void 0 ? locale : 'en';
+    const locale0 = locale ?? 'en';
     let name = Locale.gettext(parsha[0], locale0);
     if (parsha.length === 2) {
         const hyphen = locale0 === 'he' ? '־' : '-';

package/dist/src/pkgVersion.d.ts

@@ -1,2 +1,2 @@
 /** DO NOT EDIT THIS AUTO-GENERATED FILE! */
-export declare const version = "6.0.8";
+export declare const version = "6.1.0";

package/dist/src/pkgVersion.js

@@ -1,2 +1,2 @@
 /** DO NOT EDIT THIS AUTO-GENERATED FILE! */
-export const version = '6.0.8';
+export const version = '6.1.0';

package/dist/src/reformatTimeStr.js

@@ -19,15 +19,14 @@ const hour12cc = {
  * @param options
  */
 export function reformatTimeStr(timeStr, suffix, options) {
-    var _a;
     if (typeof timeStr !== 'string')
         throw new TypeError(`Bad timeStr: ${timeStr}`);
-    const cc = ((_a = options === null || options === void 0 ? void 0 : options.location) === null || _a === void 0 ? void 0 : _a.getCountryCode()) || ((options === null || options === void 0 ? void 0 : options.il) ? 'IL' : 'US');
-    const hour12 = options === null || options === void 0 ? void 0 : options.hour12;
-    if (typeof hour12 !== 'undefined' && !hour12) {
+    const cc = options?.location?.getCountryCode() || (options?.il ? 'IL' : 'US');
+    const hour12 = options?.hour12;
+    if (hour12 !== undefined && !hour12) {
         return timeStr;
     }
-    if (!hour12 && typeof hour12cc[cc] === 'undefined') {
+    if (!hour12 && hour12cc[cc] === undefined) {
         return timeStr;
     }
     const hm = timeStr.split(':');

package/dist/src/sedra.js

@@ -52,6 +52,12 @@ function yearType(hyear) {
  * Represents Parashah HaShavua for an entire Hebrew year
  */
 export class Sedra {
+    year;
+    il;
+    rh;
+    firstSaturday;
+    theSedraArray;
+    yearKey;
     /**
      * Caculates the Parashah HaShavua for an entire Hebrew year
      * @param hyear - Hebrew year (e.g. 5749)
@@ -103,7 +109,7 @@ export class Sedra {
             if (typeof num === 'number') {
                 return this.find(num);
             }
-            else if (parsha.indexOf('-') !== -1) {
+            else if (parsha.includes('-')) {
                 if (parsha === CHMPESACH || parsha === CHMSUKOT) {
                     return this.findInternal(parsha);
                 }
@@ -219,7 +225,7 @@ export class Sedra {
         const saturday = HDate.dayOnOrBefore(6, abs + 6);
         const weekNum = (saturday - this.firstSaturday) / 7;
         const index = this.theSedraArray[weekNum];
-        if (typeof index === 'undefined') {
+        if (index === undefined) {
             const sedra = getSedra(this.year + 1, this.il);
             return sedra.lookup(saturday); // must be next year
         }
@@ -319,7 +325,7 @@ for (let id = 0; id < parshiot.length; id++) {
     parsha2id.set(name, id);
 }
 // 0-based parsha IDs
-const doubles = [
+const doubles = new Set([
     21, // Vayakhel-Pekudei
     26, // Tazria-Metzora
     28, // Achrei Mot-Kedoshim
@@ -327,13 +333,13 @@ const doubles = [
     38, // Chukat-Balak
     41, // Matot-Masei
     50, // Nitzavim-Vayeilech
-];
+]);
 /**
  * @private
  * @param id a negative number
  */
 function isValidDouble(id) {
-    return doubles.includes(-id);
+    return doubles.has(-id);
 }
 /**
  * parsha doubler/undoubler
@@ -459,7 +465,7 @@ types['1311'] = types['1221'];
 /* Hebrew year that starts on Saturday, is `complete' (Heshvan and
  * Kislev each have 30 days), and has Passover start on Thursday. */
 types['1721'] = types['170'];
-const sedraCache = new QuickLRU({ maxSize: 400 });
+const sedraCache = new QuickLRU({ maxSize: 120 });
 /**
  * Convenience function to create an instance of `Sedra` or reuse a previously
  * created and cached instance.

package/dist/src/tachanun.js

@@ -35,7 +35,7 @@ function tachanun0(hdate, il, checkNext) {
     const year = hdate.yy;
     const dates = tachanunYear(year, il);
     const abs = hdate.abs();
-    if (dates.none.indexOf(abs) > -1) {
+    if (dates.none.includes(abs)) {
         return NONE;
     }
     const dow = hdate.getDay();
@@ -44,14 +44,14 @@ function tachanun0(hdate, il, checkNext) {
         mincha: false,
         allCongs: false,
     };
-    if (dates.some.indexOf(abs) === -1) {
+    if (!dates.some.includes(abs)) {
         ret.allCongs = true;
     }
     if (dow !== 6) {
         ret.shacharit = true;
     }
     const tomorrow = abs + 1;
-    if (checkNext && dates.yesPrev.indexOf(tomorrow) === -1) {
+    if (checkNext && !dates.yesPrev.includes(tomorrow)) {
         const tmp = tachanun0(new HDate(tomorrow), il, false);
         ret.mincha = tmp.shacharit;
     }

package/dist/src/zmanim.d.ts

@@ -28,7 +28,7 @@ import { HDate } from '@hebcal/hdate';
  * const timeStr = Zmanim.formatISOWithTimeZone(tzid, candleLighting);
  */
 export declare class Zmanim {
-    private readonly date;
+    private readonly plainDate;
     private readonly gloc;
     private readonly noaa;
     private useElevation;
@@ -123,6 +123,7 @@ export declare class Zmanim {
      * sea level sunrise.
      */
     alotHaShachar72(): Date;
+    alotHaShachar72zdt(): Temporal.ZonedDateTime | null;
     /**
      * Earliest talis & tefillin – Misheyakir; Sun is 11.5° below the horizon in the morning.
      * Because degree-based functions estimate the amount of light in the sky,
@@ -265,6 +266,7 @@ export declare class Zmanim {
      * the result is not impacted by elevation.
      */
     tzeit(angle?: number): Date;
+    tzeit72(): Temporal.ZonedDateTime | null;
     /**
      * Alias for sunrise
      */
@@ -282,6 +284,117 @@ export declare class Zmanim {
      * the result is not impacted by elevation.
      */
     beinHaShmashos(): Date;
+    /**
+     * Used by Molad based _zmanim_ to determine if _zmanim_ occur during the current day.
+     * @return previous midnight
+     */
+    private getMidnightLastNight;
+    /**
+     * Used by Molad based _zmanim_ to determine if _zmanim_ occur during the current day.
+     * @return following midnight
+     */
+    private getMidnightTonight;
+    /**
+     * Returns the Date of the _molad_ based time if it occurs on the current date. Since _Kiddush Levana_
+     * can only be said during the day, there are parameters to limit it to between _alos_ and _tzais_. If
+     * the time occurs between _alos_ and _tzais_, _tzais_ will be returned.
+     *
+     * @param moladBasedTime
+     *            the _molad_ based time such as _molad_, _tchilas_ and _sof zman Kiddush Levana_
+     * @param alos
+     *            optional start of day to limit _molad_ times to the end of the night before or beginning of the next night.
+     *            Ignored if either _alos_ or _tzais_ are null.
+     * @param tzais
+     *            optional end of day to limit _molad_ times to the end of the night before or beginning of the next night.
+     *            Ignored if either _tzais_ or _alos_ are null
+     * @param techila
+     *            is it the start of _Kiddush Levana_ time or the end? If it is start roll it to the next _tzais_,
+     *            and if it is the end, return the end of the previous night (_alos_ passed in). Ignored if either
+     *            _alos_ or _tzais_ are null.
+     * @return the _molad_ based time. If the _zman_ does not occur during the current date, <code>null</code> will be
+     *         returned.
+     */
+    private getMoladBasedTime;
+    private getHDate;
+    /**
+     * Returns the latest time of Kiddush Levana according to the <a
+     * href="https://en.wikipedia.org/wiki/Yaakov_ben_Moshe_Levi_Moelin">Maharil's</a> opinion that it is calculated as
+     * halfway between _molad_ and _molad_. This adds half the 29 days, 12 hours and 793 chalakim time between
+     * _molad_ and _molad_ (14 days, 18 hours, 22 minutes and 666 milliseconds) to the month's _molad_.
+     * The _sof zman Kiddush Levana_ will be returned even if it occurs during the day. To limit the time to between
+     * _tzais_ and _alos_, see {@link #getSofZmanKidushLevanaBetweenMoldos(Date, Date)}.
+     *
+     * @param alos
+     *            the beginning of the Jewish day. If _Kidush Levana_ occurs during the day (starting at _alos_ and
+     *            ending at _tzais_), the time returned will be alos. If either the _alos_ or _tzais_ parameters
+     *            are null, no daytime adjustment will be made.
+     * @param tzais
+     *            the end of the Jewish day. If Kidush Levana occurs during the day (starting at alos and ending at
+     *            tzais), the time returned will be alos. If either the alos or tzais parameters are null, no daytime
+     *            adjustment will be made.
+     * @return the Date representing the moment halfway between molad and molad. If the time occurs between
+     *         _alos_ and _tzais_, _alos_ will be returned. If the _zman_ will not occur on this
+     *         day, a <code>null</code> will be returned.
+     */
+    getSofZmanKidushLevanaBetweenMoldos(alos?: Temporal.ZonedDateTime | null, tzais?: Temporal.ZonedDateTime | null): Temporal.ZonedDateTime | null;
+    /**
+     * Returns the latest time of _Kiddush Levana_ calculated as 15 days after the molad. This is the opinion of
+     * the Shulchan Aruch (Orach Chaim 426). It should be noted that some opinions hold that the
+     * <a href="https://en.wikipedia.org/wiki/Moses_Isserles">Rema</a> who brings down the opinion of the <a
+     * href="https://en.wikipedia.org/wiki/Yaakov_ben_Moshe_Levi_Moelin">Maharil's</a> of calculating
+     * {@link #getSofZmanKidushLevanaBetweenMoldos(Date, Date) half way between _molad_ and _molad_} is of
+     * the opinion that the Mechaber agrees to his opinion. Also see the Aruch Hashulchan. For additional details on the subject,
+     * See Rabbi Dovid Heber's very detailed write-up in Siman Daled (chapter 4) of <a href="https://hebrewbooks.org/53000">Shaarei
+     * Zmanim</a>. The _sof zman Kiddush Levana_ will be returned even if it occurs during the day. To limit the time to
+     * between _tzais_ and _alos_, see {@link #getSofZmanKidushLevana15Days(Date, Date)}.
+     *
+     * @return the Date representing the moment 15 days after the _molad_. If the time occurs between
+     *         _alos_ and _tzais_, _alos_ will be returned. If the _zman_ will not occur on this day, a
+     *         <code>null</code> will be returned.
+     *
+     *
+     */
+    getSofZmanKidushLevana15Days(alos?: Temporal.ZonedDateTime | null, tzais?: Temporal.ZonedDateTime | null): Temporal.ZonedDateTime | null;
+    /**
+     * Returns the earliest time of _Kiddush Levana_ according to <a href=
+     * "https://en.wikipedia.org/wiki/Yonah_Gerondi">Rabbeinu Yonah</a>'s opinion that it can be said 3 days after the _molad_.
+     * If the time of _tchilas zman Kiddush Levana_ occurs during the day (between _alos_ and _tzais_ passed to
+     * this method) it will return the following _tzais_. If null is passed for either _alos_ or _tzais_, the actual
+     * _tchilas zman Kiddush Levana_ will be returned, regardless of if it is during the day or not.
+     *
+     * @param alos
+     *            the beginning of the Jewish day. If Kidush Levana occurs during the day (starting at _alos_ and ending
+     *            at _tzais_), the time returned will be _tzais_. If either the _alos_ or _tzais_ parameters
+     *            are null, no daytime adjustment will be made.
+     * @param tzais
+     *            the end of the Jewish day. If _Kidush Levana_ occurs during the day (starting at _alos_ and ending at
+     *            _tzais_), the time returned will be _tzais_. If either the _alos_ or _tzais_ parameters
+     *            are null, no daytime adjustment will be made.
+     *
+     * @return the Date representing the moment 3 days after the molad. If the time occurs between _alos_ and
+     *         _tzais_, _tzais_ will be returned. If the _zman_ will not occur on this day, a
+     *         <code>null</code> will be returned.
+     */
+    getTchilasZmanKidushLevana3Days(alos?: Temporal.ZonedDateTime | null, tzais?: Temporal.ZonedDateTime | null): Temporal.ZonedDateTime | null;
+    /**
+     * Returns the point in time of _Molad_ as a <code>Date</code> Object. For the traditional day of week, hour,
+     * minute and chalakim, {@link Molad.getInstant()} and the not yet completed
+     * {@link HebrewDateFormatter} that will have formatting for this.
+     *
+     * @return the Date representing the moment of the molad. If the _molad_ does not occur on this day, a
+     *         <code>null</code> will be returned.
+     *
+     */
+    getZmanMolad(): Temporal.ZonedDateTime | null;
+    /**
+     * Returns the earliest time of _Kiddush Levana_ according to the opinions that it should not be said until 7
+     * days after the _molad_. The time will be returned even if it occurs during the day when _Kiddush Levana_
+     * can't be recited. Use {@link #getTchilasZmanKidushLevana7Days(Date, Date)} if you want to limit the time to night hours.
+     *
+     * @return the Date representing the moment 7 days after the molad regardless of it is day or night. If the _zman_
+     *         will not occur on this day, a <code>null</code> will be returned.
+     */
+    getTchilasZmanKidushLevana7Days(alos?: Temporal.ZonedDateTime | null, tzais?: Temporal.ZonedDateTime | null): Temporal.ZonedDateTime | null;
     /**
      * Uses timeFormat to return a date like '20:34'.
      * Returns `XX:XX` if the date is invalid.