@hebcal/core 3.39.2 → 3.41.1

package/dist/hdate0-bundle.mjs

@@ -1,457 +0,0 @@
-/*! @hebcal/core v3.39.1 */
-/*
- * More minimal greg routines
- */
-
-/** @private */
-const lengths = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-/** @private */
-const monthLengths = [
-  lengths,
-  lengths.slice(),
-];
-monthLengths[1][2] = 29;
-
-/**
- * @private
- * @param {number} x
- * @param {number} y
- * @return {number}
- */
-function mod(x, y) {
-  return x - y * Math.floor(x / y);
-}
-
-/**
- * @private
- * @param {number} x
- * @param {number} y
- * @return {number}
- */
-function quotient(x, y) {
-  return Math.floor(x / y);
-}
-
-/**
- * Returns true if the Gregorian year is a leap year
- * @private
- * @param {number} year Gregorian year
- * @return {boolean}
- */
-function isLeapYear$1(year) {
-  return !(year % 4) && (!!(year % 100) || !(year % 400));
-}
-
-/**
- * Returns true if the object is a Javascript Date
- * @private
- * @param {Object} obj
- * @return {boolean}
- */
-function isDate(obj) {
-  return typeof obj === 'object' && Date.prototype === obj.__proto__;
-}
-
-/**
- * Returns number of days since January 1 of that year
- * @private
- * @param {Date} date Gregorian date
- * @return {number}
- */
-function dayOfYear(date) {
-  if (!isDate(date)) {
-    throw new TypeError(`Argument not a Date: ${date}`);
-  }
-  let doy = date.getDate() + 31 * date.getMonth();
-  if (date.getMonth() > 1) {
-    // FEB
-    doy -= Math.floor((4 * (date.getMonth() + 1) + 23) / 10);
-    if (isLeapYear$1(date.getFullYear())) {
-      doy++;
-    }
-  }
-  return doy;
-}
-
-/**
- * Converts Gregorian date to absolute R.D. (Rata Die) days
- * @private
- * @param {Date} date Gregorian date
- * @return {number}
- */
-function greg2abs(date) {
-  if (!isDate(date)) {
-    throw new TypeError(`Argument not a Date: ${date}`);
-  }
-  const year = date.getFullYear() - 1;
-  return (
-    dayOfYear(date) + // days this year
-    365 * year + // + days in prior years
-    (Math.floor(year / 4) - // + Julian Leap years
-    Math.floor(year / 100) + // - century years
-    Math.floor(year / 400))
-  ); // + Gregorian leap years
-}
-
-/**
- * @private
- * @param {number} abs - R.D. number of days
- * @return {number}
- */
-function yearFromFixed(abs) {
-  const l0 = abs - 1;
-  const n400 = quotient(l0, 146097);
-  const d1 = mod(l0, 146097);
-  const n100 = quotient(d1, 36524);
-  const d2 = mod(d1, 36524);
-  const n4 = quotient(d2, 1461);
-  const d3 = mod(d2, 1461);
-  const n1 = quotient(d3, 365);
-  const year = 400 * n400 + 100 * n100 + 4 * n4 + n1;
-  return n100 != 4 && n1 != 4 ? year + 1 : year;
-}
-
-/**
- * @private
- * @param {number} year
- * @param {number} month
- * @param {number} day
- * @return {number}
- */
-function toFixed(year, month, day) {
-  const py = year - 1;
-  return 0 +
-    365 * py +
-    quotient(py, 4) -
-    quotient(py, 100) +
-    quotient(py, 400) +
-    quotient((367 * month - 362), 12) +
-    Math.floor(month <= 2 ? 0 : (isLeapYear$1(year) ? -1 : -2)) +
-    day;
-}
-
-/**
- * Converts from Rata Die (R.D. number) to Gregorian date.
- * See the footnote on page 384 of ``Calendrical Calculations, Part II:
- * Three Historical Calendars'' by E. M. Reingold,  N. Dershowitz, and S. M.
- * Clamen, Software--Practice and Experience, Volume 23, Number 4
- * (April, 1993), pages 383-404 for an explanation.
- * @private
- * @param {number} abs - R.D. number of days
- * @return {Date}
- */
-function abs2greg(abs) {
-  if (typeof abs !== 'number') {
-    throw new TypeError(`Argument not a Number: ${abs}`);
-  }
-  abs = Math.trunc(abs);
-  const year = yearFromFixed(abs);
-  const priorDays = abs - toFixed(year, 1, 1);
-  const correction = abs < toFixed(year, 3, 1) ? 0 : (isLeapYear$1(year) ? 1 : 2);
-  const month = quotient((12 * (priorDays + correction) + 373), 367);
-  const day = abs - toFixed(year, month, 1) + 1;
-  const dt = new Date(year, month - 1, day);
-  if (year < 100 && year >= 0) {
-    dt.setFullYear(year);
-  }
-  return dt;
-}
-
-/*
- * More minimal HDate
- */
-
-const NISAN = 1;
-const IYYAR = 2;
-// const SIVAN = 3;
-const TAMUZ = 4;
-// const AV = 5;
-const ELUL = 6;
-const TISHREI = 7;
-const CHESHVAN = 8;
-const KISLEV = 9;
-const TEVET = 10;
-// const SHVAT = 11;
-const ADAR_I = 12;
-const ADAR_II = 13;
-
-/**
- * Hebrew months of the year (NISAN=1, TISHREI=7)
- * @readonly
- * @enum {number}
- */
-const months = {
-  /** Nissan / ניסן */
-  NISAN: 1,
-  /** Iyyar / אייר */
-  IYYAR: 2,
-  /** Sivan / סיון */
-  SIVAN: 3,
-  /** Tamuz (sometimes Tammuz) / תמוז */
-  TAMUZ: 4,
-  /** Av / אב */
-  AV: 5,
-  /** Elul / אלול */
-  ELUL: 6,
-  /** Tishrei / תִשְׁרֵי */
-  TISHREI: 7,
-  /** Cheshvan / חשון */
-  CHESHVAN: 8,
-  /** Kislev / כסלו */
-  KISLEV: 9,
-  /** Tevet / טבת */
-  TEVET: 10,
-  /** Sh'vat / שבט */
-  SHVAT: 11,
-  /** Adar or Adar Rishon / אדר */
-  ADAR_I: 12,
-  /** Adar Sheini (only on leap years) / אדר ב׳ */
-  ADAR_II: 13,
-};
-
-const monthNames0 = [
-  '',
-  'Nisan',
-  'Iyyar',
-  'Sivan',
-  'Tamuz',
-  'Av',
-  'Elul',
-  'Tishrei',
-  'Cheshvan',
-  'Kislev',
-  'Tevet',
-  'Sh\'vat',
-];
-
-/**
- * Transliterations of Hebrew month names.
- * Regular years are index 0 and leap years are index 1.
- * @private
- */
-const monthNames = [
-  monthNames0.concat([
-    'Adar',
-    'Nisan',
-  ]),
-  monthNames0.concat([
-    'Adar I',
-    'Adar II',
-    'Nisan',
-  ]),
-];
-
-const edCache = Object.create(null);
-
-const EPOCH = -1373428;
-// Avg year length in the cycle (19 solar years with 235 lunar months)
-const AVG_HEBYEAR_DAYS = 365.24682220597794;
-
-/**
- * Converts Hebrew date to R.D. (Rata Die) fixed days.
- * R.D. 1 is the imaginary date Monday, January 1, 1 on the Gregorian
- * Calendar.
- * @private
- * @param {number} year Hebrew year
- * @param {number} month Hebrew month
- * @param {number} day Hebrew date (1-30)
- * @return {number}
- */
-function hebrew2abs(year, month, day) {
-  let tempabs = day;
-
-  if (month < TISHREI) {
-    for (let m = TISHREI; m <= monthsInYear(year); m++) {
-      tempabs += daysInMonth(m, year);
-    }
-    for (let m = NISAN; m < month; m++) {
-      tempabs += daysInMonth(m, year);
-    }
-  } else {
-    for (let m = TISHREI; m < month; m++) {
-      tempabs += daysInMonth(m, year);
-    }
-  }
-
-  return EPOCH + elapsedDays(year) + tempabs - 1;
-}
-
-/**
- * @private
- * @param {number} year
- * @return {number}
- */
-function newYear(year) {
-  return EPOCH + elapsedDays(year);
-}
-
-/**
- * Converts absolute R.D. days to Hebrew date
- * @private
- * @param {number} abs absolute R.D. days
- * @return {SimpleHebrewDate}
- */
-function abs2hebrew(abs) {
-  if (typeof abs !== 'number' || isNaN(abs)) {
-    throw new TypeError(`invalid parameter to abs2hebrew ${abs}`);
-  }
-  abs = Math.trunc(abs);
-
-  // first, quickly approximate year
-  let year = Math.floor((abs - EPOCH) / AVG_HEBYEAR_DAYS);
-  while (newYear(year) <= abs) {
-    ++year;
-  }
-  --year;
-
-  let month = abs < hebrew2abs(year, 1, 1) ? 7 : 1;
-  while (abs > hebrew2abs(year, month, daysInMonth(month, year))) {
-    ++month;
-  }
-
-  const day = 1 + abs - hebrew2abs(year, month, 1);
-  return {yy: year, mm: month, dd: day};
-}
-
-/**
- * Returns true if Hebrew year is a leap year
- * @private
- * @param {number} year Hebrew year
- * @return {boolean}
- */
-function isLeapYear(year) {
-  return (1 + year * 7) % 19 < 7;
-}
-
-/**
- * Number of months in this Hebrew year (either 12 or 13 depending on leap year)
- * @private
- * @param {number} year Hebrew year
- * @return {number}
- */
-function monthsInYear(year) {
-  return 12 + isLeapYear(year); // boolean is cast to 1 or 0
-}
-
-/**
- * Number of days in Hebrew month in a given year (29 or 30)
- * @private
- * @param {number} month Hebrew month (e.g. months.TISHREI)
- * @param {number} year Hebrew year
- * @return {number}
- */
-function daysInMonth(month, year) {
-  switch (month) {
-    case IYYAR:
-    case TAMUZ:
-    case ELUL:
-    case TEVET:
-    case ADAR_II:
-      return 29;
-  }
-  if ((month === ADAR_I && !isLeapYear(year)) ||
-      (month === CHESHVAN && !longCheshvan(year)) ||
-      (month === KISLEV && shortKislev(year))) {
-    return 29;
-  } else {
-    return 30;
-  }
-}
-
-/**
- * Returns a transliterated string name of Hebrew month in year,
- * for example 'Elul' or 'Cheshvan'.
- * @private
- * @param {number} month Hebrew month (e.g. months.TISHREI)
- * @param {number} year Hebrew year
- * @return {string}
- */
-function getMonthName(month, year) {
-  if (typeof month !== 'number' || isNaN(month) || month < 1 || month > 14) {
-    throw new TypeError(`bad month argument ${month}`);
-  }
-  return monthNames[+isLeapYear(year)][month];
-}
-
-/**
- * Days from sunday prior to start of Hebrew calendar to mean
- * conjunction of Tishrei in Hebrew YEAR
- * @private
- * @param {number} year Hebrew year
- * @return {number}
- */
-function elapsedDays(year) {
-  const elapsed = edCache[year] = edCache[year] || elapsedDays0(year);
-  return elapsed;
-}
-
-/**
- * Days from sunday prior to start of Hebrew calendar to mean
- * conjunction of Tishrei in Hebrew YEAR
- * @private
- * @param {number} year Hebrew year
- * @return {number}
- */
-function elapsedDays0(year) {
-  const prevYear = year - 1;
-  const mElapsed = 235 * Math.floor(prevYear / 19) + // Months in complete 19 year lunar (Metonic) cycles so far
-      12 * (prevYear % 19) + // Regular months in this cycle
-      Math.floor(((prevYear % 19) * 7 + 1) / 19); // Leap months this cycle
-
-  const pElapsed = 204 + 793 * (mElapsed % 1080);
-
-  const hElapsed = 5 +
-      12 * mElapsed +
-      793 * Math.floor(mElapsed / 1080) +
-      Math.floor(pElapsed / 1080);
-
-  const parts = (pElapsed % 1080) + 1080 * (hElapsed % 24);
-
-  const day = 1 + 29 * mElapsed + Math.floor(hElapsed / 24);
-  const altDay = day +
-      (parts >= 19440 ||
-        (2 === day % 7 && parts >= 9924 && !isLeapYear(year)) ||
-        (1 === day % 7 && parts >= 16789 && isLeapYear(prevYear)));
-
-  return altDay + (altDay % 7 === 0 || altDay % 7 === 3 || altDay % 7 === 5);
-}
-
-/**
- * Number of days in the hebrew YEAR.
- * A common Hebrew calendar year can have a length of 353, 354 or 355 days
- * A leap Hebrew calendar year can have a length of 383, 384 or 385 days
- * @private
- * @param {number} year Hebrew year
- * @return {number}
- */
-function daysInYear(year) {
-  return elapsedDays(year + 1) - elapsedDays(year);
-}
-
-/**
- * true if Cheshvan is long in Hebrew year
- * @private
- * @param {number} year Hebrew year
- * @return {boolean}
- */
-function longCheshvan(year) {
-  return daysInYear(year) % 10 === 5;
-}
-
-/**
- * true if Kislev is short in Hebrew year
- * @private
- * @param {number} year Hebrew year
- * @return {boolean}
- */
-function shortKislev(year) {
-  return daysInYear(year) % 10 === 3;
-}
-
-const hdate = {
-  abs2hebrew, daysInMonth, daysInYear, getMonthName, hebrew2abs,
-  isLeapYear, longCheshvan, months,
-  monthsInYear, shortKislev,
-};
-
-export { abs2greg, greg2abs, hdate };