bizdays-toolkit 0.15.0 → 0.16.0

package/CHANGELOG.md

@@ -4,6 +4,32 @@
 
 ## [Unreleased]
 
+## [0.16.0] - 2026-10-23
+
+### 移行
+
+日時の文字列の区切りは `T` だけになり、空白で区切った文字列（`"2026-11-23 10:00"`）は `invalid-time` の Error になる（これまでは実行時だけ受け付けていた。型 `DateTimeInput` は以前から `T` 区切りだけ）。合成した `dayInfo` に `decidedByPath` が加わるので、`deepEqual` で比べているテストは期待値に足す。ほかは動作が変わらない（祝前日の規則・サブパス・合成の項目の追加）。版ごとの作業は [docs/migration.md](./docs/migration.md) にまとめた。
+
+### Added
+
+- 繰り返しの規則に祝前日の形 `{ dayBeforeHoliday: true }` を追加した（型 `DayBeforeHolidayPattern`）。翌日が提供元の祝日でその日自身は祝日でない日に当てはまり、連休なら連休の初日の前日だけ。`{ dayAfterHoliday: true }` の鏡像で、`weekdays`・`months`・有効期間を付けられ、`onHolidayRule` は `invalid-option`。宿泊の祝前日料金・飲食店の祝前日の営業時間・祝前日の出荷の締めの繰り上げを規則として書ける。診断の `never-matches`・`shadowed` も扱う
+- 祝日の提供元を実装する人向けのサブパス `bizdays-toolkit/provider` を追加した（`@beta`）。内部で使っている暦の計算 `easterSunday(year)`（グレゴリオ暦の復活祭。英国の祝日で GOV.UK のデータと照合済み）、`nthWeekdayOfMonth(year, month, weekday, n)`（`n` は 1〜5 と -1（最後））、`daysInMonth`、`isLeapYear` を、入力の検証を付けて公開する。米国の連邦祝日やドイツ・豪州の州の祝日のように、第 n 曜日と復活祭で決まる提供元が書ける
+- 合成したカレンダーの `dayInfo` に `decidedByPath`（判定を決めたカレンダーまでの番号の列。外側から順）を追加した。合成したカレンダーをさらに合成したとき、`rulePath` がどのカレンダーの設定の位置かを結果だけから辿れる。`decidedBy` は外側の番号のまま
+
+### Changed
+
+- 日時の文字列の区切りを `T` だけにし、空白で区切った文字列は `invalid-time` にした（上の「移行」）
+- README: 繰り返しの規則の節に祝前日、他の国・地域の祝日の節に `bizdays-toolkit/provider` と復活祭で決まる提供元の例、合成の節に `decidedByPath`、日付・日時の入力の節に区切りの条件、確かめている環境に Bun・Deno を足した。サイズの値を測り直した（ルート約 9.8KB・日本の祝日込み約 11.6KB・英国の祝日込み約 11.5KB。0.16.0 で測定）
+- `docs/decisions.md`: 14 番に年ごとの列挙で足りる理由、26 番に Bun・Deno、29 番に空白区切りの廃止、33 番に祝前日を足した経緯、36 番に曜日の日に `rulePath` を付けない理由の書き直し（位置は書けるが冗長）、41 番に次の月に併合する側を選んだ理由を書き、43 番（祝前日・provider・`decidedByPath`・空白区切りの廃止・Bun と Deno の確認）を追加した
+- `RELEASING.md`: 確認の表と固定する版の一覧に `bun`・`deno` ジョブを足した
+
+### 開発
+
+- CI に `bun`・`deno` ジョブを追加した。公開する `dist` を Bun 1.4.3 と Deno 2.9.7（`--unstable-temporal`。本物の Temporal も確かめる）で、`test/compat/runtime.mjs` から `smoke.mjs` を実行して確かめる。どちらも版と SHA-256 を固定した公式のリリースを取得する（workerd と同じ方式）。`smoke.mjs` に `bizdays-toolkit/provider` の確認を足した（Node.js・ブラウザー・workerd・CJS の確認も同じものを呼ぶ）
+- `easterSunday` を `src/uk/rules.ts` から `src/core/date.ts` に移した（結果は変わらない。provider のサブパスが英国のデータを引き込まないため）
+- 規則の診断の性質のテストの生成器に祝前日を加えた。`test/day-before-holiday.test.ts`・`test/provider.test.ts` を新規に足し、利用者の型チェックに祝前日・`decidedByPath`・provider を足した
+- サイズの上限（`size-limits.json`）を上げ、`./provider` のエントリーを足した。ルート 23,000 → 24,000、`./jp` 26,000 → 27,000、`./diagnose` 29,500 → 30,500（gzip）。祝前日の検証・判定・診断と `decidedByPath` のため。`./provider` は 4,500（日付とエラーの共通の実装を含む）
+
 ## [0.15.0] - 2026-10-21
 
 ### 移行
@@ -405,7 +431,8 @@
 
 - 日本: 2026 年 2 月の官報（2027 年の春分・秋分の日）まで反映（`dataVersion: "2026-02"`、`confirmedThrough: 2027`）
 
