bizdays-toolkit 0.18.0 → 0.19.0

package/CHANGELOG.md

@@ -4,6 +4,30 @@
 
 ## [Unreleased]
 
+## [0.19.0] - 2026-10-25
+
+### 移行
+
+動作が変わる既存の API はない（`"after-holiday"` の規則に `skipWeekdays` を付けなければ振替先はこれまでどおり）。繰り返しの規則の形 `{ businessDayOfMonth }` と項目 `skipWeekdays`・`calendar`、診断コード `counting-basis` が増える。版ごとの作業は [docs/migration.md](./docs/migration.md) にまとめた。
+
+### Added
+
+- 繰り返しの規則に月の第 n 営業日の形 `{ businessDayOfMonth: n }` を追加した（型 `BusinessDayOfMonthPattern`・`BusinessDayOfMonth`。n は 1〜31 と -1（最後）〜-31、配列可、`months` で絞れる）。「月末最終営業日は棚卸しで休業」「四半期初の第 1・第 5 営業日は予約を止める」を規則として書ける。数える基準はそのカレンダーの繰り返しの規則をすべて除いた判定（個別の日付・毎年の休業日・祝日・定休日の曜日）で、`nthBusinessDayOfMonth`・`lastBusinessDayOfMonth` は規則を適用した後の実際の営業日を返す。`onHolidayRule` は `"under-holiday"`（既定）と `"over-holiday"`（`holidayPolicy: "open"` で第 n 営業日が祝日に当たるときも適用する）を受け、`"after-holiday"` は `invalid-option`。スケジュールでは数える基準のカレンダーを `calendar` で指定する（必須。タイムゾーンが違えば `time-zone-conflict`。カレンダーの側に書くと `invalid-option`）
+- `"after-holiday"` の曜日・日の規則に `skipWeekdays` を追加した。本来の日が祝日かその曜日なら、以降で最初の「祝日でもその曜日でもない日」に振り替える（「6 月 15 日は創立記念日。土日祝なら翌営業日」は `{ day: 15, months: [6], onHolidayRule: "after-holiday", skipWeekdays: [0, 6] }`、「月曜定休。祝日なら翌平日（土曜日には落とさない）」は `{ weekday: 1, onHolidayRule: "after-holiday", skipWeekdays: [6] }`）。`"after-holiday"` 以外の規則や規則自身の曜日に付けると `invalid-option`
+- 診断コード `counting-basis`（info）を追加した。`businessDayOfMonth` の規則と、同じ設定の毎週の曜日の規則（`{ weekday }`）が同居する設定で、その曜日が営業日として数えられることを知らせる。`businessDayOfMonth` の規則は `never-matches`（その月にない回）・`shadowed`（n・months・基準のカレンダーの包含）・`redundant` の対象。`holidayPolicy: "closed"` の `businessDayOfMonth` の規則の `"over-holiday"` は `redundant`（info）。`skipWeekdays` が違う規則どうしは `shadowed` にしない
+
+### Changed
+
+- `docs/guide.md`・`docs/guide.ja.md`: 繰り返しの規則の表と本文に第 n 営業日と `skipWeekdays` を足し、コード例（銀行の支店とスケジュール）を足した
+- README: 規則の表に `businessDayOfMonth`・`skipWeekdays` を足した
+- `docs/decisions.md`: 47 番（第 n 営業日の規則・`skipWeekdays`・監視の報告書の日付）を追加し、14 番に `skipWeekdays` の追記をした
+
+### 開発
+
+- 監視の照合スクリプト（`scripts/verify-govuk.ts`・`verify-datagovsg.ts`・`verify-cao.ts`）の「確認した日付」を UTC から日本時間に揃えた（issue のコメントの日付と同じ基準）
+- テスト: `test/business-day-of-month.test.ts`・`test/skip-weekdays.test.ts` を追加し、`test/types.check.ts`・利用者の型チェックに新しい規則を足した
+- サイズの上限（`size-limits.json`）を上げた。ルート 25,000 → 26,500（測定 25,100）、`./jp` 28,000 → 29,500（測定 28,128）、`./diagnose` 33,000 → 35,500（測定 34,038）（gzip）。第 n 営業日の規則の判定・基準のキャッシュ・検証と、`skipWeekdays` の振替、診断の追加のため
+
 ## [0.18.0] - 2026-10-25
 
 ### 移行
@@ -494,7 +518,8 @@
 
 - 日本: 2026 年 2 月の官報（2027 年の春分・秋分の日）まで反映（`dataVersion: "2026-02"`、`confirmedThrough: 2027`）
 
