us-equity-market-calendar 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Moshe Malka
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,50 @@
+# us-equity-market-calendar
+
+The **NYSE / NASDAQ** trading calendar — holidays (including Good Friday and Juneteenth), **1:00 p.m. early closes**, trading-day navigation, and a DST-aware **is-market-open**. Algorithmic, zero dependencies — every past and future year is correct.
+
+```
+npm install us-equity-market-calendar
+```
+
+## Why
+
+Python has `pandas_market_calendars`; JavaScript had no maintained equivalent. Existing npm packages give you federal holidays or a stale hard-coded list, but not the *equity* calendar with its early closes and session hours. This computes it from the rules, so it's right for any year.
+
+```ts
+import { isTradingDay, nextTradingDay, isMarketOpen, sessionClose } from "us-equity-market-calendar";
+
+isTradingDay("2026-10-12");   // true  — Columbus Day: stocks trade (bonds don't)
+isTradingDay("2026-04-03");   // false — Good Friday: stocks closed (bonds don't)
+
+nextTradingDay("2026-07-02"); // "2026-07-06" — skips the Jul 3 holiday + weekend
+sessionClose("2026-12-24");   // "13:00" — Christmas Eve early close
+isMarketOpen(new Date());     // true/false, DST-correct
+```
+
+## API
+
+Dates are `"YYYY-MM-DD"` strings or `Date` objects (UTC calendar dates).
+
+- **`getHolidays(year)`** → `{ date, name }[]` — full closures.
+- **`getEarlyCloses(year)`** → `{ date, name, closeTimeET: "13:00" }[]`.
+- **`isHoliday(date)`** / **`isEarlyClose(date)`** → the entry or `null`.
+- **`isTradingDay(date)`** — weekday and not a full closure.
+- **`nextTradingDay` / `previousTradingDay` / `addTradingDays(date, n)` / `countTradingDays(from, to)`**.
+- **`sessionClose(date)`** → `"16:00" | "13:00" | null`.
+- **`isMarketOpen(instant?)`** — is the regular session (09:30–16:00 ET, 13:00 on early closes) open at a `Date`, with America/New_York DST handled via the built-in `Intl` API.
+
+Out-of-range years and malformed dates throw `RangeError`.
+
+## Correctness
+
+Full-closure and early-close output is verified against the **published NYSE calendar for 2025–2028** — including Good Friday, the Juneteenth start in 2022, the Saturday-New-Year non-observance rule, and the exact early-close pattern (e.g. no July 3 early close in 2026 because it's the observed Independence Day). The rules are algorithmic (nth-weekday, Easter computus, weekend observance), so the same logic extends to any year; intraday open/close is checked across both EST and EDT.
+
+## Related
+
+The bond-market counterpart is [`sifma-holidays`](https://github.com/moshejs/sifma-holidays) (Columbus/Veterans Day closes, 2 p.m. early closes, T+1 settlement). Part of a markets toolkit: [`fx-value-date`](https://github.com/moshejs/fx-value-date) · [`32nds`](https://github.com/moshejs/32nds) · [`day-count`](https://github.com/moshejs/day-count) · [`newyorkfed`](https://github.com/moshejs/newyorkfed).
+
+## Author
+
+Built by **[Moshe Malka](https://moshemalka.com)** — engineering leader in New York City. Studio work at [Quentin.Code](https://www.quentin.software/).
+
+MIT © Moshe Malka

package/dist/index.cjs

@@ -0,0 +1,252 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  addTradingDays: () => addTradingDays,
+  countTradingDays: () => countTradingDays,
+  getEarlyCloses: () => getEarlyCloses,
+  getHolidays: () => getHolidays,
+  isEarlyClose: () => isEarlyClose,
+  isHoliday: () => isHoliday,
+  isMarketOpen: () => isMarketOpen,
+  isTradingDay: () => isTradingDay,
+  nextTradingDay: () => nextTradingDay,
+  previousTradingDay: () => previousTradingDay,
+  sessionClose: () => sessionClose
+});
+module.exports = __toCommonJS(index_exports);
+var DATE_RE = /^(\d{4})-(\d{2})-(\d{2})$/;
+function toYMD(input, label = "date") {
+  if (input instanceof Date) {
+    if (Number.isNaN(input.getTime())) throw new RangeError(`Invalid Date for ${label}`);
+    return { y: input.getUTCFullYear(), m: input.getUTCMonth() + 1, d: input.getUTCDate() };
+  }
+  const m = DATE_RE.exec(input);
+  if (!m) throw new RangeError(`Invalid date for ${label}: "${input}" (expected YYYY-MM-DD)`);
+  const ymd = { y: Number(m[1]), m: Number(m[2]), d: Number(m[3]) };
+  const check = new Date(Date.UTC(ymd.y, ymd.m - 1, ymd.d));
+  if (check.getUTCFullYear() !== ymd.y || check.getUTCMonth() + 1 !== ymd.m || check.getUTCDate() !== ymd.d) {
+    throw new RangeError(`Invalid calendar date for ${label}: "${input}"`);
+  }
+  return ymd;
+}
+function iso(a) {
+  return `${String(a.y).padStart(4, "0")}-${String(a.m).padStart(2, "0")}-${String(a.d).padStart(2, "0")}`;
+}
+function dow(a) {
+  return new Date(Date.UTC(a.y, a.m - 1, a.d)).getUTCDay();
+}
+function addDays(a, n) {
+  const t = new Date(Date.UTC(a.y, a.m - 1, a.d + n));
+  return { y: t.getUTCFullYear(), m: t.getUTCMonth() + 1, d: t.getUTCDate() };
+}
+function nthWeekday(y, m, weekday, n) {
+  const first = dow({ y, m, d: 1 });
+  return { y, m, d: 1 + (weekday - first + 7) % 7 + (n - 1) * 7 };
+}
+function lastWeekday(y, m, weekday) {
+  const lastDay = new Date(Date.UTC(y, m, 0)).getUTCDate();
+  const last = dow({ y, m, d: lastDay });
+  return { y, m, d: lastDay - (last - weekday + 7) % 7 };
+}
+function easterSunday(y) {
+  const a = y % 19;
+  const b = Math.floor(y / 100);
+  const c = y % 100;
+  const d = Math.floor(b / 4);
+  const e = b % 4;
+  const f = Math.floor((b + 8) / 25);
+  const g = Math.floor((b - f + 1) / 3);
+  const h = (19 * a + b - d - g + 15) % 30;
+  const i = Math.floor(c / 4);
+  const k = c % 4;
+  const l = (32 + 2 * e + 2 * i - h - k) % 7;
+  const mm = Math.floor((a + 11 * h + 22 * l) / 451);
+  const month = Math.floor((h + l - 7 * mm + 114) / 31);
+  const day = (h + l - 7 * mm + 114) % 31 + 1;
+  return { y, m: month, d: day };
+}
+function observed(a, isNewYear = false) {
+  const w = dow(a);
+  if (w === 6) return isNewYear ? null : addDays(a, -1);
+  if (w === 0) return addDays(a, 1);
+  return a;
+}
+var JUNETEENTH_FROM = 2022;
+function holidaysForYear(year) {
+  const items = [];
+  const add = (d, name) => {
+    if (d && d.y === year) items.push({ date: iso(d), name });
+  };
+  add(observed({ y: year, m: 1, d: 1 }, true), "New Year's Day");
+  add(nthWeekday(year, 1, 1, 3), "Martin Luther King Jr. Day");
+  add(nthWeekday(year, 2, 1, 3), "Washington's Birthday");
+  add(addDays(easterSunday(year), -2), "Good Friday");
+  add(lastWeekday(year, 5, 1), "Memorial Day");
+  if (year >= JUNETEENTH_FROM) add(observed({ y: year, m: 6, d: 19 }), "Juneteenth");
+  add(observed({ y: year, m: 7, d: 4 }), "Independence Day");
+  add(nthWeekday(year, 9, 1, 1), "Labor Day");
+  add(nthWeekday(year, 11, 4, 4), "Thanksgiving Day");
+  add(observed({ y: year, m: 12, d: 25 }), "Christmas Day");
+  const out = items.filter((h) => h !== null);
+  out.sort((a, b) => a.date < b.date ? -1 : 1);
+  return out;
+}
+function earlyClosesForYear(year) {
+  const out = [];
+  const thanksgiving = nthWeekday(year, 11, 4, 4);
+  out.push({ date: iso(addDays(thanksgiving, 1)), name: "Day after Thanksgiving", closeTimeET: "13:00" });
+  const jul4 = dow({ y: year, m: 7, d: 4 });
+  if (jul4 >= 2 && jul4 <= 5) {
+    out.push({ date: iso({ y: year, m: 7, d: 3 }), name: "Independence Day (early close)", closeTimeET: "13:00" });
+  }
+  const dec25 = dow({ y: year, m: 12, d: 25 });
+  if (dec25 >= 2 && dec25 <= 5) {
+    out.push({ date: iso({ y: year, m: 12, d: 24 }), name: "Christmas Eve (early close)", closeTimeET: "13:00" });
+  }
+  out.sort((a, b) => a.date < b.date ? -1 : 1);
+  return out;
+}
+var holidayCache = /* @__PURE__ */ new Map();
+var earlyCache = /* @__PURE__ */ new Map();
+function holidayMap(year) {
+  let m = holidayCache.get(year);
+  if (!m) {
+    m = new Map(holidaysForYear(year).map((h) => [h.date, h.name]));
+    holidayCache.set(year, m);
+  }
+  return m;
+}
+function earlyMap(year) {
+  let m = earlyCache.get(year);
+  if (!m) {
+    m = new Map(earlyClosesForYear(year).map((e) => [e.date, e]));
+    earlyCache.set(year, m);
+  }
+  return m;
+}
+function checkYear(year) {
+  if (!Number.isInteger(year) || year < 1900 || year > 2200) {
+    throw new RangeError(`Year out of supported range (1900\u20132200): ${year}`);
+  }
+}
+function getHolidays(year) {
+  checkYear(year);
+  return holidaysForYear(year);
+}
+function getEarlyCloses(year) {
+  checkYear(year);
+  return earlyClosesForYear(year);
+}
+function isWeekend(a) {
+  const w = dow(a);
+  return w === 0 || w === 6;
+}
+function isHoliday(date) {
+  const a = toYMD(date);
+  const name = holidayMap(a.y).get(iso(a));
+  return name ? { date: iso(a), name } : null;
+}
+function isEarlyClose(date) {
+  const a = toYMD(date);
+  return earlyMap(a.y).get(iso(a)) ?? null;
+}
+function isTradingDay(date) {
+  const a = toYMD(date);
+  return !isWeekend(a) && !holidayMap(a.y).has(iso(a));
+}
+function nextTradingDay(date) {
+  let cur = addDays(toYMD(date), 1);
+  while (!isTradingDay(iso(cur))) cur = addDays(cur, 1);
+  return iso(cur);
+}
+function previousTradingDay(date) {
+  let cur = addDays(toYMD(date), -1);
+  while (!isTradingDay(iso(cur))) cur = addDays(cur, -1);
+  return iso(cur);
+}
+function addTradingDays(date, n) {
+  if (!Number.isInteger(n)) throw new RangeError(`n must be an integer, got ${n}`);
+  let cur = toYMD(date);
+  const step = n < 0 ? -1 : 1;
+  for (let left = Math.abs(n); left > 0; left--) {
+    cur = addDays(cur, step);
+    while (!isTradingDay(iso(cur))) cur = addDays(cur, step);
+  }
+  return iso(cur);
+}
+function countTradingDays(from, to) {
+  let a = toYMD(from);
+  const b = toYMD(to);
+  if (iso(a) > iso(b)) throw new RangeError("`from` must be on or before `to`");
+  let count = 0;
+  while (iso(a) <= iso(b)) {
+    if (isTradingDay(iso(a))) count++;
+    a = addDays(a, 1);
+  }
+  return count;
+}
+function sessionClose(date) {
+  if (!isTradingDay(date)) return null;
+  return isEarlyClose(date) ? "13:00" : "16:00";
+}
+function toEasternParts(instant) {
+  const fmt = new Intl.DateTimeFormat("en-US", {
+    timeZone: "America/New_York",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  });
+  const parts = fmt.formatToParts(instant);
+  const get = (t) => Number(parts.find((p) => p.type === t).value);
+  let hour = get("hour");
+  if (hour === 24) hour = 0;
+  return { y: get("year"), m: get("month"), d: get("day"), hour, minute: get("minute") };
+}
+function isMarketOpen(instant = /* @__PURE__ */ new Date()) {
+  if (!(instant instanceof Date) || Number.isNaN(instant.getTime())) {
+    throw new RangeError("isMarketOpen requires a valid Date");
+  }
+  const et = toEasternParts(instant);
+  const dateStr = iso({ y: et.y, m: et.m, d: et.d });
+  if (!isTradingDay(dateStr)) return false;
+  const minutes = et.hour * 60 + et.minute;
+  const open = 9 * 60 + 30;
+  const close = isEarlyClose(dateStr) ? 13 * 60 : 16 * 60;
+  return minutes >= open && minutes < close;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addTradingDays,
+  countTradingDays,
+  getEarlyCloses,
+  getHolidays,
+  isEarlyClose,
+  isHoliday,
+  isMarketOpen,
+  isTradingDay,
+  nextTradingDay,
+  previousTradingDay,
+  sessionClose
+});

