@hebcal/core 5.4.4 → 5.4.6

package/dist/index.mjs

@@ -1,4 +1,4 @@
-/*! @hebcal/core v5.4.4 */
+/*! @hebcal/core v5.4.6 */
 /* eslint-disable @typescript-eslint/no-namespace, no-inner-declarations */
 /** @private */
 const lengths = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
@@ -8478,9 +8478,17 @@ class HavdalahEvent extends TimedEvent {
 const shortDayNames = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
 const heDayNames = ['רִאשׁוֹן', 'שֵׁנִי', 'שְׁלִישִׁי', 'רְבִיעִי', 'חֲמִישִׁי', 'שִׁישִּׁי', 'שַׁבָּת'];
 const night = 'בַּלַּ֥יְלָה';
-const morning = 'בַּבֹּקֶר';
-const afternoon = 'בַּצׇּהֳרַיִים';
-const evening = 'בָּעֶרֶב';
+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 moment when the new moon is "born"
  */
@@ -8541,6 +8549,7 @@ class Molad {
      * @return {string}
      */
     render(locale, options) {
+        var _a;
         locale = locale !== null && locale !== void 0 ? locale : Locale.getLocaleName();
         if (typeof locale === 'string') {
             locale = locale.toLowerCase();
@@ -8553,11 +8562,10 @@ class Molad {
         const hour = this.getHour();
         const chalakim = this.getChalakim();
         const moladStr = Locale.gettext('Molad', locale);
-        const minutesStr = Locale.lookupTranslation('min', locale) || 'minutes';
+        const minutesStr = (_a = Locale.lookupTranslation('min', locale)) !== null && _a !== void 0 ? _a : 'minutes';
         const chalakimStr = Locale.gettext('chalakim', locale);
         if (isHebrewLocale) {
-            const ampm = hour < 5 ? night : hour < 12 ? morning :
-                hour < 17 ? afternoon : hour < 21 ? evening : night;
+            const ampm = getHebrewTimeOfDay(hour);
             const result = `${moladStr} ${monthName} יִהְיֶה בַּיּוֹם ${dow} בשָׁבוּעַ, ` +
                 `בְּשָׁעָה ${hour} ${ampm}, ` +
                 `ו-${minutes} ${minutesStr} ` +
@@ -8682,13 +8690,6 @@ class OmerEvent extends Event {
 }
 
 class QuickLRU extends Map {
-	#size = 0;
-	#cache = new Map();
-	#oldCache = new Map();
-	#maxSize;
-	#maxAge;
-	#onEviction;
-
 	constructor(options = {}) {
 		super();
 
@@ -8700,30 +8701,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);
@@ -8732,54 +8733,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;
 			}
@@ -8787,72 +8788,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) {
@@ -8860,23 +8862,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() {
@@ -8892,18 +8894,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];
 				}
@@ -8912,22 +8914,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];
 				}
@@ -8936,28 +8938,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() {
@@ -9009,6 +9007,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
  */
@@ -9020,11 +9031,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();
@@ -9033,6 +9039,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];
@@ -9285,7 +9292,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
@@ -9302,75 +9308,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. */
@@ -9394,6 +9406,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
@@ -10058,7 +10072,7 @@ class DailyLearning {
 }
 
 /** DO NOT EDIT THIS AUTO-GENERATED FILE! */
-const version = '5.4.4';
+const version = '5.4.6';
 
 /* eslint-disable max-len */
 /**
@@ -10625,15 +10639,16 @@ function tachanunYear(year, il) {
     if (shushPurim.getDay() === 6) {
         shushPurim = shushPurim.next();
     }
-    const empty = [];
-    const none = empty.concat(
+    const none = [
+        new HDate(2, months.TISHREI, year), // Rosh Hashana II
+    ].concat(
     // Rosh Chodesh - 1st of every month. Also includes RH day 1 (1 Tishrei)
     range(1, monthsInYear)
         .map((month) => new HDate(1, month, year)), 
     // Rosh Chodesh - 30th of months that have one
     range(1, monthsInYear)
         .filter((month) => HDate.daysInMonth(month, year) === 30)
-        .map((month) => new HDate(30, month, year)), new HDate(2, months.TISHREI, year), // Rosh Hashana II
+        .map((month) => new HDate(30, month, year)), 
     // entire month of Nisan
     range(1, HDate.daysInMonth(months.NISAN, year))
         .map((mday) => new HDate(mday, months.NISAN, year)), new HDate(18, months.IYYAR, year), // Lag BaOmer
@@ -10650,13 +10665,15 @@ function tachanunYear(year, il) {
         .map((mday) => new HDate(mday, months.KISLEV, year)), new HDate(15, months.SHVAT, year), // Tu BiShvat
     new HDate(14, months.ADAR_II, year), // Purim
     shushPurim, leap ? new HDate(14, months.ADAR_I, year) : []);
-    const some = empty.concat(
+    const some = [
+        new HDate(14, months.IYYAR, year), // Pesach Sheini
+    ].concat(
     // Until 14 Sivan
     range(1, 13)
         .map((mday) => new HDate(mday, months.SIVAN, year)), 
     // Until after Rosh Chodesh Cheshvan
     range(20, 31)
-        .map((mday) => new HDate(mday, months.TISHREI, year)), new HDate(14, months.IYYAR, year), // Pesach Sheini
+        .map((mday) => new HDate(mday, months.TISHREI, year)), 
     // Yom HaAtzma'ut, which changes based on day of week
     year >= 5708 ? dateYomHaZikaron(year).next() : [], 
     // Yom Yerushalayim

package/dist/pkgVersion.d.ts

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

package/dist/sedra.d.ts

@@ -91,6 +91,8 @@ export declare class Sedra {
 export declare const parshiot: string[];
 type NumberOrString = number | string;
 /**
+ * Convenience function to create an instance of `Sedra` or reuse a previously
+ * created and cached instance.
  * @private
  * @param {number} hyear
  * @param {boolean} il