@hebcal/core 6.5.3 → 6.7.0

package/dist/src/molad.d.ts

@@ -1,164 +0,0 @@
-import './temporal-shim';
-import { Event } from './event';
-import { CalOptions } from './CalOptions';
-import { HDate } from '@hebcal/hdate';
-import './locale';
-/**
- * Represents a *molad* — the calculated moment when the new moon is "born"
- * for a given Hebrew month.
- *
- * The molad is announced in synagogue on Shabbat Mevarchim (the Shabbat
- * before Rosh Chodesh) and is the anchor point for Kiddush Levana zmanim.
- * Calculations use the traditional chalakim arithmetic
- * (1 hour = 1080 chalakim) anchored to *Molad Tohu BaHaRaD*.
- *
- * @example
- * import {Molad, months} from '@hebcal/core';
- * const m = new Molad(5784, months.NISAN);
- * console.log(m.getMonthName()); // 'Nisan'
- * console.log(m.getHour(), m.getMinutes(), m.getChalakim()); // e.g. 1 31 12
- * console.log(m.render('en')); // 'Molad Nisan: Mon, 1:31am and 12 chalakim'
- */
-export declare class Molad {
-    private readonly m;
-    private readonly year;
-    private readonly month;
-    private instant?;
-    /**
-     * Calculates the molad for a given Hebrew year and month.
-     * @param year Hebrew year
-     * @param month 1=NISAN, 7=TISHREI (uses Nisan-based numbering)
-     */
-    constructor(year: number, month: number);
-    /**
-     * The exact Hebrew date of the molad, which often falls on the
-     * 28th or 30th of the preceeding month, occasionally on the first of the
-     * month, and in extremely rare circumstances the 27th of the month.
-     * - Molad Shevat 5541 occured on 27 Tevet / 1781-01-24T19:57:20.170Z
-     * - Molad Shevat 5788 will occur on 27 Tevet / 2028-01-26T19:07:03.504Z
-     * - Molad Nissan 5866 will occur on 27 Adar II / 2106-04-03T21:08:46.837Z
-     */
-    getMoladDate(): HDate;
-    /**
-     * The year of the molad (as constructed)
-     */
-    getYear(): number;
-    /**
-     * The month (1=NISSAN, 7=TISHREI) as constructed
-     */
-    getMonth(): number;
-    /**
-     * Returns a transliterated string name of the molad's Hebrew month,
-     * for example 'Elul' or 'Cheshvan'.
-     */
-    getMonthName(): string;
-    /**
-     * @returns Day of Week (0=Sunday, 6=Saturday)
-     */
-    getDow(): number;
-    /**
-     * @returns hour of day (0-23)
-     */
-    getHour(): number;
-    /**
-     * @returns minutes past hour (0-59)
-     */
-    getMinutes(): number;
-    /**
-     * @returns parts of a minute (0-17)
-     */
-    getChalakim(): number;
-    /**
-     * Returns the molad in Standard Time in Yerushalayim 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.
-     *
-     * The returned value is cached after the first call.
-     * @example
-     * import {Molad, months} from '@hebcal/core';
-     * const m = new Molad(5784, months.NISAN);
-     * const zdt = m.getInstant();
-     * console.log(zdt.toString()); // e.g. '2024-04-08T17:21:13.333+00:00[UTC]'
-     * @return the `Temporal.ZonedDateTime` representing the moment of the molad
-     */
-    getInstant(): Temporal.ZonedDateTime;
-    /**
-     * Returns the earliest time of _Kiddush Levana_ calculated as 3 days after the molad. This method returns the time
-     * even if it is during the day when _Kiddush Levana_ can't be said. Callers of this method should consider
-     * displaying the next _tzais_ if the zman is between _alos_ and _tzais_.
-     *
-     * @return the Temporal.ZonedDateTime representing the moment 3 days after the molad.
-     */
-    getTchilasZmanKidushLevana3Days(): Temporal.ZonedDateTime;
-    /**
-     * Returns the earliest time of Kiddush Levana calculated as 7 days after the molad as mentioned by the <a
-     * href="https://en.wikipedia.org/wiki/Yosef_Karo">Mechaber</a>. See the <a
-     * href="https://en.wikipedia.org/wiki/Yoel_Sirkis">Bach's</a> opinion on this time. This method returns the time
-     * even if it is during the day when _Kiddush Levana_ can't be said. Callers of this method should consider
-     * displaying the next _tzais_ if the zman is between _alos_ and _tzais_.
-     *
-     * @return the Temporal.ZonedDateTime representing the moment 7 days after the molad.
-     */
-    getTchilasZmanKidushLevana7Days(): Temporal.ZonedDateTime;
-    /**
-     * 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. This method returns the time
-     * even if it is during the day when _Kiddush Levana_ can't be said. Callers of this method should consider
-     * displaying _alos_ before this time if the zman is between _alos_ and _tzais_.
-     *
-     * @return the Temporal.ZonedDateTime representing the moment halfway between molad and molad.
-     */
-    getSofZmanKidushLevanaBetweenMoldos(): Temporal.ZonedDateTime;
-    /**
-     * Returns the latest time of Kiddush Levana calculated as 15 days after the molad. This is the opinion brought down
-     * in 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 Molad.getSofZmanKidushLevanaBetweenMoldos() half way between molad and mold} is of the opinion that Mechaber
-     * agrees to his opinion. Also see the Aruch Hashulchan. For additional details on the subject, See Rabbi Dovid
-     * Heber's very detailed writeup in Siman Daled (chapter 4) of <a
-     * href="https://www.worldcat.org/oclc/461326125">Shaarei Zmanim</a>. This method returns the time even if it is during
-     * the day when _Kiddush Levana_ can't be said. Callers of this method should consider displaying _alos_
-     * before this time if the zman is between _alos_ and _tzais_.
-     *
-     * @return the Temporal.ZonedDateTime representing the moment 15 days after the molad.
-     */
-    getSofZmanKidushLevana15Days(): Temporal.ZonedDateTime;
-    /**
-     * Returns a human-readable, localized string announcing the molad —
-     * suitable for use on Shabbat Mevarchim. The format includes the Hebrew
-     * month name, day of week, hour : minute, and chalakim if non-zero.
-     *
-     * Time format honors `options.hour12` and `options.location` (12-hour vs.
-     * 24-hour); see {@link HebrewCalendar.reformatTimeStr}.
-     * @example
-     * import {Molad, months} from '@hebcal/core';
-     * const m = new Molad(5784, months.NISAN);
-     * m.render('en', {hour12: true});
-     * // => 'Molad Nisan: Mon, 7:21pm and 6 chalakim'
-     * m.render('he');
-     * // => 'מוֹלָד נִיסָן יִהְיֶה בַּיּוֹם שֵׁנִי בשָׁבוּעַ, …'
-     * @param [locale] Optional locale name (defaults to empty locale)
-     * @param options used for time formatting (12-hour vs 24-hour)
-     */
-    render(locale?: string, options?: CalOptions): string;
-}
-/** Represents a Molad announcement on Shabbat Mevarchim */
-export declare class MoladEvent extends Event {
-    readonly molad: Molad;
-    private readonly options;
-    /**
-     * @param date Hebrew date event occurs
-     * @param hyear molad year
-     * @param hmonth molad month
-     * @param options
-     */
-    constructor(date: HDate, hyear: number, hmonth: number, options: CalOptions);
-    /**
-     * @param [locale] Optional locale name (defaults to empty locale)
-     */
-    render(locale?: string): string;
-}