package/dist/index.d.cts

@@ -0,0 +1,54 @@
+/**
+ * us-equity-market-calendar — the NYSE / NASDAQ trading calendar.
+ *
+ * Full-closure holidays (including Good Friday and Juneteenth from 2022),
+ * 1:00 p.m. early-close half-days, weekend observance, and session-aware
+ * open/closed queries with US-Eastern DST handling. Zero dependencies — the
+ * holiday rules are algorithmic, so every past and future year is correct.
+ *
+ * This is the STOCK market calendar: it closes on Good Friday (unlike the bond
+ * market) and does NOT close on Columbus Day or Veterans Day (unlike the bond
+ * market). Regular session 09:30–16:00 ET; early closes end 13:00 ET.
+ */
+type DateInput = string | Date;
+interface MarketHoliday {
+    date: string;
+    name: string;
+}
+interface EarlyClose {
+    date: string;
+    name: string;
+    /** Session close, US Eastern Time. Equity early closes are 13:00. */
+    closeTimeET: "13:00";
+}
+/** All NYSE/NASDAQ full-closure holidays for a year, sorted by date. */
+declare function getHolidays(year: number): MarketHoliday[];
+/** All 1 p.m. early-close half-days for a year, sorted by date. */
+declare function getEarlyCloses(year: number): EarlyClose[];
+/** The holiday entry for a date, or null. */
+declare function isHoliday(date: DateInput): MarketHoliday | null;
+/** The early-close entry for a date, or null. Early-close days ARE trading days. */
+declare function isEarlyClose(date: DateInput): EarlyClose | null;
+/** True when the market trades that day: a weekday that is not a full closure. */
+declare function isTradingDay(date: DateInput): boolean;
+/** The next trading day strictly after `date`. */
+declare function nextTradingDay(date: DateInput): string;
+/** The previous trading day strictly before `date`. */
+declare function previousTradingDay(date: DateInput): string;
+/** Add `n` trading days (n may be negative; 0 returns the date unchanged). */
+declare function addTradingDays(date: DateInput, n: number): string;
+/** Count trading days in [from, to] inclusive of neither endpoint's non-trading days. */
+declare function countTradingDays(from: DateInput, to: DateInput): number;
+/**
+ * The regular-session close time for a trading day, in ET: "16:00" normally,
+ * "13:00" on an early-close half-day. Returns null on a non-trading day.
+ */
+declare function sessionClose(date: DateInput): "16:00" | "13:00" | null;
+/**
+ * Is the regular equity session open at the given instant? Regular hours are
+ * 09:30–16:00 ET (until 13:00 on early-close days). DST is handled via the
+ * America/New_York time zone.
+ */
+declare function isMarketOpen(instant?: Date): boolean;
+
+export { type DateInput, type EarlyClose, type MarketHoliday, addTradingDays, countTradingDays, getEarlyCloses, getHolidays, isEarlyClose, isHoliday, isMarketOpen, isTradingDay, nextTradingDay, previousTradingDay, sessionClose };

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * us-equity-market-calendar — the NYSE / NASDAQ trading calendar.
+ *
+ * Full-closure holidays (including Good Friday and Juneteenth from 2022),
+ * 1:00 p.m. early-close half-days, weekend observance, and session-aware
+ * open/closed queries with US-Eastern DST handling. Zero dependencies — the
+ * holiday rules are algorithmic, so every past and future year is correct.
+ *
+ * This is the STOCK market calendar: it closes on Good Friday (unlike the bond
+ * market) and does NOT close on Columbus Day or Veterans Day (unlike the bond
+ * market). Regular session 09:30–16:00 ET; early closes end 13:00 ET.
+ */
+type DateInput = string | Date;
+interface MarketHoliday {
+    date: string;
+    name: string;
+}
+interface EarlyClose {
+    date: string;
+    name: string;
+    /** Session close, US Eastern Time. Equity early closes are 13:00. */
+    closeTimeET: "13:00";
+}
+/** All NYSE/NASDAQ full-closure holidays for a year, sorted by date. */
+declare function getHolidays(year: number): MarketHoliday[];
+/** All 1 p.m. early-close half-days for a year, sorted by date. */
+declare function getEarlyCloses(year: number): EarlyClose[];
+/** The holiday entry for a date, or null. */
+declare function isHoliday(date: DateInput): MarketHoliday | null;
+/** The early-close entry for a date, or null. Early-close days ARE trading days. */
+declare function isEarlyClose(date: DateInput): EarlyClose | null;
+/** True when the market trades that day: a weekday that is not a full closure. */
+declare function isTradingDay(date: DateInput): boolean;
+/** The next trading day strictly after `date`. */
+declare function nextTradingDay(date: DateInput): string;
+/** The previous trading day strictly before `date`. */
+declare function previousTradingDay(date: DateInput): string;
+/** Add `n` trading days (n may be negative; 0 returns the date unchanged). */
+declare function addTradingDays(date: DateInput, n: number): string;
+/** Count trading days in [from, to] inclusive of neither endpoint's non-trading days. */
+declare function countTradingDays(from: DateInput, to: DateInput): number;
+/**
+ * The regular-session close time for a trading day, in ET: "16:00" normally,
+ * "13:00" on an early-close half-day. Returns null on a non-trading day.
+ */
+declare function sessionClose(date: DateInput): "16:00" | "13:00" | null;
+/**
+ * Is the regular equity session open at the given instant? Regular hours are
+ * 09:30–16:00 ET (until 13:00 on early-close days). DST is handled via the
+ * America/New_York time zone.
+ */
+declare function isMarketOpen(instant?: Date): boolean;
+
+export { type DateInput, type EarlyClose, type MarketHoliday, addTradingDays, countTradingDays, getEarlyCloses, getHolidays, isEarlyClose, isHoliday, isMarketOpen, isTradingDay, nextTradingDay, previousTradingDay, sessionClose };

