@hebcal/core 5.4.4 → 5.4.5

package/dist/index.cjs

@@ -1,4 +1,4 @@
-/*! @hebcal/core v5.4.4 */
+/*! @hebcal/core v5.4.5 */
 'use strict';
 
 /* eslint-disable @typescript-eslint/no-namespace, no-inner-declarations */
@@ -8684,13 +8684,6 @@ class OmerEvent extends Event {
 }
 
 class QuickLRU extends Map {
-	#size = 0;
-	#cache = new Map();
-	#oldCache = new Map();
-	#maxSize;
-	#maxAge;
-	#onEviction;
-
 	constructor(options = {}) {
 		super();
 
@@ -8702,30 +8695,30 @@ class QuickLRU extends Map {
 			throw new TypeError('`maxAge` must be a number greater than 0');
 		}
 
-		this.#maxSize = options.maxSize;
-		this.#maxAge = options.maxAge || Number.POSITIVE_INFINITY;
-		this.#onEviction = options.onEviction;
-	}
-
-	// For tests.
-	get __oldCache() {
-		return this.#oldCache;
+		// TODO: Use private class fields when ESLint supports them.
+		this.maxSize = options.maxSize;
+		this.maxAge = options.maxAge || Number.POSITIVE_INFINITY;
+		this.onEviction = options.onEviction;
+		this.cache = new Map();
+		this.oldCache = new Map();
+		this._size = 0;
 	}
 
-	#emitEvictions(cache) {
-		if (typeof this.#onEviction !== 'function') {
+	// TODO: Use private class methods when targeting Node.js 16.
+	_emitEvictions(cache) {
+		if (typeof this.onEviction !== 'function') {
 			return;
 		}
 
 		for (const [key, item] of cache) {
-			this.#onEviction(key, item.value);
+			this.onEviction(key, item.value);
 		}
 	}
 
-	#deleteIfExpired(key, item) {
+	_deleteIfExpired(key, item) {
 		if (typeof item.expiry === 'number' && item.expiry <= Date.now()) {
-			if (typeof this.#onEviction === 'function') {
-				this.#onEviction(key, item.value);
+			if (typeof this.onEviction === 'function') {
+				this.onEviction(key, item.value);
 			}
 
 			return this.delete(key);
@@ -8734,54 +8727,54 @@ class QuickLRU extends Map {
 		return false;
 	}
 
-	#getOrDeleteIfExpired(key, item) {
-		const deleted = this.#deleteIfExpired(key, item);
+	_getOrDeleteIfExpired(key, item) {
+		const deleted = this._deleteIfExpired(key, item);
 		if (deleted === false) {
 			return item.value;
 		}
 	}
 
-	#getItemValue(key, item) {
-		return item.expiry ? this.#getOrDeleteIfExpired(key, item) : item.value;
+	_getItemValue(key, item) {
+		return item.expiry ? this._getOrDeleteIfExpired(key, item) : item.value;
 	}
 
-	#peek(key, cache) {
+	_peek(key, cache) {
 		const item = cache.get(key);
 
-		return this.#getItemValue(key, item);
+		return this._getItemValue(key, item);
 	}
 
-	#set(key, value) {
-		this.#cache.set(key, value);
-		this.#size++;
+	_set(key, value) {
+		this.cache.set(key, value);
+		this._size++;
 
-		if (this.#size >= this.#maxSize) {
-			this.#size = 0;
-			this.#emitEvictions(this.#oldCache);
-			this.#oldCache = this.#cache;
-			this.#cache = new Map();
+		if (this._size >= this.maxSize) {
+			this._size = 0;
+			this._emitEvictions(this.oldCache);
+			this.oldCache = this.cache;
+			this.cache = new Map();
 		}
 	}
 
-	#moveToRecent(key, item) {
-		this.#oldCache.delete(key);
-		this.#set(key, item);
+	_moveToRecent(key, item) {
+		this.oldCache.delete(key);
+		this._set(key, item);
 	}
 
-	* #entriesAscending() {
-		for (const item of this.#oldCache) {
+	* _entriesAscending() {
+		for (const item of this.oldCache) {
 			const [key, value] = item;
-			if (!this.#cache.has(key)) {
-				const deleted = this.#deleteIfExpired(key, value);
+			if (!this.cache.has(key)) {
+				const deleted = this._deleteIfExpired(key, value);
 				if (deleted === false) {
 					yield item;
 				}
 			}
 		}
 
-		for (const item of this.#cache) {
+		for (const item of this.cache) {
 			const [key, value] = item;
-			const deleted = this.#deleteIfExpired(key, value);
+			const deleted = this._deleteIfExpired(key, value);
 			if (deleted === false) {
 				yield item;
 			}
@@ -8789,72 +8782,73 @@ class QuickLRU extends Map {
 	}
 
 	get(key) {
-		if (this.#cache.has(key)) {
-			const item = this.#cache.get(key);
-			return this.#getItemValue(key, item);
+		if (this.cache.has(key)) {
+			const item = this.cache.get(key);
+
+			return this._getItemValue(key, item);
 		}
 
-		if (this.#oldCache.has(key)) {
-			const item = this.#oldCache.get(key);
-			if (this.#deleteIfExpired(key, item) === false) {
-				this.#moveToRecent(key, item);
+		if (this.oldCache.has(key)) {
+			const item = this.oldCache.get(key);
+			if (this._deleteIfExpired(key, item) === false) {
+				this._moveToRecent(key, item);
 				return item.value;
 			}
 		}
 	}
 
-	set(key, value, {maxAge = this.#maxAge} = {}) {
-		const expiry = typeof maxAge === 'number' && maxAge !== Number.POSITIVE_INFINITY
-			? (Date.now() + maxAge)
-			: undefined;
-
-		if (this.#cache.has(key)) {
-			this.#cache.set(key, {
+	set(key, value, {maxAge = this.maxAge} = {}) {
+		const expiry =
+			typeof maxAge === 'number' && maxAge !== Number.POSITIVE_INFINITY ?
+				Date.now() + maxAge :
+				undefined;
+		if (this.cache.has(key)) {
+			this.cache.set(key, {
 				value,
-				expiry,
+				expiry
 			});
 		} else {
-			this.#set(key, {value, expiry});
+			this._set(key, {value, expiry});
 		}
 
 		return this;
 	}
 
 	has(key) {
-		if (this.#cache.has(key)) {
-			return !this.#deleteIfExpired(key, this.#cache.get(key));
+		if (this.cache.has(key)) {
+			return !this._deleteIfExpired(key, this.cache.get(key));
 		}
 
-		if (this.#oldCache.has(key)) {
-			return !this.#deleteIfExpired(key, this.#oldCache.get(key));
+		if (this.oldCache.has(key)) {
+			return !this._deleteIfExpired(key, this.oldCache.get(key));
 		}
 
 		return false;
 	}
 
 	peek(key) {
-		if (this.#cache.has(key)) {
-			return this.#peek(key, this.#cache);
+		if (this.cache.has(key)) {
+			return this._peek(key, this.cache);
 		}
 
-		if (this.#oldCache.has(key)) {
-			return this.#peek(key, this.#oldCache);
+		if (this.oldCache.has(key)) {
+			return this._peek(key, this.oldCache);
 		}
 	}
 
 	delete(key) {
-		const deleted = this.#cache.delete(key);
+		const deleted = this.cache.delete(key);
 		if (deleted) {
-			this.#size--;
+			this._size--;
 		}
 
-		return this.#oldCache.delete(key) || deleted;
+		return this.oldCache.delete(key) || deleted;
 	}
 
 	clear() {
-		this.#cache.clear();
-		this.#oldCache.clear();
-		this.#size = 0;
+		this.cache.clear();
+		this.oldCache.clear();
+		this._size = 0;
 	}
 
 	resize(newSize) {
@@ -8862,23 +8856,23 @@ class QuickLRU extends Map {
 			throw new TypeError('`maxSize` must be a number greater than 0');
 		}
 
-		const items = [...this.#entriesAscending()];
+		const items = [...this._entriesAscending()];
 		const removeCount = items.length - newSize;
 		if (removeCount < 0) {
-			this.#cache = new Map(items);
-			this.#oldCache = new Map();
-			this.#size = items.length;
+			this.cache = new Map(items);
+			this.oldCache = new Map();
+			this._size = items.length;
 		} else {
 			if (removeCount > 0) {
-				this.#emitEvictions(items.slice(0, removeCount));
+				this._emitEvictions(items.slice(0, removeCount));
 			}
 
-			this.#oldCache = new Map(items.slice(removeCount));
-			this.#cache = new Map();
-			this.#size = 0;
+			this.oldCache = new Map(items.slice(removeCount));
+			this.cache = new Map();
+			this._size = 0;
 		}
 
-		this.#maxSize = newSize;
+		this.maxSize = newSize;
 	}
 
 	* keys() {
@@ -8894,18 +8888,18 @@ class QuickLRU extends Map {
 	}
 
 	* [Symbol.iterator]() {
-		for (const item of this.#cache) {
+		for (const item of this.cache) {
 			const [key, value] = item;
-			const deleted = this.#deleteIfExpired(key, value);
+			const deleted = this._deleteIfExpired(key, value);
 			if (deleted === false) {
 				yield [key, value.value];
 			}
 		}
 
-		for (const item of this.#oldCache) {
+		for (const item of this.oldCache) {
 			const [key, value] = item;
-			if (!this.#cache.has(key)) {
-				const deleted = this.#deleteIfExpired(key, value);
+			if (!this.cache.has(key)) {
+				const deleted = this._deleteIfExpired(key, value);
 				if (deleted === false) {
 					yield [key, value.value];
 				}
@@ -8914,22 +8908,22 @@ class QuickLRU extends Map {
 	}
 
 	* entriesDescending() {
-		let items = [...this.#cache];
+		let items = [...this.cache];
 		for (let i = items.length - 1; i >= 0; --i) {
 			const item = items[i];
 			const [key, value] = item;
-			const deleted = this.#deleteIfExpired(key, value);
+			const deleted = this._deleteIfExpired(key, value);
 			if (deleted === false) {
 				yield [key, value.value];
 			}
 		}
 
-		items = [...this.#oldCache];
+		items = [...this.oldCache];
 		for (let i = items.length - 1; i >= 0; --i) {
 			const item = items[i];
 			const [key, value] = item;
-			if (!this.#cache.has(key)) {
-				const deleted = this.#deleteIfExpired(key, value);
+			if (!this.cache.has(key)) {
+				const deleted = this._deleteIfExpired(key, value);
 				if (deleted === false) {
 					yield [key, value.value];
 				}
@@ -8938,28 +8932,24 @@ class QuickLRU extends Map {
 	}
 
 	* entriesAscending() {
-		for (const [key, value] of this.#entriesAscending()) {
+		for (const [key, value] of this._entriesAscending()) {
 			yield [key, value.value];
 		}
 	}
 
 	get size() {
-		if (!this.#size) {
-			return this.#oldCache.size;
+		if (!this._size) {
+			return this.oldCache.size;
 		}
 
 		let oldCacheSize = 0;
-		for (const key of this.#oldCache.keys()) {
-			if (!this.#cache.has(key)) {
+		for (const key of this.oldCache.keys()) {
+			if (!this.cache.has(key)) {
 				oldCacheSize++;
 			}
 		}
 
-		return Math.min(this.#size + oldCacheSize, this.#maxSize);
-	}
-
-	get maxSize() {
-		return this.#maxSize;
+		return Math.min(this._size + oldCacheSize, this.maxSize);
 	}
 
 	entries() {
@@ -9011,6 +9001,19 @@ class QuickLRU extends Map {
 const INCOMPLETE = 0;
 const REGULAR = 1;
 const COMPLETE = 2;
+function yearType(hyear) {
+    const longC = HDate.longCheshvan(hyear);
+    const shortK = HDate.shortKislev(hyear);
+    if (longC && !shortK) {
+        return COMPLETE;
+    }
+    else if (!longC && shortK) {
+        return INCOMPLETE;
+    }
+    else {
+        return REGULAR;
+    }
+}
 /**
  * Represents Parashah HaShavua for an entire Hebrew year
  */
@@ -9022,11 +9025,6 @@ class Sedra {
      */
     constructor(hyear, il) {
         hyear = +hyear;
-        const longC = HDate.longCheshvan(hyear);
-        const shortK = HDate.shortKislev(hyear);
-        const type = (longC && !shortK) ? COMPLETE :
-            (!longC && shortK) ? INCOMPLETE :
-                REGULAR;
         this.year = hyear;
         const rh0 = new HDate(1, months.TISHREI, hyear);
         const rh = rh0.abs();
@@ -9035,6 +9033,7 @@ class Sedra {
         this.firstSaturday = HDate.dayOnOrBefore(6, rh + 6);
         const leap = +HDate.isLeapYear(hyear);
         this.il = Boolean(il);
+        const type = yearType(hyear);
         let key = `${leap}${rhDay}${type}`;
         if (types[key]) {
             this.theSedraArray = types[key];
@@ -9287,7 +9286,6 @@ const YK = 'Yom Kippur'; // 1
 const SUKKOT = 'Sukkot'; // 0
 const CHMSUKOT = 'Sukkot Shabbat Chol ha-Moed'; // 0
 const SHMINI = 'Shmini Atzeret'; // 0
-const EOY = CHMSUKOT; // always Sukkot day 3, 5 or 6
 const PESACH = 'Pesach'; // 25
 const PESACH1 = 'Pesach I';
 const CHMPESACH = 'Pesach Shabbat Chol ha-Moed'; // 25
@@ -9304,75 +9302,81 @@ const SHAVUOT$1 = 'Shavuot'; // 33
 function range$1(start, stop) {
     return Array.from({ length: stop - start + 1 }, (v, k) => k + start);
 }
-const empty = [];
+const yearStartVayeilech = [51, 52, CHMSUKOT];
+const yearStartHaazinu = [52, YK, CHMSUKOT];
+const yearStartRH = [RH, 52, SUKKOT, SHMINI];
+const r020 = range$1(0, 20);
+const r027 = range$1(0, 27);
+const r3340 = range$1(33, 40);
+const r4349 = range$1(43, 49);
+const r4350 = range$1(43, 50);
 /**
  * The ordinary year types (keviot)
  * names are leap/nonleap - day - incomplete/regular/complete - diaspora/Israel
  * @private
  * @readonly
- * @type {Object.<string, NumberOrString[]>}
  */
 const types = {
     /* Hebrew year that starts on Monday, is `incomplete' (Heshvan and
        * Kislev each have 29 days), and has Passover start on Tuesday. */
     // e.g. 5753
-    '020': empty.concat(51, 52, EOY, range$1(0, 20), D(21), 23, 24, PESACH, 25, D(26), D(28), 30, D(31), range$1(33, 40), D(41), range$1(43, 49), D(50)),
+    '020': yearStartVayeilech.concat(r020, D(21), 23, 24, PESACH, 25, D(26), D(28), 30, D(31), r3340, D(41), r4349, D(50)),
     /* Hebrew year that starts on Monday, is `complete' (Heshvan and
        * Kislev each have 30 days), and has Passover start on Thursday. */
     // e.g. 5756
-    '0220': empty.concat(51, 52, EOY, range$1(0, 20), D(21), 23, 24, PESACH, 25, D(26), D(28), 30, D(31), 33, SHAVUOT$1, range$1(34, 37), D(38), 40, D(41), range$1(43, 49), D(50)),
+    '0220': yearStartVayeilech.concat(r020, D(21), 23, 24, PESACH, 25, D(26), D(28), 30, D(31), 33, SHAVUOT$1, range$1(34, 37), D(38), 40, D(41), r4349, D(50)),
     /* Hebrew year that starts on Thursday, is `regular' (Heshvan has 29
        * days and Kislev has 30 days), and has Passover start on Saturday. */
     // e.g. 5701
-    '0510': empty.concat(52, YK, EOY, range$1(0, 20), D(21), 23, 24, PESACH1, PESACH8, 25, D(26), D(28), 30, D(31), range$1(33, 40), D(41), range$1(43, 50)),
+    '0510': yearStartHaazinu.concat(r020, D(21), 23, 24, PESACH1, PESACH8, 25, D(26), D(28), 30, D(31), r3340, D(41), r4350),
     /* Hebrew year that starts on Thursday, is `regular' (Heshvan has 29
        * days and Kislev has 30 days), and has Passover start on Saturday. */
     // e.g. 5745
-    '0511': empty.concat(52, YK, EOY, range$1(0, 20), D(21), 23, 24, PESACH, 25, D(26), D(28), range$1(30, 40), D(41), range$1(43, 50)),
+    '0511': yearStartHaazinu.concat(r020, D(21), 23, 24, PESACH, 25, D(26), D(28), range$1(30, 40), D(41), r4350),
     /* Hebrew year that starts on Thursday, is `complete' (Heshvan and
        * Kislev each have 30 days), and has Passover start on Sunday. */
     // e.g. 5754
-    '052': empty.concat(52, YK, CHMSUKOT, range$1(0, 24), PESACH7, 25, D(26), D(28), 30, D(31), range$1(33, 40), D(41), range$1(43, 50)),
+    '052': yearStartHaazinu.concat(range$1(0, 24), PESACH7, 25, D(26), D(28), 30, D(31), r3340, D(41), r4350),
     /* Hebrew year that starts on Saturday, is `incomplete' (Heshvan and Kislev
        * each have 29 days), and has Passover start on Sunday. */
     // e.g. 5761
-    '070': empty.concat(RH, 52, SUKKOT, SHMINI, range$1(0, 20), D(21), 23, 24, PESACH7, 25, D(26), D(28), 30, D(31), range$1(33, 40), D(41), range$1(43, 50)),
+    '070': yearStartRH.concat(r020, D(21), 23, 24, PESACH7, 25, D(26), D(28), 30, D(31), r3340, D(41), r4350),
     /* Hebrew year that starts on Saturday, is `complete' (Heshvan and
        * Kislev each have 30 days), and has Passover start on Tuesday. */
     // e.g. 5716
-    '072': empty.concat(RH, 52, SUKKOT, SHMINI, range$1(0, 20), D(21), 23, 24, CHMPESACH, 25, D(26), D(28), 30, D(31), range$1(33, 40), D(41), range$1(43, 49), D(50)),
+    '072': yearStartRH.concat(r020, D(21), 23, 24, CHMPESACH, 25, D(26), D(28), 30, D(31), r3340, D(41), r4349, D(50)),
     /* --  The leap year types (keviot) -- */
     /* Hebrew year that starts on Monday, is `incomplete' (Heshvan and
        * Kislev each have 29 days), and has Passover start on Thursday. */
     // e.g. 5746
-    '1200': empty.concat(51, 52, CHMSUKOT, range$1(0, 27), CHMPESACH, range$1(28, 33), SHAVUOT$1, range$1(34, 37), D(38), 40, D(41), range$1(43, 49), D(50)),
+    '1200': yearStartVayeilech.concat(r027, CHMPESACH, range$1(28, 33), SHAVUOT$1, range$1(34, 37), D(38), 40, D(41), r4349, D(50)),
     /* Hebrew year that starts on Monday, is `incomplete' (Heshvan and
        * Kislev each have 29 days), and has Passover start on Thursday. */
     // e.g. 5746
-    '1201': empty.concat(51, 52, CHMSUKOT, range$1(0, 27), CHMPESACH, range$1(28, 40), D(41), range$1(43, 49), D(50)),
+    '1201': yearStartVayeilech.concat(r027, CHMPESACH, range$1(28, 40), D(41), r4349, D(50)),
     /* Hebrew year that starts on Monday, is `complete' (Heshvan and
        * Kislev each have 30 days), and has Passover start on Saturday. */
     // e.g.5752
-    '1220': empty.concat(51, 52, CHMSUKOT, range$1(0, 27), PESACH1, PESACH8, range$1(28, 40), D(41), range$1(43, 50)),
+    '1220': yearStartVayeilech.concat(r027, PESACH1, PESACH8, range$1(28, 40), D(41), r4350),
     /* Hebrew year that starts on Monday, is `complete' (Heshvan and
        * Kislev each have 30 days), and has Passover start on Saturday. */
     // e.g.5752
-    '1221': empty.concat(51, 52, CHMSUKOT, range$1(0, 27), PESACH, range$1(28, 50)),
+    '1221': yearStartVayeilech.concat(r027, PESACH, range$1(28, 50)),
     /* Hebrew year that starts on Thursday, is `incomplete' (Heshvan and
        * Kislev both have 29 days), and has Passover start on Sunday. */
     // e.g. 5768
-    '150': empty.concat(52, YK, CHMSUKOT, range$1(0, 28), PESACH7, range$1(29, 50)),
+    '150': yearStartHaazinu.concat(range$1(0, 28), PESACH7, range$1(29, 50)),
     /* Hebrew year that starts on Thursday, is `complete' (Heshvan and
        * Kislev both have 30 days), and has Passover start on Tuesday. */
     // eg. 5771
-    '152': empty.concat(52, YK, CHMSUKOT, range$1(0, 28), CHMPESACH, range$1(29, 49), D(50)),
+    '152': yearStartHaazinu.concat(range$1(0, 28), CHMPESACH, range$1(29, 49), D(50)),
     /* Hebrew year that starts on Saturday, is `incomplete' (Heshvan and
        * Kislev each have 29 days), and has Passover start on Tuesday. */
     // e.g.5757
-    '170': empty.concat(RH, 52, SUKKOT, SHMINI, range$1(0, 27), CHMPESACH, range$1(28, 40), D(41), range$1(43, 49), D(50)),
+    '170': yearStartRH.concat(r027, CHMPESACH, range$1(28, 40), D(41), r4349, D(50)),
     /* Hebrew year that starts on Saturday, is `complete' (Heshvan and
        * Kislev each have 30 days), and has Passover start on Thursday. */
-    '1720': empty.concat(RH, 52, SUKKOT, SHMINI, range$1(0, 27), CHMPESACH, range$1(28, 33), SHAVUOT$1, range$1(34, 37), D(38), 40, D(41), range$1(43, 49), D(50)),
+    '1720': yearStartRH.concat(r027, CHMPESACH, range$1(28, 33), SHAVUOT$1, range$1(34, 37), D(38), 40, D(41), r4349, D(50)),
 };
 /* Hebrew year that starts on Monday, is `complete' (Heshvan and
  * Kislev each have 30 days), and has Passover start on Thursday. */
@@ -9396,6 +9400,8 @@ types['1311'] = types['1221'];
 types['1721'] = types['170'];
 const sedraCache = new QuickLRU({ maxSize: 400 });
 /**
+ * Convenience function to create an instance of `Sedra` or reuse a previously
+ * created and cached instance.
  * @private
  * @param {number} hyear
  * @param {boolean} il
@@ -10060,7 +10066,7 @@ class DailyLearning {
 }
 
 /** DO NOT EDIT THIS AUTO-GENERATED FILE! */
-const version = '5.4.4';
+const version = '5.4.5';
 
 /* eslint-disable max-len */
 /**