-[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.15.0...HEAD
+[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.16.0...HEAD
+[0.16.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.15.0...v0.16.0
 [0.15.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.14.1...v0.15.0
 [0.14.1]: https://github.com/inohan77/bizdays-toolkit/compare/v0.14.0...v0.14.1
 [0.14.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.13.0...v0.14.0

package/README.md

@@ -29,7 +29,7 @@ A business-day calendar that combines public holidays with company or store clos
 - **A calendar from a schedule**: `createCalendarFromSchedule` turns a schedule such as store hours into a business-day calendar, so the hours are the only configuration and business-day arithmetic works on them
 - **Combining calendars**: `combineCalendars` builds a calendar of the days on which all of several calendars are open (your company and the bank, for a remittance date) or any of them is open (any of several stores), and business-day arithmetic works on the result
 - **Time-zone safe**: instants such as `Date` are converted to a civil date in the calendar's time zone (`Asia/Tokyo` for Japan, `Europe/London` for the UK) before evaluation. A server running in UTC does not treat 00:00–09:00 in Japan as the previous day
-- **Lightweight, zero dependencies**: about 9.7 KB min+gzip (about 11.5 KB with Japanese holidays, about 11.4 KB with UK bank holidays; measured for 0.15.0). ESM, bundled types and `sideEffects: false`. Written in standard JavaScript and `Intl` only (no Node.js APIs); CI tests it on Node.js, Chrome, Firefox, Edge, Safari and Cloudflare Workers
+- **Lightweight, zero dependencies**: about 9.8 KB min+gzip (about 11.6 KB with Japanese holidays, about 11.5 KB with UK bank holidays; measured for 0.16.0). ESM, bundled types and `sideEffects: false`. Written in standard JavaScript and `Intl` only (no Node.js APIs); CI tests it on Node.js, Chrome, Firefox, Edge, Safari, Cloudflare Workers, Bun and Deno
 - **Extensible to other countries and regions**: holiday providers are pluggable through the `HolidayProvider` interface. Japan and the UK are bundled
 
 ## Installation
@@ -38,7 +38,7 @@ A business-day calendar that combines public holidays with company or store clos
 pnpm add bizdays-toolkit
 ```
 
-Node.js 22.12 or later. CI tests the package on Node.js 22.12, 22, 24 and 26, on Chrome, Firefox and Edge (Linux) and Safari (macOS), and on Cloudflare Workers (workerd, the open-source Workers runtime). The browsers are the latest stable versions on GitHub's runners, so their versions change as the runners are updated. The package is ESM only, but it can also be loaded from CommonJS with `require()` (tested in CI as well; on Node.js 22.12, `require()` prints an experimental-feature warning, which does not affect the result, and Node.js 26 prints none). Other runtimes (such as Deno, Bun or Vercel's Edge Runtime) are not tested.
+Node.js 22.12 or later. CI tests the package on Node.js 22.12, 22, 24 and 26, on Chrome, Firefox and Edge (Linux) and Safari (macOS), on Cloudflare Workers (workerd, the open-source Workers runtime), and on Bun (1.4) and Deno (2.9). The browsers are the latest stable versions on GitHub's runners, so their versions change as the runners are updated. The package is ESM only, but it can also be loaded from CommonJS with `require()` (tested in CI as well; on Node.js 22.12, `require()` prints an experimental-feature warning, which does not affect the result, and Node.js 26 prints none). Vercel's Edge Runtime is not tested.
 
 Types are bundled. CI type-checks a consumer project against the published type definitions with TypeScript 5.0, 5.5, 5.8, 6.0 and 7.0 (the native compiler), each with `moduleResolution` set to `node16`, `nodenext` and `bundler`, and confirms that an intentional type error is reported by each.
 
@@ -137,9 +137,9 @@ Each day is decided in this order of priority (top first).
 
 This order is fixed. Only the relation between a recurring rule and holidays can be chosen per rule with `onHolidayRule` (next section).
 
-### Recurring rules (weekly, every other week, nth weekday, day of month, holidays, day after a holiday)
+### Recurring rules (weekly, every other week, nth weekday, day of month, holidays, day after or before a holiday)
 
-Recurring closed and open days such as "closed on the 3rd Wednesday", "closed on the 2nd and 4th Saturdays", "closed every other Wednesday", "stocktaking on the last day of the month", "closed on Mondays (on the next weekday if Monday is a holiday)", "open on substitute holidays" or "closed on the day after a holiday" go in `closedRecurring` and `openRecurring`.
+Recurring closed and open days such as "closed on the 3rd Wednesday", "closed on the 2nd and 4th Saturdays", "closed every other Wednesday", "stocktaking on the last day of the month", "closed on Mondays (on the next weekday if Monday is a holiday)", "open on substitute holidays", "closed on the day after a holiday" or "late opening on the day before a holiday" go in `closedRecurring` and `openRecurring`.
 
 ```ts
 const museum = createCalendar({
@@ -174,6 +174,7 @@ museum.isBusinessDay("2026-05-07"); // false (the day after the May 3–6 run of
 | `{ day: 20 }`                                       | The 20th of every month. `day` is 1–31 or -1 (last day); an array gives several                                      |
 | `{ holiday: true, kinds: ["substitute"] }`          | Holidays, optionally narrowed to the given kinds (`Holiday.kind`); judged before `holidayPolicy` (see below)         |
 | `{ dayAfterHoliday: true }`                         | The day after a holiday: the first non-holiday after a holiday or a run of holidays (holidays of the provider only)  |
+| `{ dayBeforeHoliday: true }`                        | The day before a holiday: the non-holiday just before a holiday or a run of holidays (holidays of the provider only) |
 | `months: [8, 12]`                                   | Narrows any pattern to these months                                                                                  |
 | `effectiveFrom: "2027-04-01"`, `effectiveTo: "…"`   | The period the rule is in effect (both ends included). Outside it, the rule is as if it were not written (see below) |
 
@@ -182,6 +183,7 @@ museum.isBusinessDay("2026-05-07"); // false (the day after the May 3–6 run of
 - **Every other week** (`interval: 2`) is not the same as the 1st and 3rd weekdays (`nth: [1, 3]`): a month with five Wednesdays shifts the latter by a week. `interval` is the number of weeks (an integer of 2 or more) and `anchor` is a date on the same weekday that the cycle passes through; the rule matches that date and every `interval` weeks before and after it. Stores announce "every other Wednesday from January 7", so copy that date. To start at the anchor rather than also matching earlier dates, add `effectiveFrom`. `interval` cannot be combined with `nth`
 - **Holiday rules** (`{ holiday: true }`) write exceptions to the default holiday handling: "open on holidays from April 2027" is `openRecurring: [{ holiday: true, effectiveFrom: "2027-04-01" }]` with `holidayPolicy: "closed"` kept for the past, "open on substitute holidays and citizens' holidays" is `openRecurring: [{ holiday: true, kinds: ["substitute", "citizens"] }]`, and "special hours on the May holidays" in a schedule is `recurring: [{ holiday: true, months: [5], value: … }]`. `kinds` narrows to those `Holiday.kind` values (see the provider's list; with `holidays: jp` the editor completes them), `weekdays` to those weekdays ("morning hours on a Saturday holiday" is `{ holiday: true, weekdays: [6], value: … }`), `months` to those months; omit them for all holidays. The rule is judged at the "over the holiday" step, before `holidayPolicy` or a schedule's `holiday`, and also with `holidayPolicy: "ignore"`. Its days are holidays, so `onHolidayRule` cannot be set on it (`invalid-option`); `holiday` still shows the holiday
 - **The day after a holiday** is never itself a holiday, so `onHolidayRule` cannot be set on such a rule (it is an `invalid-option`). "Holidays" are those of the holiday provider, not annual closures. A rule of this kind matches no day without a holiday provider. `weekdays` narrows it to those weekdays: a museum "closed on the day after a holiday, except when that day is a Saturday or Sunday" is `{ dayAfterHoliday: true, weekdays: [1, 2, 3, 4, 5] }` (opening the weekend with `openRecurring` instead would override every other weekend closure)
+- **The day before a holiday** (`{ dayBeforeHoliday: true }`) is the mirror image: the day whose next day is a holiday and which is not a holiday itself, so before a run of holidays it is only the day before the run (in May 2026 it is Saturday May 2; May 4 and 5 are holidays themselves). The same rules apply (`weekdays`, `months`, effective periods, no `onHolidayRule`, no match without a provider). It writes "eve-of-holiday rates" in a schedule, "open until 2 a.m. on the day before a holiday" (`weekdays: [1, 2, 3, 4, 5]` keeps weekends as usual), or an earlier shipping cutoff on the day before a holiday (put the cutoff time in a schedule and pass `cutoffs.valueOn(date)` as `cutoff`)
 - Among recurring rules, the one written first in the array wins, and `openRecurring` wins over `closedRecurring`. The day after Labor Thanksgiving Day on a Monday (2026-11-23) is both the day the Monday rule moves to and the day after a holiday; the rule written first decides, and `dayInfo` shows which
 
 **Effective periods** (`effectiveFrom`, `effectiveTo`) let one calendar represent a change of rules and still reproduce past dates. They go on recurring rules and on annual closures (`closedAnnual` in object form).
@@ -229,8 +231,15 @@ const hours = createSchedule<Hours>({
   recurring: [
     { weekday: 1, value: null, name: "Closed on Mondays", onHolidayRule: "after-holiday" },
     { day: -1, value: { open: "10:00", close: "17:00" }, name: "Short hours at month end" },
+    {
+      dayBeforeHoliday: true,
+      value: { open: "10:00", close: "23:00" },
+      name: "Late on the eve of a holiday",
+    },
   ],
 });
+hours.valueOn("2026-05-02"); // { open: "10:00", close: "23:00" } (the day before the May 3–6 holidays)
+hours.dayInfo("2026-05-04").reason; // "weekday" (a holiday in the run is not the day before a holiday)
 ```
 
 ### Combining calendars
@@ -256,7 +265,7 @@ const bank = createCalendar({
 const remittance = combineCalendars([company, bank], { businessDay: "all" });
 remittance.addBusinessDays("2026-12-28", 2); // "2027-01-05"
 remittance.dayInfo("2026-12-29");
-// { date: "2026-12-29", weekday: 2, businessDay: false, reason: "closed-annual", name: "New Year closure", rulePath: "closedAnnual[0]", decidedBy: 0 }
+// { date: "2026-12-29", weekday: 2, businessDay: false, reason: "closed-annual", name: "New Year closure", rulePath: "closedAnnual[0]", decidedBy: 0, decidedByPath: [0] }
 
 // Any of several stores is open
 const anyStore = combineCalendars([company, bank], { businessDay: "any" });
@@ -264,6 +273,7 @@ anyStore.isBusinessDay("2026-12-29"); // true
 ```
 
 - `dayInfo` reports `reason`, `name`, `shiftedFrom` and `rulePath` from the first calendar whose result equals the combined result, and the index of that calendar in `decidedBy` (`rulePath` is a position in that calendar's options). With `"all"`, a closed day is explained by the first calendar that is closed, and an open day by calendar 0 (all are open). With `"any"` it is the other way round
+- `decidedByPath` is the list of indexes down to the calendar that decided, outermost first, so that `rulePath` can be traced from the result alone when combined calendars are combined again: `[0]` for a plain combination (the same as `decidedBy`), `[0, 1]` for calendar 1 inside calendar 0. `decidedBy` stays the outer index
 - `holiday`, `isHoliday`, `holidaysInYear` and so on use the union of the calendars' holiday providers: the same provider object counts once, a wrapped provider (such as `jp` with some kinds filtered out) counts as a different one, and when two providers have a holiday on the same date, the provider of the earlier calendar decides the holiday shown. Combining a calendar with a wrapped `jp` and one with `jp` itself therefore keeps the business-day results but still shows the filtered-out holidays in `holiday`. `outOfRange` is `"throw"` if any calendar throws outside its supported years
 - All calendars must share a time zone (`time-zone-conflict` otherwise). Passing fewer than two calendars, or the same calendar twice, is an `invalid-argument`. `maxSearchDays` (default 3660) can be given in the options
 - A combined calendar can be combined again. Option diagnostics work on options, not on calendars, so diagnose each calendar's options separately
@@ -513,7 +523,7 @@ Every method accepts the following inputs. Returned dates are always `"YYYY-MM-D
 | Temporal `PlainDate`, `PlainDateTime`                | A civil date or date and time (no dependency on Temporal)         |
 | Temporal `Instant`, `ZonedDateTime`                  | An instant                                                        |
 
-Temporal objects are recognized by their shape, so the package does not depend on Temporal. CI also checks real Temporal objects in the runtimes that provide Temporal (the CI log shows whether each runtime had it).
+The separator between the date and the time is `T` (upper or lower case), as in the `DateTimeInput` type; a space (`"2026-11-23 10:00"`) is an `invalid-time` error. Temporal objects are recognized by their shape, so the package does not depend on Temporal. CI also checks real Temporal objects in the runtimes that provide Temporal (the CI log shows whether each runtime had it).
 
 The calendar's time zone is the `timeZone` option, then the holiday provider's time zone, then `"UTC"`.
 
@@ -562,6 +572,38 @@ const myCountry: HolidayProvider = {
 const calendar = createCalendar({ holidays: myCountry, closedWeekdays: [0, 6] });
 ```
 
+Most holidays of other countries are an nth weekday of a month (the US federal holidays) or a fixed number of days from Easter Sunday (much of Europe). `bizdays-toolkit/provider` exposes the calendar arithmetic the bundled providers use for these, so a provider does not have to reimplement and verify it: `nthWeekdayOfMonth(year, month, weekday, n)` (`n` is 1–5 or -1 for the last), `easterSunday(year)` (Gregorian; verified against GOV.UK for the UK providers), `daysInMonth(year, month)` and `isLeapYear(year)`. Combine them with `addDays` and `weekdayOf` from the root. These functions are `@beta` (they may change in a minor version while their use settles).
+
+```ts
+import { addDays, createCalendar, type HolidayProvider } from "bizdays-toolkit";
+import { easterSunday, nthWeekdayOfMonth } from "bizdays-toolkit/provider";
+
+const bavaria: HolidayProvider<"public"> = {
+  id: "DE-BY",
+  timeZone: "Europe/Berlin",
+  supportedYears: { from: 2000, to: 2100 },
+  dataVersion: "example",
+  holidaysInYear: (year) => {
+    const easter = easterSunday(year);
+    const day = (date: string, name: string, nameEn: string) => ({
+      date,
+      name,
+      nameEn,
+      kind: "public" as const,
+      confirmed: true,
+    });
+    return [
+      day(addDays(easter, -2), "Karfreitag", "Good Friday"),
+      day(addDays(easter, 1), "Ostermontag", "Easter Monday"),
+      day(addDays(easter, 60), "Fronleichnam", "Corpus Christi"),
+    ];
+  },
+};
+createCalendar({ holidays: bavaria }).isHoliday("2026-06-04"); // true (Corpus Christi)
+nthWeekdayOfMonth(2026, 11, 4, 4); // "2026-11-26" (the 4th Thursday of November: Thanksgiving Day)
+nthWeekdayOfMonth(2026, 5, 1, -1); // "2026-05-25" (the last Monday of May: Memorial Day)
+```
+
 Holidays can carry names in other languages in `names`. The keys are canonical BCP 47 language tags (`"zh-Hant"`, `"ko"` and so on). The bundled Japanese holidays have no `names` (only the officially sourced Japanese and English names are bundled); among the UK providers, only Wales has Welsh names. If you need more, wrap the provider.
 
 ```ts

package/dist/core/calendar.d.ts

@@ -126,6 +126,12 @@ export interface DayInfo<Kind extends string = string> {
      * reason・name・shiftedFrom・rulePath はそのカレンダーの結果。合成していないカレンダーでは付かない
      */
     readonly decidedBy?: number;
+    /**
+     * 合成したカレンダーで、判定を決めたカレンダーまでの番号の列（外側から順）。入れ子でない合成では長さ 1 で、
+     * 先頭は decidedBy と同じ。合成したカレンダーをさらに合成したとき、rulePath がどのカレンダーの設定の位置かを
+     * 結果だけから辿れる（例: [0, 1] は 0 番のカレンダーの中の 1 番）。合成していないカレンダーでは付かない
+     */
+    readonly decidedByPath?: readonly number[];
 }
 /**
  * カレンダーの合成のオプション。
@@ -268,7 +274,8 @@ export declare function createCalendar<Kind extends string = string>(options?: C
  * 営業している日を営業日とする。返すのは通常の営業日カレンダーで、営業日の加減算・調整・期日などが合成結果で動く。
  *
  * - dayInfo の reason・name・shiftedFrom・rulePath は、合成結果と同じ判定をした最初のカレンダーの結果で、
- *   その番号を decidedBy で返す。holiday・isHoliday などは、すべてのカレンダーの祝日の提供元の和集合で判定する
+ *   その番号を decidedBy で返す。入れ子の合成では、内側の番号まで含めた列を decidedByPath で返す。
+ *   holiday・isHoliday などは、すべてのカレンダーの祝日の提供元の和集合で判定する
  * - タイムゾーンはすべてのカレンダーで同じでなければならない（time-zone-conflict）。
  *   2 つ未満、同じカレンダーを 2 回渡した場合は invalid-argument
  * - 合成したカレンダーをさらに合成することもできる。規則の診断（diagnoseCalendar）の対象にはならないので、

package/dist/core/calendar.js

@@ -361,7 +361,8 @@ const isCalendarLike = (v) => typeof v === "object" &&
  * 営業している日を営業日とする。返すのは通常の営業日カレンダーで、営業日の加減算・調整・期日などが合成結果で動く。
  *
  * - dayInfo の reason・name・shiftedFrom・rulePath は、合成結果と同じ判定をした最初のカレンダーの結果で、
- *   その番号を decidedBy で返す。holiday・isHoliday などは、すべてのカレンダーの祝日の提供元の和集合で判定する
+ *   その番号を decidedBy で返す。入れ子の合成では、内側の番号まで含めた列を decidedByPath で返す。
+ *   holiday・isHoliday などは、すべてのカレンダーの祝日の提供元の和集合で判定する
  * - タイムゾーンはすべてのカレンダーで同じでなければならない（time-zone-conflict）。
  *   2 つ未満、同じカレンダーを 2 回渡した場合は invalid-argument
  * - 合成したカレンダーをさらに合成することもできる。規則の診断（diagnoseCalendar）の対象にはならないので、
@@ -426,6 +427,8 @@ export function combineCalendars(calendars, options) {
         if (base.rulePath !== undefined)
             result.rulePath = base.rulePath;
         result.decidedBy = decidedBy;
+        // 内側が合成したカレンダーなら、その経路の前に自分の番号を付ける（入れ子でなければ長さ 1）
+        result.decidedByPath = Object.freeze([decidedBy, ...(base.decidedByPath ?? [])]);
         return Object.freeze(result);
     }
     return buildCalendar(lookup, isOpen, info, maxSearchDays);

package/dist/core/date.d.ts

@@ -52,3 +52,8 @@ export declare function diffDays(from: DateString, to: DateString): number;
 export declare function weekdayOf(date: DateString): Weekday;
 /** その月の第 n 何曜日（n は 1 始まり） */
 export declare function nthWeekdayOfMonth(year: number, month: number, weekday: Weekday, n: number): DateString;
+/**
+ * 復活祭の日曜日（グレゴリオ暦。Anonymous Gregorian algorithm）。英国の祝日の計算に使い、提供元の実装者向けに
+ * bizdays-toolkit/provider からも公開する（入力の検証はそちらで行う）
+ */
+export declare function easterSunday(year: number): DateString;

package/dist/core/date.js

@@ -99,3 +99,24 @@ export function nthWeekdayOfMonth(year, month, weekday, n) {
     const offset = (weekday - weekdayOf(formatDate(year, month, 1)) + 7) % 7;
     return formatDate(year, month, 1 + offset + (n - 1) * 7);
 }
+/**
+ * 復活祭の日曜日（グレゴリオ暦。Anonymous Gregorian algorithm）。英国の祝日の計算に使い、提供元の実装者向けに
+ * bizdays-toolkit/provider からも公開する（入力の検証はそちらで行う）
+ */
+export function easterSunday(year) {
+    const a = year % 19;
+    const b = Math.floor(year / 100);
+    const c = year % 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 m = Math.floor((a + 11 * h + 22 * l) / 451);
+    const month = Math.floor((h + l - 7 * m + 114) / 31);
+    const day = ((h + l - 7 * m + 114) % 31) + 1;
+    return formatDate(year, month, day);
+}

package/dist/core/diagnose.d.ts

@@ -8,7 +8,7 @@
  * - warning … 作れるが、意図と違う可能性が高いもの
  *     unknown-option … 知らないキー（作成時は無視される）。近い既知のキーがあれば message に候補を挙げる
  *     shadowed       … 同じ種類の先の規則に完全に覆われ、決して使われない（relatedPath に先の規則）
- *     never-matches  … 当てはまる日がない繰り返しの規則（2 月 30 日、有効期間の中に第 5 水曜日がない、提供元のない設定の祝日の翌日、など）
+ *     never-matches  … 当てはまる日がない繰り返しの規則（2 月 30 日、有効期間の中に第 5 水曜日がない、提供元のない設定の祝日の翌日・祝前日、など）
  *     out-of-range   … 個別の日付、または規則の有効期間が祝日の提供元の対応年の外にある（relatedPath に提供元）
  *     no-business-day … 営業日が 1 日もない設定（営業日カレンダーのみ）
  * - info    … redundant: 取り除いても結果が変わらない規則

package/dist/core/diagnose.js

@@ -8,7 +8,7 @@
  * - warning … 作れるが、意図と違う可能性が高いもの
  *     unknown-option … 知らないキー（作成時は無視される）。近い既知のキーがあれば message に候補を挙げる
  *     shadowed       … 同じ種類の先の規則に完全に覆われ、決して使われない（relatedPath に先の規則）
- *     never-matches  … 当てはまる日がない繰り返しの規則（2 月 30 日、有効期間の中に第 5 水曜日がない、提供元のない設定の祝日の翌日、など）
+ *     never-matches  … 当てはまる日がない繰り返しの規則（2 月 30 日、有効期間の中に第 5 水曜日がない、提供元のない設定の祝日の翌日・祝前日、など）
  *     out-of-range   … 個別の日付、または規則の有効期間が祝日の提供元の対応年の外にある（relatedPath に提供元）
  *     no-business-day … 営業日が 1 日もない設定（営業日カレンダーのみ）
  * - info    … redundant: 取り除いても結果が変わらない規則
@@ -360,7 +360,7 @@ function analyze(c, compiled, isCalendar) {
     });
     // --- 繰り返しの規則: 当てはまる日がない・覆われている ---
     const recurringBits = recurring.map(patternBits);
-    /** 祝日・祝日の翌日の規則の判定に使う（提供元の対応年の外は祝日でないとみなす） */
+    /** 祝日・祝日の翌日・祝前日の規則の判定に使う（提供元の対応年の外は祝日でないとみなす） */
     const holidayOfSafe = (date) => {
         try {
             return lookup.holidayOn(date);
@@ -369,7 +369,7 @@ function analyze(c, compiled, isCalendar) {
             return undefined;
         }
     };
-    /** 祝日に従属する規則（祝日・祝日の翌日）が、調べる期間と有効期間の中で 1 日でも当てはまるか（祝日は年ごとに違うので、全日を調べる） */
+    /** 祝日に従属する規則（祝日・祝日の翌日・祝前日）が、調べる期間と有効期間の中で 1 日でも当てはまるか（祝日は年ごとに違うので、全日を調べる） */
     const holidayRuleMatches = (rule) => {
         if (source.providers.length === 0 || !window)
             return false;
@@ -381,7 +381,7 @@ function analyze(c, compiled, isCalendar) {
     const setCovers = (a, b) => a === null || (b !== null && [...b].every((v) => a.has(v)));
     recurring.forEach((rule, j) => {
         const bits = recurringBits[j];
-        const holidayBased = rule.holiday || rule.dayAfterHoliday;
+        const holidayBased = rule.holiday || rule.dayAfterHoliday || rule.dayBeforeHoliday;
         const matches = holidayBased ? holidayRuleMatches(rule) : matchesAnyDay(rule, cycle);
         if (!matches) {
             unused.add(rule);
@@ -390,13 +390,15 @@ function analyze(c, compiled, isCalendar) {
                     ? "This rule matches no day: there are no holidays without a holiday provider"
                     : rule.holiday
                         ? "This rule matches no day: no holiday of the selected kinds, weekdays and months within its effective period"
-                        : "This rule matches no day: no day after a holiday on the selected weekdays and months within its effective period"
+                        : rule.dayAfterHoliday
+                            ? "This rule matches no day: no day after a holiday on the selected weekdays and months within its effective period"
+                            : "This rule matches no day: no day before a holiday on the selected weekdays and months within its effective period"
                 : rule.effectiveFrom === null && rule.effectiveTo === null
                     ? "This rule matches no day (for example, a day that does not exist in the selected months)"
                     : "This rule matches no day within its effective period");
             return;
         }
-        // 祝日・祝日の翌日の規則は祝日次第で年ごとに変わるので、形の包含は同じ形の規則どうし（種別・曜日・月の絞り込み）だけで調べる
+        // 祝日・祝日の翌日・祝前日の規則は祝日次第で年ごとに変わるので、形の包含は同じ形の規則どうし（種別・曜日・月の絞り込み）だけで調べる
         const k = recurring.findIndex((r, i) => i < j &&
             canCover(r, rule) &&
             periodCovers(r, rule) &&
@@ -405,12 +407,14 @@ function analyze(c, compiled, isCalendar) {
                     setCovers(r.kinds, rule.kinds) &&
                     setCovers(r.weekdays, rule.weekdays) &&
                     setCovers(r.months, rule.months)
-                : rule.dayAfterHoliday
-                    ? r.dayAfterHoliday &&
+                : rule.dayAfterHoliday || rule.dayBeforeHoliday
+                    ? r.dayAfterHoliday === rule.dayAfterHoliday &&
+                        r.dayBeforeHoliday === rule.dayBeforeHoliday &&
                         setCovers(r.weekdays, rule.weekdays) &&
                         setCovers(r.months, rule.months)
                     : !r.holiday &&
                         !r.dayAfterHoliday &&
+                        !r.dayBeforeHoliday &&
                         intervalCovers(r, rule) &&
                         isSubset(bits, recurringBits[i])));
         if (k < 0)

package/dist/core/input.js

@@ -10,7 +10,8 @@
  */
 import { formatDate, parseDate } from "./date.js";
 import { rangeError, typeError } from "./errors.js";
-const DATETIME_RE = /^(\d{4}-\d{2}-\d{2})[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.\d{1,9})?)?(Z|[+-]\d{2}:?\d{2})?$/i;
+// 日付と時刻の区切りは "T" だけ（型 DateTimeInput と同じ）。空白で区切った文字列は 0.16.0 から invalid-time
+const DATETIME_RE = /^(\d{4}-\d{2}-\d{2})T(\d{2}):(\d{2})(?::(\d{2})(?:\.\d{1,9})?)?(Z|[+-]\d{2}:?\d{2})?$/i;
 const formatters = new Map();
 function formatterFor(timeZone) {
     let f = formatters.get(timeZone);

package/dist/core/schedule.d.ts

@@ -13,6 +13,7 @@
  * "after-holiday" の規則は、祝日には当てはめず、その日以降で最初の祝日でない日に当てはめる（振替）。
  * 毎年の月日・繰り返しの規則の有効期間（effectiveFrom・effectiveTo）の外では、その規則は書かれていないのと同じ。
  * 祝日の翌日の規則（dayAfterHoliday）は、前日が祝日でその日自身は祝日でない日に当てはまる（提供元の祝日だけで判定）。
+ * 祝前日の規則（dayBeforeHoliday）は、翌日が祝日でその日自身は祝日でない日に当てはまる（同じく提供元の祝日だけ）。
  * 祝日の規則（holiday: true。kinds で種別を絞れる）は、「祝日の上」の段階で判定する
  *
  * 営業日カレンダー（createCalendar）は、このスケジュールの真偽値版として作られている。
@@ -90,6 +91,7 @@ export interface WeekdayPattern {
     readonly months?: readonly Month[];
     readonly day?: never;
     readonly dayAfterHoliday?: never;
+    readonly dayBeforeHoliday?: never;
     readonly holiday?: never;
     readonly weekdays?: never;
     readonly kinds?: never;
@@ -108,6 +110,7 @@ export interface DayOfMonthPattern {
     readonly interval?: never;
     readonly anchor?: never;
     readonly dayAfterHoliday?: never;
+    readonly dayBeforeHoliday?: never;
     readonly holiday?: never;
     readonly weekdays?: never;
     readonly kinds?: never;
@@ -128,6 +131,28 @@ export interface DayAfterHolidayPattern {
     readonly interval?: never;
     readonly anchor?: never;
     readonly day?: never;
+    readonly dayBeforeHoliday?: never;
+    readonly holiday?: never;
+    readonly kinds?: never;
+}
+/**
+ * 祝前日（翌日が祝日で、その日自身は祝日でない日。連休なら連休の初日の前日）。「祝日」は提供元の祝日だけ。
+ * 祝日の翌日（dayAfterHoliday）の鏡像で、祝前日料金・祝前日の営業時間の延長・締め時刻の繰り上げなどを規則として書く。
+ * 当てはまる日は祝日でないので、onHolidayRule は指定できない（指定すると invalid-option）。
+ * @public
+ */
+export interface DayBeforeHolidayPattern {
+    readonly dayBeforeHoliday: true;
+    /** 当てはめる曜日（祝前日の曜日。省略時はすべての曜日。例: [1, 2, 3, 4, 5] で土日に当たる祝前日は除く） */
+    readonly weekdays?: readonly Weekday[];
+    /** 当てはめる月（祝前日の月。省略時はすべての月） */
+    readonly months?: readonly Month[];
+    readonly weekday?: never;
+    readonly nth?: never;
+    readonly interval?: never;
+    readonly anchor?: never;
+    readonly day?: never;
+    readonly dayAfterHoliday?: never;
     readonly holiday?: never;
     readonly kinds?: never;
 }
@@ -152,12 +177,13 @@ export interface HolidayPattern<Kind extends string = string> {
     readonly anchor?: never;
     readonly day?: never;
     readonly dayAfterHoliday?: never;
+    readonly dayBeforeHoliday?: never;
 }
 /**
  * 繰り返しのパターン。
  * @public
  */
-export type RecurringPattern<Kind extends string = string> = WeekdayPattern | DayOfMonthPattern | DayAfterHolidayPattern | HolidayPattern<Kind>;
+export type RecurringPattern<Kind extends string = string> = WeekdayPattern | DayOfMonthPattern | DayAfterHolidayPattern | DayBeforeHolidayPattern | HolidayPattern<Kind>;
 /**
  * 繰り返しの規則（営業日カレンダーの closedRecurring・openRecurring）。
  * @public
@@ -375,11 +401,13 @@ export interface RecurringRuleCompiled<T> extends CompiledPeriod {
     readonly days: ReadonlySet<number> | null;
     /** 祝日の翌日の規則か */
     readonly dayAfterHoliday: boolean;
+    /** 祝前日の規則か */
+    readonly dayBeforeHoliday: boolean;
     /** 祝日の規則か */
     readonly holiday: boolean;
     /** 祝日の規則で絞る種別（null はすべての祝日） */
     readonly kinds: ReadonlySet<string> | null;
-    /** 祝日・祝日の翌日の規則で絞る曜日（null はすべての曜日） */
+    /** 祝日・祝日の翌日・祝前日の規則で絞る曜日（null はすべての曜日） */
     readonly weekdays: ReadonlySet<number> | null;
     /** 月の集合（null はすべての月） */
     readonly months: ReadonlySet<number> | null;
@@ -389,12 +417,12 @@ export interface RecurringRuleCompiled<T> extends CompiledPeriod {
 }
 /** @internal 繰り返しの規則を検証して取り込む */
 export declare function compileRecurringRules<T>(c: IssueCollector, path: string, entries: unknown, valueOf: (entry: Record<string, unknown>, path: string) => T | undefined, keys: readonly string[]): RecurringRuleCompiled<T>[];
-/** @internal その日の祝日を返す関数（祝日・祝日の翌日の規則の判定に使う。提供元の対応年の外は祝日でないとみなすこと） */
+/** @internal その日の祝日を返す関数（祝日・祝日の翌日・祝前日の規則の判定に使う。提供元の対応年の外は祝日でないとみなすこと） */
 export type HolidayOf = (date: DateString) => Holiday<string> | undefined;
 /**
- * @internal 繰り返しの規則の形（曜日・第 n 回目・周期・日・祝日の翌日・月）がその日に当てはまるか。
+ * @internal 繰り返しの規則の形（曜日・第 n 回目・周期・日・祝日・祝日の翌日・祝前日・月）がその日に当てはまるか。
  * 有効期間は考えない（規則の診断で、形どうしの包含を調べるために分けている）。
- * 祝日の翌日の規則は isHoliday で判定し、isHoliday を渡さなければ当てはまらない
+ * 祝日に従属する規則は holidayOf で判定し、holidayOf を渡さなければ当てはまらない
  */
 export declare function matchPattern(rule: RecurringRuleCompiled<unknown>, date: DateString, holidayOf?: HolidayOf): boolean;
 /** @internal 繰り返しの規則がその日に当てはまるか（有効期間を含む） */

package/dist/core/schedule.js

@@ -13,6 +13,7 @@
  * "after-holiday" の規則は、祝日には当てはめず、その日以降で最初の祝日でない日に当てはめる（振替）。
  * 毎年の月日・繰り返しの規則の有効期間（effectiveFrom・effectiveTo）の外では、その規則は書かれていないのと同じ。
  * 祝日の翌日の規則（dayAfterHoliday）は、前日が祝日でその日自身は祝日でない日に当てはまる（提供元の祝日だけで判定）。
+ * 祝前日の規則（dayBeforeHoliday）は、翌日が祝日でその日自身は祝日でない日に当てはまる（同じく提供元の祝日だけ）。
  * 祝日の規則（holiday: true。kinds で種別を絞れる）は、「祝日の上」の段階で判定する
  *
  * 営業日カレンダー（createCalendar）は、このスケジュールの真偽値版として作られている。
@@ -211,9 +212,15 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
         const hasWeekday = "weekday" in entry;
         const hasDay = "day" in entry;
         const hasAfter = "dayAfterHoliday" in entry;
+        const hasBefore = "dayBeforeHoliday" in entry;
         const hasHoliday = "holiday" in entry;
-        if (Number(hasWeekday) + Number(hasDay) + Number(hasAfter) + Number(hasHoliday) !== 1) {
-            c.error("invalid-option", p, 'must have exactly one of "weekday", "day", "dayAfterHoliday" or "holiday"');
+        if (Number(hasWeekday) +
+            Number(hasDay) +
+            Number(hasAfter) +
+            Number(hasBefore) +
+            Number(hasHoliday) !==
+            1) {
+            c.error("invalid-option", p, 'must have exactly one of "weekday", "day", "dayAfterHoliday", "dayBeforeHoliday" or "holiday"');
             return;
         }
         let kinds = null;
@@ -281,7 +288,7 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
                     ok = false;
             }
             else {
-                const key = hasAfter ? "dayAfterHoliday" : "holiday";
+                const key = hasAfter ? "dayAfterHoliday" : hasBefore ? "dayBeforeHoliday" : "holiday";
                 if (entry[key] !== true) {
                     c.error("invalid-option", `${p}.${key}`, "must be true");
                     ok = false;
@@ -289,7 +296,9 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
                 if ("onHolidayRule" in entry) {
                     c.error("invalid-option", `${p}.onHolidayRule`, hasAfter
                         ? 'cannot be used with "dayAfterHoliday" (the day after a holiday is never a holiday)'
-                        : 'cannot be used with "holiday" (the rule applies on holidays; it is judged before holidayPolicy)');
+                        : hasBefore
+                            ? 'cannot be used with "dayBeforeHoliday" (the day before a holiday is never a holiday)'
+                            : 'cannot be used with "holiday" (the rule applies on holidays; it is judged before holidayPolicy)');
                     ok = false;
                 }
                 if (hasHoliday && entry["kinds"] !== undefined && !Array.isArray(entry["kinds"])) {
@@ -311,8 +320,8 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
         }
         let weekdays = null;
         if ("weekdays" in entry) {
-            if (!hasHoliday && !hasAfter) {
-                c.error("invalid-option", `${p}.weekdays`, '"weekdays" can be used only with "holiday" or "dayAfterHoliday"');
+            if (!hasHoliday && !hasAfter && !hasBefore) {
+                c.error("invalid-option", `${p}.weekdays`, '"weekdays" can be used only with "holiday", "dayAfterHoliday" or "dayBeforeHoliday"');
                 ok = false;
             }
             else if (!Array.isArray(entry["weekdays"])) {
@@ -357,6 +366,7 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
                 anchor,
                 days,
                 dayAfterHoliday: hasAfter,
+                dayBeforeHoliday: hasBefore,
                 holiday: hasHoliday,
                 kinds,
                 weekdays,
@@ -371,15 +381,15 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
     return rules;
 }
 /**
- * @internal 繰り返しの規則の形（曜日・第 n 回目・周期・日・祝日の翌日・月）がその日に当てはまるか。
+ * @internal 繰り返しの規則の形（曜日・第 n 回目・周期・日・祝日・祝日の翌日・祝前日・月）がその日に当てはまるか。
  * 有効期間は考えない（規則の診断で、形どうしの包含を調べるために分けている）。
- * 祝日の翌日の規則は isHoliday で判定し、isHoliday を渡さなければ当てはまらない
+ * 祝日に従属する規則は holidayOf で判定し、holidayOf を渡さなければ当てはまらない
  */
 export function matchPattern(rule, date, holidayOf) {
     const { year, month, day } = parseDate(date);
     if (rule.months && !rule.months.has(month))
         return false;
-    if (rule.holiday || rule.dayAfterHoliday) {
+    if (rule.holiday || rule.dayAfterHoliday || rule.dayBeforeHoliday) {
         if (holidayOf === undefined)
             return false;
         if (rule.weekdays && !rule.weekdays.has(weekdayOf(date)))
@@ -388,7 +398,10 @@ export function matchPattern(rule, date, holidayOf) {
             const h = holidayOf(date);
             return h !== undefined && (rule.kinds === null || rule.kinds.has(h.kind));
         }
-        return holidayOf(date) === undefined && holidayOf(addDays(date, -1)) !== undefined;
+        // 祝日の翌日は前日が祝日、祝前日は翌日が祝日（どちらもその日自身は祝日でない）
+        if (holidayOf(date) !== undefined)
+            return false;
+        return holidayOf(addDays(date, rule.dayAfterHoliday ? -1 : 1)) !== undefined;
     }
     const dim = daysInMonth(year, month);
     if (rule.weekday !== null) {
@@ -638,6 +651,7 @@ export const RECURRING_RULE_KEYS = [
     "anchor",
     "day",
     "dayAfterHoliday",
+    "dayBeforeHoliday",
     "holiday",
     "kinds",
     "weekdays",

package/dist/index.d.ts

@@ -8,7 +8,7 @@
  * 公開する名前と型は etc/api.md に記録し、pnpm check で意図しない変化を検出する。
  */
 export { combineCalendars, createCalendar, createCalendarFromSchedule, type AdjustOptions, type AnnualDate, type AnnualRange, type BusinessDayConvention, type BusinessDayOptions, type Calendar, type CalendarOptions, type CombineOptions, type DateRange, type DayInfo, type DayReason, type DueDateOptions, type HolidayPolicy, type KnownDayReason, type SpecificDate, } from "./core/calendar.ts";
-export { createSchedule, type AnnualRangeValue, type AnnualValue, type CivilDateTimeParts, type DateRangeValue, type DateValue, type DayAfterHolidayPattern, type DayOfMonth, type DayOfMonthPattern, type EffectivePeriod, type HolidayLookup, type HolidayPattern, type HolidaySourceOptions, type HolidayValueRule, type KnownScheduleReason, type Month, type Nth, type OnHolidayRule, type RecurringPattern, type RecurringRule, type RecurringValue, type Schedule, type ScheduleDay, type ScheduleOptions, type ScheduleReason, type WeekdayPattern, } from "./core/schedule.ts";
+export { createSchedule, type AnnualRangeValue, type AnnualValue, type CivilDateTimeParts, type DateRangeValue, type DateValue, type DayAfterHolidayPattern, type DayBeforeHolidayPattern, type DayOfMonth, type DayOfMonthPattern, type EffectivePeriod, type HolidayLookup, type HolidayPattern, type HolidaySourceOptions, type HolidayValueRule, type KnownScheduleReason, type Month, type Nth, type OnHolidayRule, type RecurringPattern, type RecurringRule, type RecurringValue, type Schedule, type ScheduleDay, type ScheduleOptions, type ScheduleReason, type WeekdayPattern, } from "./core/schedule.ts";
 export { addDays, diffDays, isValidDate, weekdayOf, type DateString, type Weekday, } from "./core/date.ts";
 export { closingMonth, closingPeriod, monthOf, type MonthString } from "./core/month.ts";
 export { isBizdaysError, type ErrorCode, type KnownErrorCode } from "./core/errors.ts";

package/dist/provider/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 祝日の提供元（HolidayProvider）を実装する人向けの暦の計算（bizdays-toolkit/provider）。
+ *
+ * 多くの国・地域の祝日は「月の第 n 何曜日」（米国の連邦祝日など）と「復活祭からの日数」（ヨーロッパの多くの国）で
+ * 書ける。この 2 種類の計算と、月の日数・うるう年の判定を、ライブラリ内部で使っている実装のまま公開する
+ * （復活祭の計算は英国の祝日で GOV.UK のデータと照合済み）。ルートの addDays・weekdayOf と組み合わせて使う。
+ * 同梱の提供元の実装とは別に、アプリの本体に不要なものが入らないようサブパスに分けている。
+ *
+ * 公開する関数は @beta（マイナー版で変わりうる）。使われ方が固まったら @public にする。
+ */
+import { type DateString, type Weekday } from "../core/date.ts";
+/**
+ * 復活祭の日曜日（グレゴリオ暦）。Good Friday は −2 日、Easter Monday は +1 日、Ascension は +39 日、
+ * Whit Monday は +50 日、Corpus Christi は +60 日（ルートの addDays で求める）。
+ * 年は 1000〜9999 の整数（それ以外は invalid-argument）。
+ * @beta
+ */
+export declare function easterSunday(year: number): DateString;
+/**
+ * その月の第 n 何曜日（n は 1〜5、-1 は最後。曜日は 0 = 日曜日〜6 = 土曜日）。
+ * 例: 1 月の第 3 月曜日は nthWeekdayOfMonth(2026, 1, 1, 3)、5 月の最終月曜日は nthWeekdayOfMonth(2026, 5, 1, -1)。
+ * その月に n 回目のその曜日がないとき（第 5 回目）は invalid-argument。
+ * @beta
+ */
+export declare function nthWeekdayOfMonth(year: number, month: number, weekday: Weekday, n: number): DateString;
+/**
+ * その月の日数（28〜31）。
+ * @beta
+ */
+export declare function daysInMonth(year: number, month: number): number;
+/**
+ * うるう年か（グレゴリオ暦）。
+ * @beta
+ */
+export declare function isLeapYear(year: number): boolean;

package/dist/provider/index.js

@@ -0,0 +1,76 @@
+/**
+ * 祝日の提供元（HolidayProvider）を実装する人向けの暦の計算（bizdays-toolkit/provider）。
+ *
+ * 多くの国・地域の祝日は「月の第 n 何曜日」（米国の連邦祝日など）と「復活祭からの日数」（ヨーロッパの多くの国）で
+ * 書ける。この 2 種類の計算と、月の日数・うるう年の判定を、ライブラリ内部で使っている実装のまま公開する
+ * （復活祭の計算は英国の祝日で GOV.UK のデータと照合済み）。ルートの addDays・weekdayOf と組み合わせて使う。
+ * 同梱の提供元の実装とは別に、アプリの本体に不要なものが入らないようサブパスに分けている。
+ *
+ * 公開する関数は @beta（マイナー版で変わりうる）。使われ方が固まったら @public にする。
+ */
+import { daysInMonth as daysInMonthOf, easterSunday as easterSundayOf, formatDate, isLeapYear as isLeapYearOf, nthWeekdayOfMonth as nthWeekdayOfMonthIn, weekdayOf, } from "../core/date.js";
+import { rangeError } from "../core/errors.js";
+function checkYear(year) {
+    if (!Number.isInteger(year) || year < 1000 || year > 9999) {
+        throw rangeError("invalid-argument", `year must be an integer from 1000 to 9999: ${String(year)}`);
+    }
+}
+function checkMonth(month) {
+    if (!Number.isInteger(month) || month < 1 || month > 12) {
+        throw rangeError("invalid-argument", `month must be an integer from 1 to 12: ${String(month)}`);
+    }
+}
+/**
+ * 復活祭の日曜日（グレゴリオ暦）。Good Friday は −2 日、Easter Monday は +1 日、Ascension は +39 日、
+ * Whit Monday は +50 日、Corpus Christi は +60 日（ルートの addDays で求める）。
+ * 年は 1000〜9999 の整数（それ以外は invalid-argument）。
+ * @beta
+ */
+export function easterSunday(year) {
+    checkYear(year);
+    return easterSundayOf(year);
+}
+/**
+ * その月の第 n 何曜日（n は 1〜5、-1 は最後。曜日は 0 = 日曜日〜6 = 土曜日）。
+ * 例: 1 月の第 3 月曜日は nthWeekdayOfMonth(2026, 1, 1, 3)、5 月の最終月曜日は nthWeekdayOfMonth(2026, 5, 1, -1)。
+ * その月に n 回目のその曜日がないとき（第 5 回目）は invalid-argument。
+ * @beta
+ */
+export function nthWeekdayOfMonth(year, month, weekday, n) {
+    checkYear(year);
+    checkMonth(month);
+    if (!Number.isInteger(weekday) || weekday < 0 || weekday > 6) {
+        throw rangeError("invalid-weekday", `weekday must be an integer from 0 (Sunday) to 6 (Saturday): ${String(weekday)}`);
+    }
+    if (!Number.isInteger(n) || n === 0 || n < -1 || n > 5) {
+        throw rangeError("invalid-argument", `n must be an integer from 1 to 5, or -1 (last): ${String(n)}`);
+    }
+    const days = daysInMonthOf(year, month);
+    if (n === -1) {
+        const last = formatDate(year, month, days);
+        const offset = (weekdayOf(last) - weekday + 7) % 7;
+        return formatDate(year, month, days - offset);
+    }
+    const first = ((weekday - weekdayOf(formatDate(year, month, 1)) + 7) % 7) + 1;
+    if (first + (n - 1) * 7 > days) {
+        throw rangeError("invalid-argument", `${year}-${String(month).padStart(2, "0")} has no ${n}th weekday ${weekday}`);
+    }
+    return nthWeekdayOfMonthIn(year, month, weekday, n);
+}
+/**
+ * その月の日数（28〜31）。
+ * @beta
+ */
+export function daysInMonth(year, month) {
+    checkYear(year);
+    checkMonth(month);
+    return daysInMonthOf(year, month);
+}
+/**
+ * うるう年か（グレゴリオ暦）。
+ * @beta
+ */
+export function isLeapYear(year) {
+    checkYear(year);
+    return isLeapYearOf(year);
+}

package/dist/uk/rules.d.ts

@@ -10,7 +10,6 @@
  * （test/fixtures/govuk-bank-holidays.json）で検証している。CONFIRMED_THROUGH より後の年は、
  * 規則による予測（confirmed: false）。
  */
-import { type DateString } from "../core/date.ts";
 import type { Holiday } from "../core/types.ts";
 /**
  * 英国の祝日の種別（既知の値）。
@@ -40,7 +39,5 @@ export declare const SUPPORTED_YEARS: Readonly<{
 export declare const CONFIRMED_THROUGH = 2028;
 /** @internal 反映済みの GOV.UK のデータの年月（2026 年の Scotland の World Cup bank holiday の追加） */
 export declare const DATA_VERSION = "2026-02";
-/** @internal 復活祭の日曜日（グレゴリオ暦。Anonymous Gregorian algorithm） */
-export declare function easterSunday(year: number): DateString;
 /** @internal その年・区分の祝日（日付順） */
 export declare function computeUkHolidays(division: UkDivision, year: number): Holiday<UkHolidayKind>[];

package/dist/uk/rules.js

@@ -10,7 +10,7 @@
  * （test/fixtures/govuk-bank-holidays.json）で検証している。CONFIRMED_THROUGH より後の年は、
  * 規則による予測（confirmed: false）。
  */
-import { addDays, daysInMonth, formatDate, nthWeekdayOfMonth, weekdayOf, } from "../core/date.js";
+import { addDays, daysInMonth, easterSunday, formatDate, nthWeekdayOfMonth, weekdayOf, } from "../core/date.js";
 import { rangeError } from "../core/errors.js";
 /** @internal 対応年 */
 export const SUPPORTED_YEARS = Object.freeze({ from: 2012, to: 2099 });
@@ -62,24 +62,6 @@ const RENAMED = [
     { division: "scotland", date: "2023-01-02", name: NEW_YEAR, kind: "substitute" },
     { division: "scotland", date: "2023-01-03", name: SECOND_JANUARY, kind: "substitute" },
 ];
-/** @internal 復活祭の日曜日（グレゴリオ暦。Anonymous Gregorian algorithm） */
-export function easterSunday(year) {
-    const a = year % 19;
-    const b = Math.floor(year / 100);
-    const c = year % 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 m = Math.floor((a + 11 * h + 22 * l) / 451);
-    const month = Math.floor((h + l - 7 * m + 114) / 31);
-    const day = ((h + l - 7 * m + 114) % 31) + 1;
-    return formatDate(year, month, day);
-}
 function lastMonday(year, month) {
     const last = formatDate(year, month, daysInMonth(year, month));
     return addDays(last, -((weekdayOf(last) - 1 + 7) % 7));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bizdays-toolkit",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "Holidays, business-day calendar and day-by-day schedules (e.g. store hours) with time zone support. Japanese holidays verified against the Cabinet Office data; UK bank holidays (England, Wales, Scotland, Northern Ireland) verified against GOV.UK. / 祝日と営業日のカレンダー（タイムゾーン対応・日本の祝日は内閣府、英国の bank holidays は GOV.UK のデータで全日照合）",
   "keywords": [
     "bank-holidays",
@@ -50,6 +50,10 @@
       "types": "./dist/diagnose/index.d.ts",
       "default": "./dist/diagnose/index.js"
     },
+    "./provider": {
+      "types": "./dist/provider/index.d.ts",
+      "default": "./dist/provider/index.js"
+    },
     "./package.json": "./package.json"
   },
   "scripts": {