package/dist/index.js

@@ -0,0 +1,217 @@
+// src/index.ts
+var DATE_RE = /^(\d{4})-(\d{2})-(\d{2})$/;
+function toYMD(input, label = "date") {
+  if (input instanceof Date) {
+    if (Number.isNaN(input.getTime())) throw new RangeError(`Invalid Date for ${label}`);
+    return { y: input.getUTCFullYear(), m: input.getUTCMonth() + 1, d: input.getUTCDate() };
+  }
+  const m = DATE_RE.exec(input);
+  if (!m) throw new RangeError(`Invalid date for ${label}: "${input}" (expected YYYY-MM-DD)`);
+  const ymd = { y: Number(m[1]), m: Number(m[2]), d: Number(m[3]) };
+  const check = new Date(Date.UTC(ymd.y, ymd.m - 1, ymd.d));
+  if (check.getUTCFullYear() !== ymd.y || check.getUTCMonth() + 1 !== ymd.m || check.getUTCDate() !== ymd.d) {
+    throw new RangeError(`Invalid calendar date for ${label}: "${input}"`);
+  }
+  return ymd;
+}
+function iso(a) {
+  return `${String(a.y).padStart(4, "0")}-${String(a.m).padStart(2, "0")}-${String(a.d).padStart(2, "0")}`;
+}
+function dow(a) {
+  return new Date(Date.UTC(a.y, a.m - 1, a.d)).getUTCDay();
+}
+function addDays(a, n) {
+  const t = new Date(Date.UTC(a.y, a.m - 1, a.d + n));
+  return { y: t.getUTCFullYear(), m: t.getUTCMonth() + 1, d: t.getUTCDate() };
+}
+function nthWeekday(y, m, weekday, n) {
+  const first = dow({ y, m, d: 1 });
+  return { y, m, d: 1 + (weekday - first + 7) % 7 + (n - 1) * 7 };
+}
+function lastWeekday(y, m, weekday) {
+  const lastDay = new Date(Date.UTC(y, m, 0)).getUTCDate();
+  const last = dow({ y, m, d: lastDay });
+  return { y, m, d: lastDay - (last - weekday + 7) % 7 };
+}
+function easterSunday(y) {
+  const a = y % 19;
+  const b = Math.floor(y / 100);
+  const c = y % 100;
+  const d = Math.floor(b / 4);
+  const e = b % 4;
+  const f = Math.floor((b + 8) / 25);
+  const g = Math.floor((b - f + 1) / 3);
+  const h = (19 * a + b - d - g + 15) % 30;
+  const i = Math.floor(c / 4);
+  const k = c % 4;
+  const l = (32 + 2 * e + 2 * i - h - k) % 7;
+  const mm = Math.floor((a + 11 * h + 22 * l) / 451);
+  const month = Math.floor((h + l - 7 * mm + 114) / 31);
+  const day = (h + l - 7 * mm + 114) % 31 + 1;
+  return { y, m: month, d: day };
+}
+function observed(a, isNewYear = false) {
+  const w = dow(a);
+  if (w === 6) return isNewYear ? null : addDays(a, -1);
+  if (w === 0) return addDays(a, 1);
+  return a;
+}
+var JUNETEENTH_FROM = 2022;
+function holidaysForYear(year) {
+  const items = [];
+  const add = (d, name) => {
+    if (d && d.y === year) items.push({ date: iso(d), name });
+  };
+  add(observed({ y: year, m: 1, d: 1 }, true), "New Year's Day");
+  add(nthWeekday(year, 1, 1, 3), "Martin Luther King Jr. Day");
+  add(nthWeekday(year, 2, 1, 3), "Washington's Birthday");
+  add(addDays(easterSunday(year), -2), "Good Friday");
+  add(lastWeekday(year, 5, 1), "Memorial Day");
+  if (year >= JUNETEENTH_FROM) add(observed({ y: year, m: 6, d: 19 }), "Juneteenth");
+  add(observed({ y: year, m: 7, d: 4 }), "Independence Day");
+  add(nthWeekday(year, 9, 1, 1), "Labor Day");
+  add(nthWeekday(year, 11, 4, 4), "Thanksgiving Day");
+  add(observed({ y: year, m: 12, d: 25 }), "Christmas Day");
+  const out = items.filter((h) => h !== null);
+  out.sort((a, b) => a.date < b.date ? -1 : 1);
+  return out;
+}
+function earlyClosesForYear(year) {
+  const out = [];
+  const thanksgiving = nthWeekday(year, 11, 4, 4);
+  out.push({ date: iso(addDays(thanksgiving, 1)), name: "Day after Thanksgiving", closeTimeET: "13:00" });
+  const jul4 = dow({ y: year, m: 7, d: 4 });
+  if (jul4 >= 2 && jul4 <= 5) {
+    out.push({ date: iso({ y: year, m: 7, d: 3 }), name: "Independence Day (early close)", closeTimeET: "13:00" });
+  }
+  const dec25 = dow({ y: year, m: 12, d: 25 });
+  if (dec25 >= 2 && dec25 <= 5) {
+    out.push({ date: iso({ y: year, m: 12, d: 24 }), name: "Christmas Eve (early close)", closeTimeET: "13:00" });
+  }
+  out.sort((a, b) => a.date < b.date ? -1 : 1);
+  return out;
+}
+var holidayCache = /* @__PURE__ */ new Map();
+var earlyCache = /* @__PURE__ */ new Map();
+function holidayMap(year) {
+  let m = holidayCache.get(year);
+  if (!m) {
+    m = new Map(holidaysForYear(year).map((h) => [h.date, h.name]));
+    holidayCache.set(year, m);
+  }
+  return m;
+}
+function earlyMap(year) {
+  let m = earlyCache.get(year);
+  if (!m) {
+    m = new Map(earlyClosesForYear(year).map((e) => [e.date, e]));
+    earlyCache.set(year, m);
+  }
+  return m;
+}
+function checkYear(year) {
+  if (!Number.isInteger(year) || year < 1900 || year > 2200) {
+    throw new RangeError(`Year out of supported range (1900\u20132200): ${year}`);
+  }
+}
+function getHolidays(year) {
+  checkYear(year);
+  return holidaysForYear(year);
+}
+function getEarlyCloses(year) {
+  checkYear(year);
+  return earlyClosesForYear(year);
+}
+function isWeekend(a) {
+  const w = dow(a);
+  return w === 0 || w === 6;
+}
+function isHoliday(date) {
+  const a = toYMD(date);
+  const name = holidayMap(a.y).get(iso(a));
+  return name ? { date: iso(a), name } : null;
+}
+function isEarlyClose(date) {
+  const a = toYMD(date);
+  return earlyMap(a.y).get(iso(a)) ?? null;
+}
+function isTradingDay(date) {
+  const a = toYMD(date);
+  return !isWeekend(a) && !holidayMap(a.y).has(iso(a));
+}
+function nextTradingDay(date) {
+  let cur = addDays(toYMD(date), 1);
+  while (!isTradingDay(iso(cur))) cur = addDays(cur, 1);
+  return iso(cur);
+}
+function previousTradingDay(date) {
+  let cur = addDays(toYMD(date), -1);
+  while (!isTradingDay(iso(cur))) cur = addDays(cur, -1);
+  return iso(cur);
+}
+function addTradingDays(date, n) {
+  if (!Number.isInteger(n)) throw new RangeError(`n must be an integer, got ${n}`);
+  let cur = toYMD(date);
+  const step = n < 0 ? -1 : 1;
+  for (let left = Math.abs(n); left > 0; left--) {
+    cur = addDays(cur, step);
+    while (!isTradingDay(iso(cur))) cur = addDays(cur, step);
+  }
+  return iso(cur);
+}
+function countTradingDays(from, to) {
+  let a = toYMD(from);
+  const b = toYMD(to);
+  if (iso(a) > iso(b)) throw new RangeError("`from` must be on or before `to`");
+  let count = 0;
+  while (iso(a) <= iso(b)) {
+    if (isTradingDay(iso(a))) count++;
+    a = addDays(a, 1);
+  }
+  return count;
+}
+function sessionClose(date) {
+  if (!isTradingDay(date)) return null;
+  return isEarlyClose(date) ? "13:00" : "16:00";
+}
+function toEasternParts(instant) {
+  const fmt = new Intl.DateTimeFormat("en-US", {
+    timeZone: "America/New_York",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  });
+  const parts = fmt.formatToParts(instant);
+  const get = (t) => Number(parts.find((p) => p.type === t).value);
+  let hour = get("hour");
+  if (hour === 24) hour = 0;
+  return { y: get("year"), m: get("month"), d: get("day"), hour, minute: get("minute") };
+}
+function isMarketOpen(instant = /* @__PURE__ */ new Date()) {
+  if (!(instant instanceof Date) || Number.isNaN(instant.getTime())) {
+    throw new RangeError("isMarketOpen requires a valid Date");
+  }
+  const et = toEasternParts(instant);
+  const dateStr = iso({ y: et.y, m: et.m, d: et.d });
+  if (!isTradingDay(dateStr)) return false;
+  const minutes = et.hour * 60 + et.minute;
+  const open = 9 * 60 + 30;
+  const close = isEarlyClose(dateStr) ? 13 * 60 : 16 * 60;
+  return minutes >= open && minutes < close;
+}
+export {
+  addTradingDays,
+  countTradingDays,
+  getEarlyCloses,
+  getHolidays,
+  isEarlyClose,
+  isHoliday,
+  isMarketOpen,
+  isTradingDay,
+  nextTradingDay,
+  previousTradingDay,
+  sessionClose
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "us-equity-market-calendar",
+  "version": "1.0.0",
+  "description": "NYSE / NASDAQ trading calendar — holidays (incl. Good Friday & Juneteenth), 1pm early closes, trading-day navigation, and DST-aware is-market-open. Algorithmic, zero dependencies.",
+  "keywords": [
+    "nyse",
+    "nasdaq",
+    "trading-calendar",
+    "market-calendar",
+    "market-holidays",
+    "trading-days",
+    "is-market-open",
+    "early-close",
+    "stock-market",
+    "finance",
+    "settlement"
+  ],
+  "homepage": "https://moshemalka.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/moshejs/us-equity-market-calendar.git"
+  },
+  "bugs": "https://github.com/moshejs/us-equity-market-calendar/issues",
+  "author": "Moshe Malka <hello@moshemalka.com> (https://moshemalka.com)",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run typecheck && npm run test && npm run build"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.0",
+    "vitest": "^3.2.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}