bizdays-toolkit 0.0.0 → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Changelog
+
+この形式は [Keep a Changelog](https://keepachangelog.com/ja/1.1.0/) に、版の付け方は [Semantic Versioning](https://semver.org/lang/ja/) と [RELEASING.md](./RELEASING.md) の方針に従います。区分には Keep a Changelog の Added / Changed / Deprecated / Removed / Fixed / Security に加えて、祝日データの更新を表す **Data** を使います。
+
+## [Unreleased]
+
+## [0.1.0] - 2026-10-11
+
+### Added
+
+- `createCalendar()`: 祝日・定休日の曜日・毎年の休業日（年をまたぐ期間を含む）・臨時休業日・臨時営業日を組み合わせた営業日カレンダー
+- 営業日の判定と計算: `isBusinessDay`・`dayInfo`（判定の理由付き）・`nextBusinessDay`・`previousBusinessDay`・`businessDayOnOrAfter`（締め時刻 `cutoff`）・`businessDayOnOrBefore`・`addBusinessDays`・`businessDaysBetween`・`listBusinessDays`
+- 祝日の扱い `holidayPolicy`（`closed` / `open` / `ignore`）
+- 日時の入力: `YYYY-MM-DD`・ISO 8601 日時（オフセット付きは瞬間）・`Date`・Temporal 互換オブジェクト。カレンダーのタイムゾーンで暦日に変換
+- 祝日の提供元のインターフェース `HolidayProvider`（他の国・地域を追加できる）
+- `bizdays-toolkit/jp`: 日本の祝日（1955〜2099 年）。国民の祝日・振替休日・国民の休日・皇室行事による休日
+
+### Data
+
+- 日本: 2026 年 2 月の官報（2027 年の春分・秋分の日）まで反映（`dataVersion: "2026-02"`、`confirmedThrough: 2027`）
+
+[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/inohan77/bizdays-toolkit/releases/tag/v0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 bizdays-toolkit contributors
+
+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

@@ -1 +1,160 @@
-Placeholder. See https://github.com/inohan77/bizdays-toolkit
+# bizdays-toolkit
+
+祝日と、会社・店舗の休業日を組み合わせた営業日カレンダーです。
+
+- **日本の祝日を内閣府のデータで全日照合**: 1955 年〜官報公表済みの年まで、内閣府「国民の祝日」CSV のすべての日付と一致することをテストで確かめています（振替休日・国民の休日・皇室行事による休日・五輪特措法による移動を含む）
+- **営業日の計算**: 定休日の曜日・毎年の休業日（年末年始のような年をまたぐ期間も可）・臨時休業日・臨時営業日と祝日を組み合わせ、「N 営業日後」「締め時刻を過ぎたら翌営業日」などを計算します
+- **タイムゾーンを間違えない**: `Date` などの瞬間は、カレンダーのタイムゾーン（日本は `Asia/Tokyo`）で暦日に変換してから判定します。UTC で動くサーバーでも、日本時間 0〜9 時が前日扱いになりません
+- **軽量・依存ゼロ**: minify + gzip で約 3KB（日本の祝日込みで約 5KB）。ESM・型定義同梱・`sideEffects: false` で、Node.js・ブラウザー・Edge ランタイムで動作します
+- **他の国・地域に拡張できる**: 祝日の提供元はインターフェース（`HolidayProvider`）で差し替えられます。現在は日本のみ同梱しています
+
+[English](#english)
+
+## インストール
+
+```sh
+pnpm add bizdays-toolkit
+```
+
+Node.js 22.12 以上。ESM のみですが、Node.js 22.12 以降は CommonJS からも `require()` で読み込めます。
+
+## 使い方
+
+### 祝日を調べる
+
+```ts
+import { getHoliday, holidaysInYear, isHoliday } from "bizdays-toolkit/jp";
+
+isHoliday("2026-11-23"); // true
+getHoliday("2026-09-22");
+// { date: "2026-09-22", name: "国民の休日", nameEn: "Citizens' Holiday", kind: "citizens", confirmed: true }
+holidaysInYear(2027);
+
+// 瞬間（Date）は日本時間で判定する
+isHoliday(new Date("2026-11-22T15:30:00Z")); // true（日本時間では 11/23）
+```
+
+`kind` は `national`（国民の祝日）・`substitute`（振替休日）・`citizens`（国民の休日）・`special`（皇室行事などによる休日）のいずれかです。
+
+`confirmed` は、その日付が公式に確定しているかを表します。春分・秋分の日は前年 2 月の官報で確定するため、それより先の年は近似式による予測（`confirmed: false`）です。
+
+### 営業日カレンダー
+
+```ts
+import { createCalendar } from "bizdays-toolkit";
+import { jp } from "bizdays-toolkit/jp";
+
+const shipping = createCalendar({
+  holidays: jp,
+  closedWeekdays: [0], // 日曜日（0 = 日曜 … 6 = 土曜）
+  closedAnnual: [{ from: "12-31", to: "01-03", name: "年末年始" }],
+  closedDates: [{ from: "2027-08-12", to: "2027-08-16", name: "夏季休業" }],
+  openDates: ["2026-12-27"], // 臨時営業日
+  holidayPolicy: "closed", // 祝日は休み（"open": 営業 / "ignore": 判定に使わない）
+});
+
+shipping.isBusinessDay("2026-11-23"); // false（勤労感謝の日）
+shipping.addBusinessDays("2026-12-30", 1); // "2027-01-04"
+shipping.businessDaysBetween("2026-09-01", "2026-10-01"); // from 以上 to 未満の営業日数
+
+// 14 時より前の注文は当日、それ以降は翌営業日に出荷
+shipping.businessDayOnOrAfter(new Date(), { cutoff: "14:00" });
+
+shipping.dayInfo("2027-01-01");
+// { date: "2027-01-01", weekday: 5, businessDay: false, reason: "closed-annual", name: "年末年始", holiday: {…} }
+```
+
+1 日の判定は次の優先順位で行います（上が優先）。
+
+1. `openDates`（臨時営業日）
+2. `closedDates`（臨時休業日）
+3. `closedAnnual`（毎年の休業日）
+4. 祝日（`holidayPolicy` に従う。`"open"` は定休日の曜日より優先して営業日にする）
+5. `closedWeekdays`（定休日の曜日）
+6. それ以外は営業日
+
+### 日付・日時の入力
+
+すべてのメソッドは次の入力を受け付けます。戻り値の日付は常に `"YYYY-MM-DD"` 文字列です。
+
+| 入力                                                 | 扱い                                           |
+| ---------------------------------------------------- | ---------------------------------------------- |
+| `"2026-11-23"`                                       | 暦日                                           |
+| `"2026-11-23T10:00"`                                 | カレンダーのタイムゾーンでの日時（壁時計）     |
+| `"2026-11-22T15:30:00Z"`・`"2026-11-23T00:30+09:00"` | 瞬間。カレンダーのタイムゾーンで暦日に変換する |
+| `Date`                                               | 瞬間                                           |
+| Temporal の `PlainDate`・`PlainDateTime`             | 暦日・日時（Temporal への依存はありません）    |
+| Temporal の `Instant`・`ZonedDateTime`               | 瞬間                                           |
+
+カレンダーのタイムゾーンは、`timeZone` オプション、祝日の提供元のタイムゾーン、`"UTC"` の順に決まります。
+
+### 他の国・地域の祝日
+
+`HolidayProvider` を実装して `holidays` に渡します。複数渡すと和集合になります（タイムゾーンが異なる場合は `timeZone` の指定が必要です）。
+
+```ts
+import { createCalendar, type HolidayProvider } from "bizdays-toolkit";
+
+const myCountry: HolidayProvider = {
+  id: "XX",
+  timeZone: "Europe/London",
+  supportedYears: { from: 2000, to: 2100 },
+  dataVersion: "2026-10",
+  holidaysInYear: (year) => [
+    {
+      date: `${year}-12-25`,
+      name: "Christmas Day",
+      nameEn: "Christmas Day",
+      kind: "public",
+      confirmed: true,
+    },
+  ],
+};
+const calendar = createCalendar({ holidays: myCountry, closedWeekdays: [0, 6] });
+```
+
+### 対応年の外
+
+祝日の提供元の対応年（日本は 1955〜2099 年）を外れた日付を判定すると `RangeError` になります。祝日がない日として扱いたい場合は `outOfRange: "ignore"` を指定してください。
+
+## バージョン番号とデータの更新
+
+[Semantic Versioning](https://semver.org/lang/ja/) に従います。詳しくは [RELEASING.md](./RELEASING.md) を参照してください。
+
+- 法改正・官報公表の反映（祝日の新設・移動、春分・秋分の日の確定）は**マイナー版**です。`^` で指定していれば自動で届きます
+- 祝日の判定結果を固定したい場合は、版を完全一致で指定してください（例: `"bizdays-toolkit": "0.1.0"`）
+- 反映済みのデータは `dataVersion`（日本は反映済みの官報の年月）と `confirmedThrough` で確認できます
+- 1.0.0 までは、マイナー版で破壊的変更を行うことがあります
+
+## 出典
+
+日本の祝日の検証には、内閣府ホームページで公開されている「国民の祝日」の CSV（<https://www8.cao.go.jp/chosei/shukujitsu/syukujitsu.csv>） を利用しています（テスト用フィクスチャのみ。パッケージには含みません）。
+
+## ライセンス
+
+MIT
+
+---
+
+## English
+
+A business-day calendar that combines public holidays with company or store closures.
+
+- **Japanese holidays verified day by day** against the Cabinet Office CSV, from 1955 through the latest year officially announced (substitute holidays, citizens' holidays, imperial ceremonies, and the Olympic moves included)
+- **Business-day arithmetic**: closed weekdays, annual closures (including ranges across the new year), specific closed/open dates, holiday policy, `addBusinessDays`, cut-off times, and more
+- **Time-zone safe**: instants (`Date`, ISO strings with offsets, Temporal) are converted to a civil date in the calendar's time zone before evaluation
+- **Lightweight, zero dependencies**: about 3 KB min+gzip (about 5 KB with Japanese holidays), ESM, bundled types, `sideEffects: false`
+- **Extensible** through the `HolidayProvider` interface (only Japan is bundled for now)
+
+```ts
+import { createCalendar } from "bizdays-toolkit";
+import { jp, isHoliday } from "bizdays-toolkit/jp";
+
+isHoliday("2026-11-23"); // true
+
+const office = createCalendar({ holidays: jp, closedWeekdays: [0, 6] });
+office.addBusinessDays("2026-09-18", 1); // "2026-09-24"
+office.businessDayOnOrAfter(new Date(), { cutoff: "14:00" });
+```
+
+Versioning follows SemVer. Updates that reflect law amendments or official announcements are released as **minor** versions; pin an exact version if you need frozen results. Before 1.0.0, minor versions may contain breaking changes. See [RELEASING.md](./RELEASING.md) (Japanese) for details.

package/dist/core/calendar.d.ts

@@ -0,0 +1,123 @@
+/**
+ * 祝日と、会社・店舗の休業日を組み合わせた営業日カレンダー。
+ *
+ * 1 日の判定は次の優先順位で行う（上が優先）:
+ *   1. openDates      … 臨時営業日（個別の日付・期間）
+ *   2. closedDates    … 臨時休業日（個別の日付・期間）
+ *   3. closedAnnual   … 毎年の休業日（月日・月日の期間。年をまたぐ期間も可）
+ *   4. 祝日            … holidayPolicy に従う（closed: 休業 / open: 営業 / ignore: 判定に使わない）
+ *   5. closedWeekdays … 定休日の曜日
+ *   6. それ以外は営業日
+ */
+import { type DateString, type Weekday } from "./date.ts";
+import { type DateInput } from "./input.ts";
+import type { Holiday, HolidayProvider } from "./types.ts";
+/** 祝日の扱い */
+export type HolidayPolicy = "closed" | "open" | "ignore";
+/** 毎年の月日 "MM-DD"（名前付きも可） */
+export type AnnualDate = string | {
+    readonly date: string;
+    readonly name?: string;
+};
+/** 毎年の月日の期間（from > to なら年をまたぐ。例: 12-31 〜 01-03） */
+export interface AnnualRange {
+    readonly from: string;
+    readonly to: string;
+    readonly name?: string;
+}
+/** 個別の日付 "YYYY-MM-DD"（名前付きも可） */
+export type SpecificDate = DateString | {
+    readonly date: DateString;
+    readonly name?: string;
+};
+/** 個別の日付の期間（両端を含む） */
+export interface DateRange {
+    readonly from: DateString;
+    readonly to: DateString;
+    readonly name?: string;
+}
+export interface CalendarOptions<Kind extends string = string> {
+    /** 祝日の提供元（例: jp）。複数渡すと和集合になる */
+    readonly holidays?: HolidayProvider<Kind> | readonly HolidayProvider<Kind>[];
+    /**
+     * 日時の入力（Date・オフセット付き文字列など）を暦日に変換するタイムゾーン。
+     * 省略時は祝日の提供元のタイムゾーン、提供元もなければ "UTC"
+     */
+    readonly timeZone?: string;
+    /** 定休日の曜日（0 = 日曜日） */
+    readonly closedWeekdays?: readonly Weekday[];
+    /** 毎年の休業日 */
+    readonly closedAnnual?: readonly (AnnualDate | AnnualRange)[];
+    /** 臨時休業日 */
+    readonly closedDates?: readonly (SpecificDate | DateRange)[];
+    /** 臨時営業日（ほかのすべての規則より優先） */
+    readonly openDates?: readonly (SpecificDate | DateRange)[];
+    /** 祝日の扱い（既定: "closed"） */
+    readonly holidayPolicy?: HolidayPolicy;
+    /** 祝日の提供元の対応年を外れた日付の扱い（既定: "throw"） */
+    readonly outOfRange?: "throw" | "ignore";
+    /** 営業日を探すときに調べる最大日数（既定: 3660）。超えたら Error */
+    readonly maxSearchDays?: number;
+}
+/** 営業・休業を決めた規則 */
+export type DayReason = "open-date" | "closed-date" | "closed-annual" | "holiday" | "closed-weekday" | "regular";
+/** 1 日分の判定結果 */
+export interface DayInfo<Kind extends string = string> {
+    readonly date: DateString;
+    readonly weekday: Weekday;
+    readonly businessDay: boolean;
+    /** 判定を決めた規則 */
+    readonly reason: DayReason;
+    /** 判定を決めた規則の名前（休業日の名前・祝日名など） */
+    readonly name?: string;
+    /** その日が祝日なら祝日（holidayPolicy に関係なく付く） */
+    readonly holiday?: Holiday<Kind>;
+}
+export interface BusinessDayOptions {
+    /**
+     * 締め時刻 "HH:mm"（カレンダーのタイムゾーン）。
+     * 入力の時刻がこの時刻以降なら、その日は対象にしない。暦日だけの入力は 0 時として扱う
+     */
+    readonly cutoff?: string;
+}
+export interface Calendar<Kind extends string = string> {
+    /** 日時の入力を暦日に変換するタイムゾーン */
+    readonly timeZone: string;
+    /** 祝日の提供元 */
+    readonly providers: readonly HolidayProvider<Kind>[];
+    /** 入力をカレンダーのタイムゾーンでの暦日に変換する */
+    dateOf(input: DateInput): DateString;
+    /** 今日の日付（カレンダーのタイムゾーン） */
+    today(now?: Date): DateString;
+    /** 祝日か */
+    isHoliday(input: DateInput): boolean;
+    /** 祝日なら祝日を返す */
+    getHoliday(input: DateInput): Holiday<Kind> | undefined;
+    /** その年の祝日 */
+    holidaysInYear(year: number): readonly Holiday<Kind>[];
+    /** 期間内の祝日（両端を含む） */
+    holidaysBetween(from: DateInput, to: DateInput): readonly Holiday<Kind>[];
+    /** 1 日分の判定結果（営業日か・理由・祝日） */
+    dayInfo(input: DateInput): DayInfo<Kind>;
+    /** 営業日か */
+    isBusinessDay(input: DateInput): boolean;
+    /** 翌営業日（入力日の翌日以降） */
+    nextBusinessDay(input: DateInput): DateString;
+    /** 前営業日（入力日の前日以前） */
+    previousBusinessDay(input: DateInput): DateString;
+    /** 入力日が営業日ならその日、そうでなければ翌営業日。cutoff で締め時刻を指定できる */
+    businessDayOnOrAfter(input: DateInput, options?: BusinessDayOptions): DateString;
+    /** 入力日が営業日ならその日、そうでなければ前営業日 */
+    businessDayOnOrBefore(input: DateInput): DateString;
+    /**
+     * n 営業日後（負なら前）。入力日自身は数えない。
+     * n = 0 のときは businessDayOnOrAfter と同じ
+     */
+    addBusinessDays(input: DateInput, n: number): DateString;
+    /** from 以上 to 未満の営業日の数（to が前なら負） */
+    businessDaysBetween(from: DateInput, to: DateInput): number;
+    /** 期間内の営業日（両端を含む） */
+    listBusinessDays(from: DateInput, to: DateInput): readonly DateString[];
+}
+/** 祝日と休業日の規則から営業日カレンダーを作る */
+export declare function createCalendar<Kind extends string = string>(options?: CalendarOptions<Kind>): Calendar<Kind>;

package/dist/core/calendar.js

@@ -0,0 +1,254 @@
+/**
+ * 祝日と、会社・店舗の休業日を組み合わせた営業日カレンダー。
+ *
+ * 1 日の判定は次の優先順位で行う（上が優先）:
+ *   1. openDates      … 臨時営業日（個別の日付・期間）
+ *   2. closedDates    … 臨時休業日（個別の日付・期間）
+ *   3. closedAnnual   … 毎年の休業日（月日・月日の期間。年をまたぐ期間も可）
+ *   4. 祝日            … holidayPolicy に従う（closed: 休業 / open: 営業 / ignore: 判定に使わない）
+ *   5. closedWeekdays … 定休日の曜日
+ *   6. それ以外は営業日
+ */
+import { addDays, fromDayNumber, parseDate, toDayNumber, weekdayOf, } from "./date.js";
+import { instantToCivil, parseTimeOfDay, toCivil, validateTimeZone, } from "./input.js";
+const MONTH_DAY_RE = /^(\d{2})-(\d{2})$/;
+const MAX_DAYS_IN_MONTH = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+function parseMonthDay(value) {
+    const m = MONTH_DAY_RE.exec(value);
+    const month = Number(m?.[1]);
+    const day = Number(m?.[2]);
+    if (!m || month < 1 || month > 12 || day < 1 || day > MAX_DAYS_IN_MONTH[month - 1]) {
+        throw new RangeError(`Invalid month-day: ${JSON.stringify(value)} (expected MM-DD)`);
+    }
+    return value;
+}
+function compileDates(entries, label) {
+    return (entries ?? []).map((e) => {
+        if (typeof e === "string") {
+            const n = toDayNumber(e);
+            return { from: n, to: n, name: undefined };
+        }
+        if ("date" in e) {
+            const n = toDayNumber(e.date);
+            return { from: n, to: n, name: e.name };
+        }
+        const from = toDayNumber(e.from);
+        const to = toDayNumber(e.to);
+        if (from > to)
+            throw new RangeError(`${label}: "from" must not be after "to" (${e.from} > ${e.to})`);
+        return { from, to, name: e.name };
+    });
+}
+function compileAnnual(entries) {
+    return (entries ?? []).map((e) => {
+        if (typeof e === "string") {
+            const md = parseMonthDay(e);
+            return { from: md, to: md, name: undefined };
+        }
+        if ("date" in e) {
+            const md = parseMonthDay(e.date);
+            return { from: md, to: md, name: e.name };
+        }
+        return { from: parseMonthDay(e.from), to: parseMonthDay(e.to), name: e.name };
+    });
+}
+function matchAnnual(rule, monthDay) {
+    return rule.from <= rule.to
+        ? monthDay >= rule.from && monthDay <= rule.to
+        : monthDay >= rule.from || monthDay <= rule.to;
+}
+/** 祝日と休業日の規則から営業日カレンダーを作る */
+export function createCalendar(options = {}) {
+    const providers = Object.freeze(options.holidays === undefined
+        ? []
+        : Array.isArray(options.holidays)
+            ? [...options.holidays]
+            : [options.holidays]);
+    let timeZone;
+    if (options.timeZone !== undefined) {
+        timeZone = validateTimeZone(options.timeZone);
+    }
+    else {
+        const zones = [...new Set(providers.map((p) => validateTimeZone(p.timeZone)))];
+        if (zones.length > 1) {
+            throw new RangeError(`Holiday providers use different time zones (${zones.join(", ")}); specify options.timeZone`);
+        }
+        timeZone = zones[0] ?? "UTC";
+    }
+    const closedWeekdays = new Set();
+    for (const w of options.closedWeekdays ?? []) {
+        if (!Number.isInteger(w) || w < 0 || w > 6)
+            throw new RangeError(`Invalid weekday: ${w}`);
+        closedWeekdays.add(w);
+    }
+    const closedAnnual = compileAnnual(options.closedAnnual);
+    const closedDates = compileDates(options.closedDates, "closedDates");
+    const openDates = compileDates(options.openDates, "openDates");
+    const holidayPolicy = options.holidayPolicy ?? "closed";
+    if (!["closed", "open", "ignore"].includes(holidayPolicy)) {
+        throw new RangeError(`Invalid holidayPolicy: ${String(holidayPolicy)}`);
+    }
+    const outOfRange = options.outOfRange ?? "throw";
+    const maxSearchDays = options.maxSearchDays ?? 3660;
+    if (!Number.isInteger(maxSearchDays) || maxSearchDays < 1) {
+        throw new RangeError(`Invalid maxSearchDays: ${maxSearchDays}`);
+    }
+    const yearCache = new Map();
+    function providerYears(provider, year) {
+        const { from, to } = provider.supportedYears;
+        if (year < from || year > to) {
+            if (outOfRange === "ignore")
+                return [];
+            throw new RangeError(`Holidays for ${provider.id} are supported for ${from}-${to}; requested ${year}`);
+        }
+        return provider.holidaysInYear(year);
+    }
+    function holidayMap(year) {
+        let map = yearCache.get(year);
+        if (!map) {
+            map = new Map();
+            for (const provider of providers) {
+                for (const h of providerYears(provider, year)) {
+                    // 同じ日に複数の提供元の祝日がある場合は、先に渡した提供元を優先する
+                    if (!map.has(h.date))
+                        map.set(h.date, h);
+                }
+            }
+            yearCache.set(year, map);
+        }
+        return map;
+    }
+    const dateOf = (input) => toCivil(input, timeZone).date;
+    function holidayOn(date) {
+        if (providers.length === 0)
+            return undefined;
+        return holidayMap(parseDate(date).year).get(date);
+    }
+    function findRule(rules, dayNumber) {
+        return rules.find((r) => dayNumber >= r.from && dayNumber <= r.to);
+    }
+    function info(date) {
+        const dayNumber = toDayNumber(date);
+        const weekday = weekdayOf(date);
+        const holiday = holidayOn(date);
+        const make = (businessDay, reason, name) => {
+            const result = {
+                date,
+                weekday,
+                businessDay,
+                reason,
+            };
+            if (name !== undefined)
+                result.name = name;
+            if (holiday !== undefined)
+                result.holiday = holiday;
+            return Object.freeze(result);
+        };
+        const open = findRule(openDates, dayNumber);
+        if (open)
+            return make(true, "open-date", open.name);
+        const closed = findRule(closedDates, dayNumber);
+        if (closed)
+            return make(false, "closed-date", closed.name);
+        const monthDay = date.slice(5);
+        const annual = closedAnnual.find((r) => matchAnnual(r, monthDay));
+        if (annual)
+            return make(false, "closed-annual", annual.name);
+        if (holiday && holidayPolicy !== "ignore") {
+            return make(holidayPolicy === "open", "holiday", holiday.name);
+        }
+        if (closedWeekdays.has(weekday))
+            return make(false, "closed-weekday", undefined);
+        return make(true, "regular", undefined);
+    }
+    const isOpen = (date) => info(date).businessDay;
+    function search(start, step) {
+        let n = toDayNumber(start);
+        for (let i = 0; i < maxSearchDays; i++, n += step) {
+            const date = fromDayNumber(n);
+            if (isOpen(date))
+                return date;
+        }
+        throw new Error(`No business day found within ${maxSearchDays} days from ${start}`);
+    }
+    function ordered(from, to) {
+        const a = dateOf(from);
+        const b = dateOf(to);
+        if (a > b)
+            throw new RangeError(`"from" must not be after "to" (${a} > ${b})`);
+        return [a, b];
+    }
+    function countOpen(from, toExclusive) {
+        let count = 0;
+        for (let n = from; n < toExclusive; n++)
+            if (isOpen(fromDayNumber(n)))
+                count++;
+        return count;
+    }
+    const calendar = {
+        timeZone,
+        providers,
+        dateOf,
+        today: (now = new Date()) => instantToCivil(now.getTime(), timeZone).date,
+        isHoliday: (input) => holidayOn(dateOf(input)) !== undefined,
+        getHoliday: (input) => holidayOn(dateOf(input)),
+        holidaysInYear(year) {
+            if (!Number.isInteger(year))
+                throw new RangeError(`Invalid year: ${year}`);
+            return Object.freeze([...holidayMap(year).values()].sort((a, b) => a.date < b.date ? -1 : a.date > b.date ? 1 : 0));
+        },
+        holidaysBetween(from, to) {
+            const [a, b] = ordered(from, to);
+            const result = [];
+            for (let y = parseDate(a).year; y <= parseDate(b).year; y++) {
+                for (const h of calendar.holidaysInYear(y))
+                    if (h.date >= a && h.date <= b)
+                        result.push(h);
+            }
+            return Object.freeze(result);
+        },
+        dayInfo: (input) => info(dateOf(input)),
+        isBusinessDay: (input) => isOpen(dateOf(input)),
+        nextBusinessDay: (input) => search(addDays(dateOf(input), 1), 1),
+        previousBusinessDay: (input) => search(addDays(dateOf(input), -1), -1),
+        businessDayOnOrAfter(input, opts = {}) {
+            const civil = toCivil(input, timeZone);
+            let start = civil.date;
+            if (opts.cutoff !== undefined) {
+                const cutoff = parseTimeOfDay(opts.cutoff);
+                if (civil.minutes !== null && civil.minutes >= cutoff)
+                    start = addDays(start, 1);
+            }
+            return search(start, 1);
+        },
+        businessDayOnOrBefore: (input) => search(dateOf(input), -1),
+        addBusinessDays(input, n) {
+            if (!Number.isInteger(n))
+                throw new RangeError(`n must be an integer: ${n}`);
+            let date = dateOf(input);
+            if (n === 0)
+                return search(date, 1);
+            const step = n > 0 ? 1 : -1;
+            for (let remaining = Math.abs(n); remaining > 0; remaining--) {
+                date = search(addDays(date, step), step);
+            }
+            return date;
+        },
+        businessDaysBetween(from, to) {
+            const a = toDayNumber(dateOf(from));
+            const b = toDayNumber(dateOf(to));
+            return a <= b ? countOpen(a, b) : -countOpen(b, a);
+        },
+        listBusinessDays(from, to) {
+            const [a, b] = ordered(from, to);
+            const result = [];
+            for (let n = toDayNumber(a); n <= toDayNumber(b); n++) {
+                const date = fromDayNumber(n);
+                if (isOpen(date))
+                    result.push(date);
+            }
+            return Object.freeze(result);
+        },
+    };
+    return Object.freeze(calendar);
+}

package/dist/core/date.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 暦日（タイムゾーンを持たない日付）の計算。
+ *
+ * 日付は常に "YYYY-MM-DD" 文字列で扱い、内部では 1970-01-01 からの日数（day number）に
+ * 変換して計算する。Date オブジェクトのローカル時刻は使わない。
+ */
+/** 暦日を表す "YYYY-MM-DD" 文字列 */
+export type DateString = string;
+/** 曜日（0 = 日曜日 … 6 = 土曜日。Date#getDay と同じ） */
+export type Weekday = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+/** 年月日に分解する。形式または暦として不正なら RangeError */
+export declare function parseDate(value: string): {
+    year: number;
+    month: number;
+    day: number;
+};
+/** "YYYY-MM-DD" として正しい暦日か */
+export declare function isValidDate(value: unknown): value is DateString;
+/** 年月日から "YYYY-MM-DD" を作る（範囲外なら RangeError） */
+export declare function formatDate(year: number, month: number, day: number): DateString;
+/** うるう年か */
+export declare function isLeapYear(year: number): boolean;
+/** その月の日数 */
+export declare function daysInMonth(year: number, month: number): number;
+/** 1970-01-01 からの日数 */
+export declare function toDayNumber(date: DateString): number;
+/** 1970-01-01 からの日数を "YYYY-MM-DD" に戻す */
+export declare function fromDayNumber(dayNumber: number): DateString;
+/** n 日後（負なら前）の日付 */
+export declare function addDays(date: DateString, days: number): DateString;
+/** from から to までの日数（to が後なら正） */
+export declare function diffDays(from: DateString, to: DateString): number;
+/** 曜日（0 = 日曜日） */
+export declare function weekdayOf(date: DateString): Weekday;
+/** その月の第 n 何曜日（n は 1 始まり） */
+export declare function nthWeekdayOfMonth(year: number, month: number, weekday: Weekday, n: number): DateString;