package/dist/src/molad.js

@@ -1,297 +0,0 @@
-import './temporal-shim';
-import { Event, flags } from './event';
-import { HDate, Locale, pad2 } from '@hebcal/hdate';
-import { reformatTimeStr } from './reformatTimeStr';
-import { calculateMolad } from './moladBase';
-import { getMoladAsDate } from './moladDate';
-import './locale'; // Adds Hebrew and Ashkenazic translations
-const enDoW = [
-    'Sunday',
-    'Monday',
-    'Tuesday',
-    'Wednesday',
-    'Thursday',
-    'Friday',
-    'Saturday',
-];
-const heDayNames = [
-    'רִאשׁוֹן',
-    'שֵׁנִי',
-    'שְׁלִישִׁי',
-    'רְבִיעִי',
-    'חֲמִישִׁי',
-    'שִׁישִּׁי',
-    'שַׁבָּת',
-];
-const frDoW = [
-    'Dimanche',
-    'Lundi',
-    'Mardi',
-    'Mercredi',
-    'Jeudi',
-    'Vendredi',
-    'Samedi',
-];
-const night = 'בַּלַּ֥יְלָה';
-function getDayNames(locale) {
-    if (Locale.isHebrewLocale(locale)) {
-        return heDayNames;
-    }
-    else if (locale === 'fr') {
-        return frDoW;
-    }
-    return enDoW;
-}
-function getHebrewTimeOfDay(hour) {
-    if (hour < 5)
-        return night;
-    else if (hour < 12)
-        return 'בַּבֹּקֶר';
-    else if (hour < 17)
-        return 'בַּצׇּהֳרַיִים';
-    else if (hour < 21)
-        return 'בָּעֶרֶב';
-    return night;
-}
-/**
- * Represents a *molad* — the calculated moment when the new moon is "born"
- * for a given Hebrew month.
- *
- * The molad is announced in synagogue on Shabbat Mevarchim (the Shabbat
- * before Rosh Chodesh) and is the anchor point for Kiddush Levana zmanim.
- * Calculations use the traditional chalakim arithmetic
- * (1 hour = 1080 chalakim) anchored to *Molad Tohu BaHaRaD*.
- *
- * @example
- * import {Molad, months} from '@hebcal/core';
- * const m = new Molad(5784, months.NISAN);
- * console.log(m.getMonthName()); // 'Nisan'
- * console.log(m.getHour(), m.getMinutes(), m.getChalakim()); // e.g. 1 31 12
- * console.log(m.render('en')); // 'Molad Nisan: Mon, 1:31am and 12 chalakim'
- */
-export class Molad {
-    m;
-    year;
-    month;
-    instant;
-    /**
-     * Calculates the molad for a given Hebrew year and month.
-     * @param year Hebrew year
-     * @param month 1=NISAN, 7=TISHREI (uses Nisan-based numbering)
-     */
-    constructor(year, month) {
-        this.m = calculateMolad(year, month);
-        this.year = year;
-        this.month = month;
-    }
-    /**
-     * The exact Hebrew date of the molad, which often falls on the
-     * 28th or 30th of the preceeding month, occasionally on the first of the
-     * month, and in extremely rare circumstances the 27th of the month.
-     * - Molad Shevat 5541 occured on 27 Tevet / 1781-01-24T19:57:20.170Z
-     * - Molad Shevat 5788 will occur on 27 Tevet / 2028-01-26T19:07:03.504Z
-     * - Molad Nissan 5866 will occur on 27 Adar II / 2106-04-03T21:08:46.837Z
-     */
-    getMoladDate() {
-        return this.m.hdate;
-    }
-    /**
-     * The year of the molad (as constructed)
-     */
-    getYear() {
-        return this.year;
-    }
-    /**
-     * The month (1=NISSAN, 7=TISHREI) as constructed
-     */
-    getMonth() {
-        return this.month;
-    }
-    /**
-     * Returns a transliterated string name of the molad's Hebrew month,
-     * for example 'Elul' or 'Cheshvan'.
-     */
-    getMonthName() {
-        return HDate.getMonthName(this.month, this.year);
-    }
-    /**
-     * @returns Day of Week (0=Sunday, 6=Saturday)
-     */
-    getDow() {
-        return this.m.hdate.getDay();
-    }
-    /**
-     * @returns hour of day (0-23)
-     */
-    getHour() {
-        return this.m.hour;
-    }
-    /**
-     * @returns minutes past hour (0-59)
-     */
-    getMinutes() {
-        return this.m.minutes;
-    }
-    /**
-     * @returns parts of a minute (0-17)
-     */
-    getChalakim() {
-        return this.m.chalakim;
-    }
-    /**
-     * Returns the molad in Standard Time in Yerushalayim 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.
-     *
-     * The returned value is cached after the first call.
-     * @example
-     * import {Molad, months} from '@hebcal/core';
-     * const m = new Molad(5784, months.NISAN);
-     * const zdt = m.getInstant();
-     * console.log(zdt.toString()); // e.g. '2024-04-08T17:21:13.333+00:00[UTC]'
-     * @return the `Temporal.ZonedDateTime` representing the moment of the molad
-     */
-    getInstant() {
-        this.instant ??= getMoladAsDate(this.m);
-        return this.instant;
-    }
-    /**
-     * Returns the earliest time of _Kiddush Levana_ calculated as 3 days after the molad. This method returns the time
-     * even if it is during the day when _Kiddush Levana_ can't be said. Callers of this method should consider
-     * displaying the next _tzais_ if the zman is between _alos_ and _tzais_.
-     *
-     * @return the Temporal.ZonedDateTime representing the moment 3 days after the molad.
-     */
-    getTchilasZmanKidushLevana3Days() {
-        const zdt = this.getInstant();
-        return zdt.add({ hours: 72 });
-    }
-    /**
-     * Returns the earliest time of Kiddush Levana calculated as 7 days after the molad as mentioned by the <a
-     * href="https://en.wikipedia.org/wiki/Yosef_Karo">Mechaber</a>. See the <a
-     * href="https://en.wikipedia.org/wiki/Yoel_Sirkis">Bach's</a> opinion on this time. This method returns the time
-     * even if it is during the day when _Kiddush Levana_ can't be said. Callers of this method should consider
-     * displaying the next _tzais_ if the zman is between _alos_ and _tzais_.
-     *
-     * @return the Temporal.ZonedDateTime representing the moment 7 days after the molad.
-     */
-    getTchilasZmanKidushLevana7Days() {
-        const zdt = this.getInstant();
-        return zdt.add({ hours: 168 });
-    }
-    /**
-     * 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. This method returns the time
-     * even if it is during the day when _Kiddush Levana_ can't be said. Callers of this method should consider
-     * displaying _alos_ before this time if the zman is between _alos_ and _tzais_.
-     *
-     * @return the Temporal.ZonedDateTime representing the moment halfway between molad and molad.
-     */
-    getSofZmanKidushLevanaBetweenMoldos() {
-        const zdt = this.getInstant();
-        // add half the time between molad and molad (half of 29 days, 12 hours and 793 chalakim (44 minutes, 3.3
-        // seconds), or 14 days, 18 hours, 22 minutes and 666 milliseconds). Add it as hours, not days, to avoid
-        // DST/ST crossover issues.
-        return zdt.add({
-            hours: 24 * 14 + 18,
-            minutes: 22,
-            seconds: 1,
-            milliseconds: 666,
-        });
-    }
-    /**
-     * Returns the latest time of Kiddush Levana calculated as 15 days after the molad. This is the opinion brought down
-     * in 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 Molad.getSofZmanKidushLevanaBetweenMoldos() half way between molad and mold} is of the opinion that Mechaber
-     * agrees to his opinion. Also see the Aruch Hashulchan. For additional details on the subject, See Rabbi Dovid
-     * Heber's very detailed writeup in Siman Daled (chapter 4) of <a
-     * href="https://www.worldcat.org/oclc/461326125">Shaarei Zmanim</a>. This method returns the time even if it is during
-     * the day when _Kiddush Levana_ can't be said. Callers of this method should consider displaying _alos_
-     * before this time if the zman is between _alos_ and _tzais_.
-     *
-     * @return the Temporal.ZonedDateTime representing the moment 15 days after the molad.
-     */
-    getSofZmanKidushLevana15Days() {
-        const zdt = this.getInstant();
-        // 15 days after the molad. Add it as hours, not days, to avoid DST/ST crossover issues.
-        return zdt.add({ hours: 24 * 15 });
-    }
-    /**
-     * Returns a human-readable, localized string announcing the molad —
-     * suitable for use on Shabbat Mevarchim. The format includes the Hebrew
-     * month name, day of week, hour : minute, and chalakim if non-zero.
-     *
-     * Time format honors `options.hour12` and `options.location` (12-hour vs.
-     * 24-hour); see {@link HebrewCalendar.reformatTimeStr}.
-     * @example
-     * import {Molad, months} from '@hebcal/core';
-     * const m = new Molad(5784, months.NISAN);
-     * m.render('en', {hour12: true});
-     * // => 'Molad Nisan: Mon, 7:21pm and 6 chalakim'
-     * m.render('he');
-     * // => 'מוֹלָד נִיסָן יִהְיֶה בַּיּוֹם שֵׁנִי בשָׁבוּעַ, …'
-     * @param [locale] Optional locale name (defaults to empty locale)
-     * @param options used for time formatting (12-hour vs 24-hour)
-     */
-    render(locale, options) {
-        const monthName = Locale.gettext(this.getMonthName(), locale);
-        const dayNames = getDayNames(locale);
-        const dow = dayNames[this.getDow()];
-        const minutes = this.getMinutes();
-        const hour = this.getHour();
-        const chalakim = this.getChalakim();
-        const moladStr = Locale.gettext('Molad', locale);
-        const minutesStr = Locale.lookupTranslation('min', locale) ?? 'minutes';
-        const chalakimStr = Locale.gettext('chalakim', locale);
-        const and = Locale.gettext('and', locale);
-        if (Locale.isHebrewLocale(locale)) {
-            const ampm = getHebrewTimeOfDay(hour);
-            let result = `${moladStr} ${monthName} יִהְיֶה בַּיּוֹם ${dow} בשָׁבוּעַ, ` +
-                `בְּשָׁעָה ${hour} ${ampm}, ` +
-                `ו-${minutes} ${minutesStr}`;
-            if (chalakim !== 0) {
-                result += ` ו-${chalakim} ${chalakimStr}`;
-            }
-            if (locale.toLocaleLowerCase() === 'he-x-nonikud') {
-                return Locale.hebrewStripNikkud(result);
-            }
-            return result;
-        }
-        const fmtTime = reformatTimeStr(`${hour}:${pad2(minutes)}`, 'pm', options);
-        const month = monthName.replace(/'/g, '’');
-        const result = `${moladStr} ${month}: ${dow}, ${fmtTime}`;
-        if (chalakim === 0) {
-            return result;
-        }
-        return result + ` ${and} ${chalakim} ${chalakimStr}`;
-    }
-}
-/** Represents a Molad announcement on Shabbat Mevarchim */
-export class MoladEvent extends Event {
-    molad;
-    options;
-    /**
-     * @param date Hebrew date event occurs
-     * @param hyear molad year
-     * @param hmonth molad month
-     * @param options
-     */
-    constructor(date, hyear, hmonth, options) {
-        const m = new Molad(hyear, hmonth);
-        const monthName = m.getMonthName();
-        super(date, `Molad ${monthName} ${hyear}`, flags.MOLAD);
-        this.molad = m;
-        this.options = options;
-    }
-    /**
-     * @param [locale] Optional locale name (defaults to empty locale)
-     */
-    render(locale) {
-        return this.molad.render(locale, this.options);
-    }
-}

package/dist/src/moladBase.d.ts

@@ -1,15 +0,0 @@
-import { HDate } from '@hebcal/hdate';
-/**
- * Represents a molad, the moment when the new moon is "born"
- */
-export type MoladBase = {
-    /** Hebrew date */
-    readonly hdate: HDate;
-    /** hour of day (0-23) */
-    readonly hour: number;
-    /** minutes past hour (0-59) */
-    readonly minutes: number;
-    /** parts of a minute (0-17) */
-    readonly chalakim: number;
-};
-export declare function calculateMolad(year: number, month: number): MoladBase;

package/dist/src/moladBase.js

@@ -1,78 +0,0 @@
-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

@@ -1,12 +0,0 @@
-import './temporal-shim';
-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

@@ -1,58 +0,0 @@
-import './temporal-shim';
-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');
-}