-[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.18.0...HEAD
+[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.19.0...HEAD
+[0.19.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.18.0...v0.19.0
 [0.18.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.17.1...v0.18.0
 [0.17.1]: https://github.com/inohan77/bizdays-toolkit/compare/v0.17.0...v0.17.1
 [0.17.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.16.0...v0.17.0

package/README.md

@@ -74,15 +74,17 @@ Each holiday carries its date, name (and English name), `kind` (national, substi
 
 A calendar is built from the holiday provider and your closures: `closedWeekdays`, `closedAnnual` (month-day ranges, across the new year too), `closedDates` and `openDates`, and recurring rules in `closedRecurring` / `openRecurring`:
 
-| Rule                                                      | Meaning                                                                         |
-| --------------------------------------------------------- | ------------------------------------------------------------------------------- |
-| `{ weekday: 3, nth: 3 }`                                  | The 3rd Wednesday (`nth` is 1–5 or -1 for the last; an array for several)       |
-| `{ weekday: 3, interval: 2, anchor: "2026-01-07" }`       | Every other Wednesday, counted from the anchor                                  |
-| `{ day: 20 }`, `{ day: -1 }`                              | The 20th, the last day of the month                                             |
-| `{ holiday: true, kinds: ["substitute"] }`                | Holidays, optionally narrowed by kind or by key (`keys: ["vernal-equinox"]`)    |
-| `{ dayAfterHoliday: true }`, `{ dayBeforeHoliday: true }` | The day after (or before) a holiday or a run of holidays                        |
-| `onHolidayRule: "after-holiday"`                          | "Closed on Mondays, or the next weekday when Monday is a holiday" (museum rule) |
-| `effectiveFrom`, `effectiveTo`                            | The period the rule is in effect                                                |
+| Rule                                                      | Meaning                                                                          |
+| --------------------------------------------------------- | -------------------------------------------------------------------------------- |
+| `{ weekday: 3, nth: 3 }`                                  | The 3rd Wednesday (`nth` is 1–5 or -1 for the last; an array for several)        |
+| `{ weekday: 3, interval: 2, anchor: "2026-01-07" }`       | Every other Wednesday, counted from the anchor                                   |
+| `{ day: 20 }`, `{ day: -1 }`                              | The 20th, the last day of the month                                              |
+| `{ businessDayOfMonth: -1 }`, `{ businessDayOfMonth: 5 }` | The last business day of the month, the 5th business day                         |
+| `{ holiday: true, kinds: ["substitute"] }`                | Holidays, optionally narrowed by kind or by key (`keys: ["vernal-equinox"]`)     |
+| `{ dayAfterHoliday: true }`, `{ dayBeforeHoliday: true }` | The day after (or before) a holiday or a run of holidays                         |
+| `onHolidayRule: "after-holiday"`                          | "Closed on Mondays, or the next weekday when Monday is a holiday" (museum rule)  |
+| `skipWeekdays: [0, 6]`                                    | With `"after-holiday"`: also skip weekends ("June 15, or the next business day") |
+| `effectiveFrom`, `effectiveTo`                            | The period the rule is in effect                                                 |
 
 `dayInfo` tells you why a day is open or closed (`reason`, `name`, `rulePath`). Every bundled holiday that recurs each year has a stable `key` (`vernal-equinox`, `good-friday`, `hari-raya-puasa`, …), so a rule can select individual holidays that no date pattern can express. Details: [Business-day calendars](https://github.com/inohan77/bizdays-toolkit/blob/main/docs/guide.md#business-day-calendars), [Recurring rules](https://github.com/inohan77/bizdays-toolkit/blob/main/docs/guide.md#recurring-rules), [Holiday keys](https://github.com/inohan77/bizdays-toolkit/blob/main/docs/guide.md#holiday-keys), [Common recipes](https://github.com/inohan77/bizdays-toolkit/blob/main/docs/guide.md#common-recipes).
 

package/dist/core/calendar.js

@@ -72,8 +72,8 @@ export function compileCalendarOptions(c, options) {
     const annual = compileAnnualRules(c, "closedAnnual", o["closedAnnual"], () => false, true);
     const open = compileDateRules(c, "openDates", o["openDates"], () => true, true);
     const closed = compileDateRules(c, "closedDates", o["closedDates"], () => false, true);
-    const openRecurring = compileRecurringRules(c, "openRecurring", o["openRecurring"], () => true, RECURRING_RULE_KEYS);
-    const closedRecurring = compileRecurringRules(c, "closedRecurring", o["closedRecurring"], () => false, RECURRING_RULE_KEYS);
+    const openRecurring = compileRecurringRules(c, "openRecurring", o["openRecurring"], () => true, RECURRING_RULE_KEYS, "calendar");
+    const closedRecurring = compileRecurringRules(c, "closedRecurring", o["closedRecurring"], () => false, RECURRING_RULE_KEYS, "calendar");
     return {
         schedule: {
             source,

package/dist/core/diagnose.d.ts

@@ -13,6 +13,8 @@
  *     no-business-day … 営業日が 1 日もない設定（営業日カレンダーのみ）
  * - info    … redundant: 取り除いても結果が変わらない規則・設定（判定に祝日を使わない設定の unconfirmedHolidays: "throw" を含む）
  *             expired: 第 2 引数の asOf より前に終わった規則・日付（asOf を渡したときだけ）
+ *             counting-basis: 第 n 営業日の規則（businessDayOfMonth）の数える基準は繰り返しの規則を除くので、
+ *                             同じ設定の毎週の曜日の規則（{ weekday }）の曜日は営業日として数えられる（relatedPath にその規則）
  *
  * 未確定の祝日の扱い（unconfirmedHolidays）は診断では常に "accept" で評価する。診断は設定の形を調べるもので、
  * 祝日が確定しているかどうかは関係がなく、"throw" のまま評価すると例外を握りつぶして「当てはまらない」と誤判定するため
@@ -51,7 +53,9 @@ export type KnownDiagnosticCode = KnownErrorCode
 /** 取り除いても結果が変わらない */
  | "redundant"
 /** 基準日（asOf）より前に終わった規則・日付（整理の候補） */
- | "expired";
+ | "expired"
+/** 第 n 営業日の規則の数える基準に、同じ設定の曜日の規則が入らない（その曜日を営業日として数える） */
+ | "counting-basis";
 /**
  * 診断コード。将来の版で値が増えることがあるので、分岐では「その他」も扱うこと。
  * @public

package/dist/core/diagnose.js

@@ -13,6 +13,8 @@
  *     no-business-day … 営業日が 1 日もない設定（営業日カレンダーのみ）
  * - info    … redundant: 取り除いても結果が変わらない規則・設定（判定に祝日を使わない設定の unconfirmedHolidays: "throw" を含む）
  *             expired: 第 2 引数の asOf より前に終わった規則・日付（asOf を渡したときだけ）
+ *             counting-basis: 第 n 営業日の規則（businessDayOfMonth）の数える基準は繰り返しの規則を除くので、
+ *                             同じ設定の毎週の曜日の規則（{ weekday }）の曜日は営業日として数えられる（relatedPath にその規則）
  *
  * 未確定の祝日の扱い（unconfirmedHolidays）は診断では常に "accept" で評価する。診断は設定の形を調べるもので、
  * 祝日が確定しているかどうかは関係がなく、"throw" のまま評価すると例外を握りつぶして「当てはまらない」と誤判定するため
@@ -26,7 +28,7 @@
 import { daysInMonth, fromDayNumber, isValidDate, parseDate, toDayNumber, } from "./date.js";
 import { compileCalendarOptions } from "./calendar.js";
 import { IssueCollector, rangeError } from "./errors.js";
-import { compileScheduleOptions, createHolidayLookup, createResolver, inPeriod, matchMonthDay, matchPattern, } from "./schedule.js";
+import { compileScheduleOptions, createBasis, createHolidayLookup, createResolver, inPeriod, matchMonthDay, matchPattern, } from "./schedule.js";
 // ------------------------------------------------------------
 // 知らないキーの候補
 // ------------------------------------------------------------
@@ -311,6 +313,7 @@ function analyze(c, compiled, isCalendar) {
     if (!checkProviderData(c, source))
         return;
     const lookup = createHolidayLookup({ ...source, unconfirmedHolidays: "accept" });
+    const basis = createBasis(compiled, lookup);
     const cycle = patternCycle(recurring);
     const window = scanWindow(source, [...annual, ...recurring], cycle);
     /** 使われないことが分かった規則（redundant を重ねて出さない） */
@@ -381,12 +384,41 @@ function analyze(c, compiled, isCalendar) {
         eachDay(window, (n) => (found = inPeriod(rule, n) && matchPattern(rule, fromDayNumber(n), holidayOfSafe)));
         return found;
     };
+    /** 第 n 営業日の規則が、調べる期間と有効期間の中で 1 日でも当てはまるか（基準は祝日次第で年ごとに違うので、全日を調べる。対応年の外は当てはまらないとみなす） */
+    const businessDayRuleMatches = (rule) => {
+        if (!window)
+            return false;
+        let found = false;
+        eachDay(window, (n) => {
+            if (!inPeriod(rule, n))
+                return false;
+            try {
+                found = matchPattern(rule, fromDayNumber(n), holidayOfSafe, basis);
+            }
+            catch {
+                found = false;
+            }
+            return found;
+        });
+        return found;
+    };
     /** 集合 a（null はすべて）が集合 b（null はすべて）を含むか */
     const setCovers = (a, b) => a === null || (b !== null && [...b].every((v) => a.has(v)));
+    /** 振替で飛ばす曜日が同じか（違えば当てはまる日が違うので覆わない） */
+    const sameSkip = (a, b) => a.skipWeekdays === null
+        ? b.skipWeekdays === null
+        : b.skipWeekdays !== null &&
+            a.skipWeekdays.size === b.skipWeekdays.size &&
+            [...a.skipWeekdays].every((w) => b.skipWeekdays.has(w));
     recurring.forEach((rule, j) => {
         const bits = recurringBits[j];
         const holidayBased = rule.holiday || rule.dayAfterHoliday || rule.dayBeforeHoliday;
-        const matches = holidayBased ? holidayRuleMatches(rule) : matchesAnyDay(rule, cycle);
+        const businessDayBased = rule.businessDays !== null;
+        const matches = holidayBased
+            ? holidayRuleMatches(rule)
+            : businessDayBased
+                ? businessDayRuleMatches(rule)
+                : matchesAnyDay(rule, cycle);
         if (!matches) {
             unused.add(rule);
             c.warning("never-matches", rule.path, holidayBased
@@ -397,15 +429,35 @@ function analyze(c, compiled, isCalendar) {
                         : 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");
+                : businessDayBased
+                    ? "This rule matches no day: no month has that many business days of the counting basis in the selected 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;
         }
+        // 第 n 営業日の規則の "over-holiday" は、祝日が基準の営業日にならない設定（holidayPolicy: "closed"）では結果を変えない
+        if (businessDayBased &&
+            rule.basis === null &&
+            rule.onHolidayRule === "over-holiday" &&
+            typeof compiled.holiday === "object" &&
+            "value" in compiled.holiday &&
+            compiled.holiday.value === false) {
+            c.info("redundant", `${rule.path}.onHolidayRule`, 'This option does not change the result: holidays are closed (holidayPolicy: "closed"), so an nth business day is never a holiday');
+        }
+        // 第 n 営業日の規則の数える基準は繰り返しの規則を除くので、同じ設定の毎週の曜日の規則があれば知らせる（定休日を曜日の規則で書いた設定）
+        if (businessDayBased && rule.basis === null) {
+            const weekly = recurring.find((r) => r.weekday !== null && r.nth === null && r.interval === null && r.months === null);
+            if (weekly) {
+                c.info("counting-basis", rule.path, `The business days are counted without recurring rules, so the weekday rule ${weekly.path} does not reduce the count; ` +
+                    "write regular closed weekdays as closedWeekdays if they should not be counted", weekly.path);
+            }
+        }
         // 祝日・祝日の翌日・祝前日の規則は祝日次第で年ごとに変わるので、形の包含は同じ形の規則どうし（種別・識別子・曜日・月の絞り込み）だけで調べる
         const k = recurring.findIndex((r, i) => i < j &&
             canCover(r, rule) &&
             periodCovers(r, rule) &&
+            sameSkip(r, rule) &&
             (rule.holiday
                 ? r.holiday &&
                     setCovers(r.kinds, rule.kinds) &&
@@ -417,11 +469,17 @@ function analyze(c, compiled, isCalendar) {
                         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])));
+                    : rule.businessDays !== null
+                        ? r.businessDays !== null &&
+                            r.calendar === rule.calendar &&
+                            setCovers(r.businessDays, rule.businessDays) &&
+                            setCovers(r.months, rule.months)
+                        : !r.holiday &&
+                            !r.dayAfterHoliday &&
+                            !r.dayBeforeHoliday &&
+                            r.businessDays === null &&
+                            intervalCovers(r, rule) &&
+                            isSubset(bits, recurringBits[i])));
         if (k < 0)
             return;
         unused.add(rule);

package/dist/core/schedule.d.ts

@@ -23,6 +23,7 @@ import { IssueCollector } from "./errors.ts";
 import { type CivilDateTimeParts, type DateInput, type DateTimeInput } from "./input.ts";
 export type { CivilDateTimeParts } from "./input.ts";
 import { type Holiday, type HolidayProvider } from "./types.ts";
+import type { Calendar } from "./calendar.ts";
 /**
  * 祝日の値の決め方（スケジュールの holiday の設定）。
  * @public
@@ -48,6 +49,11 @@ export type Nth = 1 | 2 | 3 | 4 | 5 | -1;
  * @public
  */
 export type DayOfMonth = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | -1;
+/**
+ * 月の第 n 営業日（1〜31。-1 は最後、-2 はその前、… -31 まで。0 は不可）。
+ * @public
+ */
+export type BusinessDayOfMonth = number;
 /**
  * 月（1〜12）。
  * @public
@@ -89,7 +95,16 @@ export interface WeekdayPattern {
     readonly anchor?: DateString;
     /** 当てはめる月（省略時はすべての月） */
     readonly months?: readonly Month[];
+    /**
+     * onHolidayRule: "after-holiday" と組で、祝日に加えて飛ばす曜日（0 = 日曜日〜6 = 土曜日）。
+     * 本来の日が祝日かこの曜日なら、その日以降で最初の、祝日でもこの曜日でもない日に振り替える
+     * （例: 月曜定休で、月曜が祝日なら翌平日（土曜日には落とさない）は { weekday: 1, onHolidayRule: "after-holiday", skipWeekdays: [6] }）。
+     * weekday 自身は含められない。"after-holiday" 以外と組にすると invalid-option
+     */
+    readonly skipWeekdays?: readonly Weekday[];
     readonly day?: never;
+    readonly businessDayOfMonth?: never;
+    readonly calendar?: never;
     readonly dayAfterHoliday?: never;
     readonly dayBeforeHoliday?: never;
     readonly holiday?: never;
@@ -106,16 +121,61 @@ export interface DayOfMonthPattern {
     readonly day: DayOfMonth | readonly DayOfMonth[];
     /** 当てはめる月（省略時はすべての月） */
     readonly months?: readonly Month[];
+    /**
+     * onHolidayRule: "after-holiday" と組で、祝日に加えて飛ばす曜日。本来の日が祝日かこの曜日なら、その日以降で最初の、
+     * 祝日でもこの曜日でもない日に振り替える（例: 「6 月 15 日は創立記念日。土日祝なら翌営業日」は
+     * { day: 15, months: [6], onHolidayRule: "after-holiday", skipWeekdays: [0, 6] }）。"after-holiday" 以外と組にすると invalid-option
+     */
+    readonly skipWeekdays?: readonly Weekday[];
+    readonly weekday?: never;
+    readonly nth?: never;
+    readonly interval?: never;
+    readonly anchor?: never;
+    readonly businessDayOfMonth?: never;
+    readonly calendar?: never;
+    readonly dayAfterHoliday?: never;
+    readonly dayBeforeHoliday?: never;
+    readonly holiday?: never;
+    readonly weekdays?: never;
+    readonly kinds?: never;
+    readonly keys?: never;
+}
+/**
+ * 月の第 n 営業日（例: 月末最終営業日、第 5 営業日）。n は 1〜31、-1 は最後、-2 はその前。その月にない回は当てはまらない。
+ *
+ * 数える基準はこの規則を書いたカレンダーの「繰り返しの規則をすべて除いた判定」（個別の日付 → 毎年の月日 → 祝日 → 定休日の曜日）で、
+ * 定休日の曜日・祝日・年末年始休業（closedAnnual）・臨時休業日は数えに入らない。繰り返しの規則（定休日を closedRecurring の
+ * 曜日の規則で書いたものを含む）は基準に入らない。nthBusinessDayOfMonth・lastBusinessDayOfMonth はこの規則を適用した後の
+ * 実際の営業日を返すので、{ businessDayOfMonth: -1 } を休業にすると lastBusinessDayOfMonth はその前日になる。
+ * onHolidayRule は "under-holiday"（既定）と "over-holiday" を受け、"after-holiday" は invalid-option（第 n 営業日をずらす意味がない）。
+ * holidayPolicy: "open" のカレンダーでは祝日も営業日として数えるので第 n 営業日が祝日に当たることがあり、既定ではその日は
+ * 祝日の段階が先に決めてこの規則は当てはまらない（曜日の規則と同じ優先順位）。「第 1 営業日は祝日でも休業」は "over-holiday" で書く。
+ * holidayPolicy: "closed" では祝日が基準の営業日にならないので "over-holiday" は結果を変えない（診断が info で知らせる）。
+ *
+ * スケジュール（createSchedule の recurring）では、スケジュール自身に営業・休業の概念がないので、数える基準にする作成済みの
+ * カレンダーを calendar で指定する（必須。タイムゾーンはスケジュールと同じであること）。カレンダー（closedRecurring・openRecurring）
+ * では calendar は指定できない（invalid-option。基準は自分の設定で決まる）。
+ * @public
+ */
+export interface BusinessDayOfMonthPattern {
+    /** 月の第 n 営業日（1〜31、-1 は最後、-2 はその前、… -31 まで）。配列で複数指定できる */
+    readonly businessDayOfMonth: BusinessDayOfMonth | readonly BusinessDayOfMonth[];
+    /** 当てはめる月（省略時はすべての月） */
+    readonly months?: readonly Month[];
+    /** 営業日を数える基準のカレンダー（スケジュールでは必須。カレンダーでは指定できない） */
+    readonly calendar?: Calendar;
     readonly weekday?: never;
     readonly nth?: never;
     readonly interval?: never;
     readonly anchor?: never;
+    readonly day?: never;
     readonly dayAfterHoliday?: never;
     readonly dayBeforeHoliday?: never;
     readonly holiday?: never;
     readonly weekdays?: never;
     readonly kinds?: never;
     readonly keys?: never;
+    readonly skipWeekdays?: never;
 }
 /**
  * 祝日の翌日（祝日が続く場合は連休が明けた日。その日自身は祝日でない）。「祝日」は提供元の祝日だけ。
@@ -133,10 +193,13 @@ export interface DayAfterHolidayPattern {
     readonly interval?: never;
     readonly anchor?: never;
     readonly day?: never;
+    readonly businessDayOfMonth?: never;
+    readonly calendar?: never;
     readonly dayBeforeHoliday?: never;
     readonly holiday?: never;
     readonly kinds?: never;
     readonly keys?: never;
+    readonly skipWeekdays?: never;
 }
 /**
  * 祝前日（翌日が祝日で、その日自身は祝日でない日。連休なら連休の初日の前日）。「祝日」は提供元の祝日だけ。
@@ -155,10 +218,13 @@ export interface DayBeforeHolidayPattern {
     readonly interval?: never;
     readonly anchor?: never;
     readonly day?: never;
+    readonly businessDayOfMonth?: never;
+    readonly calendar?: never;
     readonly dayAfterHoliday?: never;
     readonly holiday?: never;
     readonly kinds?: never;
     readonly keys?: never;
+    readonly skipWeekdays?: never;
 }
 /**
  * 祝日（提供元の祝日である日）。kinds で祝日の種別を、keys で個別の祝日を絞れる（省略時はすべての祝日）。
@@ -188,14 +254,17 @@ export interface HolidayPattern<Kind extends string = string> {
     readonly interval?: never;
     readonly anchor?: never;
     readonly day?: never;
+    readonly businessDayOfMonth?: never;
+    readonly calendar?: never;
     readonly dayAfterHoliday?: never;
     readonly dayBeforeHoliday?: never;
+    readonly skipWeekdays?: never;
 }
 /**
  * 繰り返しのパターン。
  * @public
  */
-export type RecurringPattern<Kind extends string = string> = WeekdayPattern | DayOfMonthPattern | DayAfterHolidayPattern | DayBeforeHolidayPattern | HolidayPattern<Kind>;
+export type RecurringPattern<Kind extends string = string> = WeekdayPattern | DayOfMonthPattern | BusinessDayOfMonthPattern | DayAfterHolidayPattern | DayBeforeHolidayPattern | HolidayPattern<Kind>;
 /**
  * 繰り返しの規則（営業日カレンダーの closedRecurring・openRecurring）。
  * @public
@@ -421,6 +490,14 @@ export interface RecurringRuleCompiled<T> extends CompiledPeriod {
     readonly anchor: number | null;
     /** 日の集合（曜日の規則では null） */
     readonly days: ReadonlySet<number> | null;
+    /** 第 n 営業日の集合（第 n 営業日の規則以外では null） */
+    readonly businessDays: ReadonlySet<number> | null;
+    /** 営業日を数える基準（スケジュールの第 n 営業日の規則の calendar から。null なら自分の設定の「繰り返しの規則を除いた判定」） */
+    readonly basis: BasisOfMonth | null;
+    /** basis の元のカレンダー（診断で同じ基準かを比べるため。basis が null なら null） */
+    readonly calendar: Calendar | null;
+    /** "after-holiday" の振替で、祝日に加えて飛ばす曜日（null はなし） */
+    readonly skipWeekdays: ReadonlySet<number> | null;
     /** 祝日の翌日の規則か */
     readonly dayAfterHoliday: boolean;
     /** 祝前日の規則か */
@@ -439,18 +516,31 @@ export interface RecurringRuleCompiled<T> extends CompiledPeriod {
     readonly value: T;
     readonly name: string | undefined;
 }
+/**
+ * @internal 営業日を数える基準。年と月を受け取り、その月の基準で営業日である日（1〜31）を日付順に返す。
+ * 第 n 営業日の規則（businessDayOfMonth）の判定に使う
+ */
+export type BasisOfMonth = (year: number, month: number) => readonly number[];
+/** @internal カレンダーの判定関数から、月ごとに結果をキャッシュする基準を作る */
+export declare function basisFromPredicate(isOpen: (date: DateString) => boolean): BasisOfMonth;
 /** @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>[];
+export declare function compileRecurringRules<T>(c: IssueCollector, path: string, entries: unknown, valueOf: (entry: Record<string, unknown>, path: string) => T | undefined, keys: readonly string[], context: "calendar" | "schedule"): RecurringRuleCompiled<T>[];
 /** @internal その日の祝日を返す関数（祝日・祝日の翌日・祝前日の規則の判定に使う。提供元の対応年の外は祝日でないとみなすこと） */
 export type HolidayOf = (date: DateString) => Holiday<string> | undefined;
 /**
- * @internal 繰り返しの規則の形（曜日・第 n 回目・周期・日・祝日・祝日の翌日・祝前日・月）がその日に当てはまるか。
+ * @internal 繰り返しの規則の形（曜日・第 n 回目・周期・日・第 n 営業日・祝日・祝日の翌日・祝前日・月）がその日に当てはまるか。
  * 有効期間は考えない（規則の診断で、形どうしの包含を調べるために分けている）。
- * 祝日に従属する規則は holidayOf で判定し、holidayOf を渡さなければ当てはまらない
+ * 祝日に従属する規則は holidayOf で判定し、holidayOf を渡さなければ当てはまらない。
+ * 第 n 営業日の規則は、規則自身の基準（スケジュールの calendar）か basis で数え、どちらもなければ当てはまらない
  */
-export declare function matchPattern(rule: RecurringRuleCompiled<unknown>, date: DateString, holidayOf?: HolidayOf): boolean;
+export declare function matchPattern(rule: RecurringRuleCompiled<unknown>, date: DateString, holidayOf?: HolidayOf, basis?: BasisOfMonth): boolean;
 /** @internal 繰り返しの規則がその日に当てはまるか（有効期間を含む） */
-export declare function matchRecurring(rule: RecurringRuleCompiled<unknown>, date: DateString, holidayOf: HolidayOf): boolean;
+export declare function matchRecurring(rule: RecurringRuleCompiled<unknown>, date: DateString, holidayOf: HolidayOf, basis?: BasisOfMonth): boolean;
+/**
+ * @internal 第 n 営業日の規則が自分の設定を基準にする場合の基準を作る（繰り返しの規則をすべて除いた判定で営業日か）。
+ * 基準が要らない設定（第 n 営業日の規則がない、またはすべて calendar を持つ）では undefined
+ */
+export declare function createBasis<T, Kind extends string>(compiled: CompiledSchedule<T, Kind>, lookup: HolidayLookupInternal<Kind>): BasisOfMonth | undefined;
 /** @internal 祝日の提供元とタイムゾーンの設定を検証した結果 */
 export interface HolidaySource<Kind extends string> {
     readonly providers: readonly HolidayProvider<Kind>[];

package/dist/core/schedule.js

@@ -18,7 +18,7 @@
  *
  * 営業日カレンダー（createCalendar）は、このスケジュールの真偽値版として作られている。
  */
-import { addDays, daysInMonth, fromDayNumber, isValidDate, parseDate, toDayNumber, weekdayOf, } from "./date.js";
+import { addDays, daysInMonth, formatDate, fromDayNumber, isValidDate, parseDate, toDayNumber, weekdayOf, } from "./date.js";
 import { checkUnknownKeys, IssueCollector, rangeError } from "./errors.js";
 import { instantToCivil, toCivil, toDateTimeParts, toInstant, validateTimeZone, } from "./input.js";
 import { HOLIDAY_KEY_PATTERN } from "./types.js";
@@ -176,6 +176,29 @@ export function compileAnnualRules(c, path, entries, valueOf, allowString) {
     return rules;
 }
 const NTH_VALUES = [1, 2, 3, 4, 5, -1];
+const isBusinessDayOfMonth = (v) => Number.isInteger(v) && v !== 0 && v >= -31 && v <= 31;
+/** @internal カレンダーの判定関数から、月ごとに結果をキャッシュする基準を作る */
+export function basisFromPredicate(isOpen) {
+    const cache = new Map();
+    return (year, month) => {
+        const key = year * 12 + month;
+        let days = cache.get(key);
+        if (days === undefined) {
+            const list = [];
+            const dim = daysInMonth(year, month);
+            for (let d = 1; d <= dim; d++)
+                if (isOpen(formatDate(year, month, d)))
+                    list.push(d);
+            days = Object.freeze(list);
+            if (cache.size >= 240)
+                cache.clear();
+            cache.set(key, days);
+        }
+        return days;
+    };
+}
+/** 作成済みのカレンダーか（createCalendar の結果の形。isBusinessDay と timeZone を持つ） */
+const isCalendarLike = (v) => isObject(v) && typeof v["isBusinessDay"] === "function" && typeof v["timeZone"] === "string";
 const ON_HOLIDAY_RULES = [
     "under-holiday",
     "over-holiday",
@@ -193,7 +216,7 @@ function checkSet(c, path, raw, valid, expected) {
     return new Set(list);
 }
 /** @internal 繰り返しの規則を検証して取り込む */
-export function compileRecurringRules(c, path, entries, valueOf, keys) {
+export function compileRecurringRules(c, path, entries, valueOf, keys, context) {
     if (entries === undefined)
         return [];
     if (!Array.isArray(entries)) {
@@ -215,13 +238,15 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
         const hasAfter = "dayAfterHoliday" in entry;
         const hasBefore = "dayBeforeHoliday" in entry;
         const hasHoliday = "holiday" in entry;
+        const hasBusinessDay = "businessDayOfMonth" in entry;
         if (Number(hasWeekday) +
             Number(hasDay) +
+            Number(hasBusinessDay) +
             Number(hasAfter) +
             Number(hasBefore) +
             Number(hasHoliday) !==
             1) {
-            c.error("invalid-option", p, 'must have exactly one of "weekday", "day", "dayAfterHoliday", "dayBeforeHoliday" or "holiday"');
+            c.error("invalid-option", p, 'must have exactly one of "weekday", "day", "businessDayOfMonth", "dayAfterHoliday", "dayBeforeHoliday" or "holiday"');
             return;
         }
         let kinds = null;
@@ -229,6 +254,9 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
         let weekday = null;
         let nth = null;
         let days = null;
+        let businessDays = null;
+        let basis = null;
+        let basisCalendar = null;
         let interval = null;
         let anchor = null;
         const hasInterval = "interval" in entry;
@@ -288,6 +316,32 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
                 else
                     ok = false;
             }
+            else if (hasBusinessDay) {
+                const set = checkSet(c, `${p}.businessDayOfMonth`, entry["businessDayOfMonth"], isBusinessDayOfMonth, "1-31 or -1 (last business day) to -31");
+                if (set)
+                    businessDays = set;
+                else
+                    ok = false;
+                if (entry["onHolidayRule"] === "after-holiday") {
+                    c.error("invalid-option", `${p}.onHolidayRule`, '"after-holiday" cannot be used with "businessDayOfMonth" (shifting the nth business day has no meaning; use "under-holiday" or "over-holiday")');
+                    ok = false;
+                }
+                if (context === "calendar") {
+                    if ("calendar" in entry) {
+                        c.error("invalid-option", `${p}.calendar`, '"calendar" cannot be used in a calendar (the counting basis is the calendar\'s own options without recurring rules)');
+                        ok = false;
+                    }
+                }
+                else if (!isCalendarLike(entry["calendar"])) {
+                    c.error("invalid-option", `${p}.calendar`, "must be a calendar made with createCalendar (the basis for counting business days; required in a schedule)");
+                    ok = false;
+                }
+                else {
+                    const calendar = entry["calendar"];
+                    basisCalendar = calendar;
+                    basis = basisFromPredicate((date) => calendar.isBusinessDay(date));
+                }
+            }
             else {
                 const key = hasAfter ? "dayAfterHoliday" : hasBefore ? "dayBeforeHoliday" : "holiday";
                 if (entry[key] !== true) {
@@ -315,6 +369,10 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
                 }
             }
         }
+        if (!hasBusinessDay && "calendar" in entry) {
+            c.error("invalid-option", `${p}.calendar`, '"calendar" can be used only with "businessDayOfMonth"');
+            ok = false;
+        }
         if (!hasHoliday && "kinds" in entry) {
             c.error("invalid-option", `${p}.kinds`, '"kinds" can be used only with "holiday"');
             ok = false;
@@ -375,6 +433,28 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
             c.error("invalid-option", `${p}.onHolidayRule`, `must be one of ${ON_HOLIDAY_RULES.map((v) => `"${v}"`).join(", ")}`);
             ok = false;
         }
+        let skipWeekdays = null;
+        if ("skipWeekdays" in entry) {
+            if (entry["onHolidayRule"] !== "after-holiday" || !(hasWeekday || hasDay)) {
+                c.error("invalid-option", `${p}.skipWeekdays`, '"skipWeekdays" can be used only with onHolidayRule: "after-holiday" on a "weekday" or "day" rule');
+                ok = false;
+            }
+            else if (!Array.isArray(entry["skipWeekdays"])) {
+                c.error("invalid-option", `${p}.skipWeekdays`, "must be a non-empty array of weekdays (0 = Sunday to 6 = Saturday)");
+                ok = false;
+            }
+            else {
+                const set = checkSet(c, `${p}.skipWeekdays`, entry["skipWeekdays"], isWeekday, "a weekday (0 = Sunday to 6 = Saturday)");
+                if (set === undefined)
+                    ok = false;
+                else if (weekday !== null && set.has(weekday)) {
+                    c.error("invalid-option", `${p}.skipWeekdays`, `cannot include the rule's own weekday ${weekday} (the rule would be shifted every time)`);
+                    ok = false;
+                }
+                else
+                    skipWeekdays = set;
+            }
+        }
         const period = checkPeriod(c, p, entry);
         if (ok && period && value !== undefined) {
             rules.push(Object.freeze({
@@ -384,6 +464,10 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
                 interval,
                 anchor,
                 days,
+                businessDays,
+                basis,
+                calendar: basisCalendar,
+                skipWeekdays,
                 dayAfterHoliday: hasAfter,
                 dayBeforeHoliday: hasBefore,
                 holiday: hasHoliday,
@@ -401,14 +485,26 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
     return rules;
 }
 /**
- * @internal 繰り返しの規則の形（曜日・第 n 回目・周期・日・祝日・祝日の翌日・祝前日・月）がその日に当てはまるか。
+ * @internal 繰り返しの規則の形（曜日・第 n 回目・周期・日・第 n 営業日・祝日・祝日の翌日・祝前日・月）がその日に当てはまるか。
  * 有効期間は考えない（規則の診断で、形どうしの包含を調べるために分けている）。
- * 祝日に従属する規則は holidayOf で判定し、holidayOf を渡さなければ当てはまらない
+ * 祝日に従属する規則は holidayOf で判定し、holidayOf を渡さなければ当てはまらない。
+ * 第 n 営業日の規則は、規則自身の基準（スケジュールの calendar）か basis で数え、どちらもなければ当てはまらない
  */
-export function matchPattern(rule, date, holidayOf) {
+export function matchPattern(rule, date, holidayOf, basis) {
     const { year, month, day } = parseDate(date);
     if (rule.months && !rule.months.has(month))
         return false;
+    if (rule.businessDays) {
+        // 第 n 営業日: 規則自身の基準（スケジュールの calendar）か、呼び出し側の基準（カレンダーの「繰り返しの規則を除いた判定」）で数える
+        const b = rule.basis ?? basis;
+        if (b === undefined)
+            return false;
+        const days = b(year, month);
+        const index = days.indexOf(day);
+        if (index < 0)
+            return false;
+        return rule.businessDays.has(index + 1) || rule.businessDays.has(index - days.length);
+    }
     if (rule.holiday || rule.dayAfterHoliday || rule.dayBeforeHoliday) {
         if (holidayOf === undefined)
             return false;
@@ -438,8 +534,18 @@ export function matchPattern(rule, date, holidayOf) {
     return rule.days.has(day) || (rule.days.has(-1) && day === dim);
 }
 /** @internal 繰り返しの規則がその日に当てはまるか（有効期間を含む） */
-export function matchRecurring(rule, date, holidayOf) {
-    return inPeriod(rule, toDayNumber(date)) && matchPattern(rule, date, holidayOf);
+export function matchRecurring(rule, date, holidayOf, basis) {
+    return inPeriod(rule, toDayNumber(date)) && matchPattern(rule, date, holidayOf, basis);
+}
+/**
+ * @internal 第 n 営業日の規則が自分の設定を基準にする場合の基準を作る（繰り返しの規則をすべて除いた判定で営業日か）。
+ * 基準が要らない設定（第 n 営業日の規則がない、またはすべて calendar を持つ）では undefined
+ */
+export function createBasis(compiled, lookup) {
+    if (!compiled.recurring.some((r) => r.businessDays !== null && r.basis === null))
+        return undefined;
+    const resolve = createResolver({ ...compiled, recurring: [] }, lookup);
+    return basisFromPredicate((date) => resolve(date).day.value === true);
 }
 /** 規則の value を取り出す（value が必須の規則用） */
 function requiredValue(c) {
@@ -705,6 +811,9 @@ export const RECURRING_RULE_KEYS = [
     "keys",
     "weekdays",
     "months",
+    "businessDayOfMonth",
+    "calendar",
+    "skipWeekdays",
     "name",
     "onHolidayRule",
     ...PERIOD_KEYS,
@@ -744,7 +853,17 @@ export function compileScheduleOptions(c, options) {
     }
     const annual = compileAnnualRules(c, "annual", options["annual"], requiredValue(c), false);
     const dates = compileDateRules(c, "dates", options["dates"], requiredValue(c), false);
-    const recurring = compileRecurringRules(c, "recurring", options["recurring"], requiredValue(c), [...RECURRING_RULE_KEYS, "value"]);
+    const recurring = compileRecurringRules(c, "recurring", options["recurring"], requiredValue(c), [...RECURRING_RULE_KEYS, "value"], "schedule");
+    // 第 n 営業日の規則の基準のカレンダーは、スケジュールと同じタイムゾーンであること（合成と同じ理由。瞬間の暦日が食い違うため）
+    for (const rule of recurring) {
+        if (rule.businessDays === null)
+            continue;
+        const entry = options["recurring"][Number(/\[(\d+)\]$/.exec(rule.path)[1])];
+        const tz = entry["calendar"].timeZone;
+        if (tz !== source.timeZone) {
+            c.error("time-zone-conflict", `${rule.path}.calendar`, `the calendar's time zone ${tz} differs from the schedule's ${source.timeZone}`);
+        }
+    }
     return { source, weekly, holiday, annual, dates, recurring };
 }
 /** 振替元をさかのぼる最大日数（祝日が続く日数の上限。2019 年の大型連休でも 10 日） */
@@ -766,6 +885,7 @@ export function matchAnnual(rule, date) {
 export function createResolver(compiled, lookup) {
     const { weekly, holiday: holidayRule, annual, dates, recurring } = compiled;
     const hasShift = recurring.some((r) => r.onHolidayRule === "after-holiday");
+    const basis = createBasis(compiled, lookup);
     /** 振替・祝日の規則の判断に使う祝日。提供元の対応年の外は祝日でないとみなす（振替元をさかのぼる途中で範囲を出る場合のため） */
     function holidayOfSafe(date) {
         try {
@@ -786,7 +906,8 @@ export function createResolver(compiled, lookup) {
     function shiftedOrigin(rule, date) {
         for (let k = 1; k <= MAX_HOLIDAY_RUN; k++) {
             const prev = addDays(date, -k);
-            if (!isHolidaySafe(prev))
+            // 飛ばす日は祝日と、skipWeekdays の曜日。それ以外の日に達したら、振替元はない
+            if (!isHolidaySafe(prev) && !rule.skipWeekdays?.has(weekdayOf(prev)))
                 return undefined;
             if (matchRecurring(rule, prev, holidayOfSafe))
                 return prev;
@@ -823,7 +944,7 @@ export function createResolver(compiled, lookup) {
             return make(byAnnual.value, "annual", byAnnual, byAnnual.name);
         if (holiday) {
             // 3. 祝日の上（"over-holiday"。祝日の規則 { holiday: true } もここ）
-            const over = recurring.find((r) => r.onHolidayRule === "over-holiday" && matchRecurring(r, date, holidayOfSafe));
+            const over = recurring.find((r) => r.onHolidayRule === "over-holiday" && matchRecurring(r, date, holidayOfSafe, basis));
             if (over)
                 return make(over.value, "recurring", over, over.name);
             // 4. 祝日
@@ -833,14 +954,17 @@ export function createResolver(compiled, lookup) {
             }
             // 祝日の扱いが「曜日どおり」なら、祝日の下（"under-holiday"）の規則も当てはまる。
             // "after-holiday" の規則は祝日には当てはめない（振り替える）
-            const under = recurring.find((r) => r.onHolidayRule === "under-holiday" && matchRecurring(r, date, holidayOfSafe));
+            const under = recurring.find((r) => r.onHolidayRule === "under-holiday" && matchRecurring(r, date, holidayOfSafe, basis));
             if (under)
                 return make(under.value, "recurring", under, under.name);
             return make(weekly[weekday], "weekday", null, undefined);
         }
         // 5. 繰り返しの規則（祝日でない日。配列で先に書いたものが優先）。振替先も同じ段階で判定する
         for (const rule of recurring) {
-            if (matchRecurring(rule, date, holidayOfSafe))
+            // skipWeekdays の曜日には当てはめない（祝日と同じく振り替える）
+            if (rule.skipWeekdays?.has(weekday))
+                continue;
+            if (matchRecurring(rule, date, holidayOfSafe, basis))
                 return make(rule.value, "recurring", rule, rule.name);
             if (hasShift && rule.onHolidayRule === "after-holiday") {
                 const origin = shiftedOrigin(rule, date);

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 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 { createSchedule, type AnnualRangeValue, type AnnualValue, type BusinessDayOfMonth, type BusinessDayOfMonthPattern, 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bizdays-toolkit",
-  "version": "0.18.0",
+  "version": "0.19.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; Singapore public holidays verified against data.gov.sg. / 祝日と営業日のカレンダー（タイムゾーン対応・日本の祝日は内閣府、英国の bank holidays は GOV.UK、シンガポールの祝日は data.gov.sg のデータで全日照合）",
   "keywords": [
     "bank-holidays",