bizdays-toolkit 0.16.0 → 0.17.0

package/CHANGELOG.md

@@ -4,6 +4,33 @@
 
 ## [Unreleased]
 
+## [0.17.0] - 2026-10-25
+
+### 移行
+
+動作が変わる既存の API はない（既定値はこれまでどおり）。`Calendar`・`Schedule`・`HolidayLookup` に項目 `unconfirmedHolidays` が加わり、`createCalendar`・`createSchedule` の設定と `diagnoseCalendar`・`diagnoseSchedule` の第 2 引数が増える。監視のワークフローの改名（`govuk-watch.yml` → `data-watch.yml`）により、cron-job.org の URL を直す（RELEASING.md）。版ごとの作業は [docs/migration.md](./docs/migration.md) にまとめた。
+
+### Added
+
+- 未確定の祝日のガード `unconfirmedHolidays: "accept" | "throw"`（カレンダー・スケジュール共通。既定 `"accept"`）を追加した。`"throw"` では、評価した日（探索が途中で通る日、祝日の翌日・祝前日の規則が見る隣の日を含む）が未確定の祝日（`confirmed: false`）なら `code: "unconfirmed-holiday"` の `RangeError` を投げる。`holidaysInYear`・`holidaysBetween` は投げないので、影響する日を列挙できる。合成はどれかが `"throw"` なら `"throw"`。エラーコードに `unconfirmed-holiday` を追加した
+- 診断の第 2 引数 `{ asOf: "YYYY-MM-DD" }`（型 `DiagnoseOptions`）を追加した。基準日より前に終わった規則・個別の日付を `info` の `expired` で返す。省略時の結果は変わらない。診断コードに `expired` を追加した
+- シンガポールの祝日 `bizdays-toolkit/sg`（提供元 `sg`。ID `SG`、`Asia/Singapore`、種別 `regular`・`substitute`・`special`、型 `SgHoliday`・`SgHolidayKind`・`KnownSgHolidayKind`）を追加した。MOM が告示した 2020〜2027 年の日付を表で持ち、日曜日に当たった祝日の振替を Holidays Act の規則で計算する。それより後の年は予測せず `out-of-range`。data.gov.sg のコレクション 691（MOM）で全日照合し、2022 年の既知の差分（改定後の告示との食い違い）はフィクスチャに出典付きで記録した
+
+### Changed
+
+- 診断: 判定に祝日を使わない設定（提供元がない、または `holidayPolicy: "ignore"` / `holiday: "weekday"` で祝日に従属する規則もない）の `unconfirmedHolidays: "throw"` を `info` の `redundant` にする。診断は未確定の祝日を `"accept"` で評価する
+- 診断: 第 2 引数がオブジェクトでなければ `invalid-argument`、`asOf` が暦日の文字列でなければ `invalid-date` の例外を投げる（設定の誤りは診断結果で返す現状のまま）
+- 振替元をさかのぼるときに祝日の例外を飲み込む範囲を `out-of-range` だけにした（`unconfirmed-holiday` などは投げ直す。これまでは提供元の例外も飲み込んでいた）
+- README: シンガポールの節、「未確定の祝日」の節（レシピ付き）、診断の `asOf` と `expired`、出典にシンガポールと Singapore Open Data Licence を足した。サイズの値を測り直した（ルート約 10.0KB・日本の祝日込み約 11.8KB・英国の祝日込み約 11.7KB・シンガポールの祝日込み約 10.9KB。0.17.0 で測定）
+- `RELEASING.md`: 「シンガポールのデータの更新」の節を足し、監視のワークフローの改名と cron-job.org の URL の修正を書いた
+- `docs/decisions.md`: 44 番（未確定の祝日のガード・診断の基準日・シンガポールの祝日）を追加し、15・28 番に監視のワークフローの改名を書いた
+
+### 開発
+
+- 監視のワークフローを `govuk-watch.yml` から `data-watch.yml` に改名し、英国とシンガポールの照合を 1 回の起動で順に行う（issue のラベルは `govuk-data`・`datagovsg-data`。ハートビートは両方が動いたときだけ）。`scripts/verify-datagovsg.ts`（`pnpm verify:datagovsg`。`--file`・`--write`・`--report`・`--simulate`）とフィクスチャ `test/fixtures/datagovsg-public-holidays.json`（既知の差分を含む）を追加した
+- テスト: `test/unconfirmed-holidays.test.ts`・`test/diagnose-as-of.test.ts`・`test/sg-rules.test.ts`・`test/sg-datagovsg.test.ts` を追加し、`smoke.mjs`・CJS・利用者の型チェックにシンガポールと新しい設定を足した
+- サイズの上限（`size-limits.json`）を上げ、`./sg` のエントリーを足した。ルート 24,000 → 25,000、`./jp` 27,000 → 28,000、`./uk` 6,700 → 7,500、`./diagnose` 30,500 → 32,000（gzip）。未確定の祝日のガードと診断の基準日のため。`./sg` は 6,000（日付とエラーの共通の実装を含む）
+
 ## [0.16.0] - 2026-10-23
 
 ### 移行
@@ -431,7 +458,8 @@
 
 - 日本: 2026 年 2 月の官報（2027 年の春分・秋分の日）まで反映（`dataVersion: "2026-02"`、`confirmedThrough: 2027`）
 
-[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.16.0...HEAD
+[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.17.0...HEAD
+[0.17.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.16.0...v0.17.0
 [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

package/README.md

@@ -21,6 +21,7 @@ A business-day calendar that combines public holidays with company or store clos
 
 - **Japanese holidays verified day by day against the Cabinet Office data**: from 1955 through the latest year announced in the Official Gazette, every date in the Cabinet Office "National Holidays" CSV is checked in the tests (substitute holidays, citizens' holidays, holidays for imperial ceremonies and the Olympic moves included)
 - **UK bank holidays verified day by day against GOV.UK**: choose England, Wales, Scotland or Northern Ireland. From 2012 through the last year GOV.UK has published, every date and name is checked against the GOV.UK data in the tests, and differences are watched daily
+- **Singapore public holidays verified day by day against data.gov.sg**: the dates gazetted by the Ministry of Manpower (2020 through the last year gazetted), with the days in lieu for holidays on a Sunday, are checked against the MOM collection on data.gov.sg in the tests, and differences are watched daily
 - **Recurring rules**: rules such as "closed on the 3rd Wednesday", "closed every other Wednesday", "stocktaking on the last day of the month", "closed on Mondays (on the next weekday if Monday is a holiday)" or "closed on the day after a holiday", together with what happens when they fall on a holiday (follow the holiday, apply anyway, or move to the next day). Rules can have an effective period, so "closed on Tuesdays instead of Mondays from April 2027" is one calendar
 - **Day-by-day values (e.g. store hours)**: values that change by weekday, holiday and specific date, such as "closed on Tuesdays, Sunday hours on holidays, closed on New Year's Day, short hours on New Year's Eve", are looked up with the same rules
 - **Option diagnostics**: `diagnoseCalendar` and `diagnoseSchedule` from `bizdays-toolkit/diagnose` list rules that can never apply, rules whose removal changes nothing, typos in option keys, calendars with no business day and more, without throwing. One line in your tests keeps a change of settings from silently killing a rule
@@ -28,9 +29,9 @@ A business-day calendar that combines public holidays with company or store clos
 - **Business-day arithmetic**: closed weekdays, annual closures (including ranges across the new year), specific closed and open dates, and holidays combine to compute "N business days later", "next business day after the cut-off time" and more
 - **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.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
+- **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, `Asia/Singapore` for Singapore) before evaluation. A server running in UTC does not treat 00:00–09:00 in Japan as the previous day
+- **Lightweight, zero dependencies**: about 10.0 KB min+gzip (about 11.8 KB with Japanese holidays, about 11.7 KB with UK bank holidays, about 10.9 KB with Singapore holidays; measured for 0.17.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, the UK and Singapore are bundled
 
 ## Installation
 
@@ -93,6 +94,23 @@ const ukWide = createCalendar({ holidays: [england, scotland, northernIreland] }
 - Local holidays set by Scottish councils are not included. Whether a bank holiday is a day off depends on the employment contract and similar arrangements
 - One-off bank holidays may be announced only about ten days ahead. Differences from GOV.UK are watched daily and released as patch versions
 
+### Singapore public holidays
+
+```ts
+import { createCalendar } from "bizdays-toolkit";
+import { sg } from "bizdays-toolkit/sg";
+
+const singapore = createCalendar({ holidays: sg, closedWeekdays: [0, 6] });
+singapore.isBusinessDay("2026-08-10"); // false (National Day falls on a Sunday; Monday is the holiday in lieu)
+singapore.addBusinessDays("2026-02-16", 1); // "2026-02-19" (Chinese New Year on February 17 and 18)
+sg.holidaysInYear(2026).find((h) => h.kind === "substitute");
+// { date: "2026-06-01", name: "Vesak Day", nameEn: "Vesak Day", kind: "substitute", confirmed: true }
+```
+
+- `sg` (ID `SG`, time zone `Asia/Singapore`) is one provider; Singapore has no regional holidays. `kind` is `regular` (an annual public holiday), `substitute` (the day after a public holiday that falls on a Sunday, which the Holidays Act makes a public holiday; it has the name of the original holiday) or `special` (a one-off holiday declared by the Government, such as Polling Day). A public holiday on a Saturday has no substitute day
+- Chinese New Year, Hari Raya Puasa, Hari Raya Haji, Vesak Day and Deepavali follow the lunar, Islamic and Hindu calendars, so they cannot be computed from rules. The dates are the ones gazetted by the Ministry of Manpower (MOM), year by year, and the substitute days follow the rule of the Holidays Act. Supported years are the years MOM has gazetted (currently 2020–2027; `confirmedThrough` is the same as the last supported year). Later years are not predicted and are outside the supported years (`out-of-range`), so `sg` never returns `confirmed: false`
+- The dates are verified against the "Singapore Public Holidays" collection on data.gov.sg (MOM). Where that data differs from the gazetted dates (2022: the revised Hari Raya dates and two missing substitute days), the gazetted dates are used. Differences from data.gov.sg are watched daily and released as patch versions
+
 ### Business-day calendars
 
 ```ts
@@ -623,7 +641,37 @@ createCalendar({ holidays: jpWithNames }).getHoliday("2026-01-01")?.names; // {
 
 ### Outside the supported years
 
-Evaluating a date outside the holiday provider's supported years (1955–2099 for Japan, 2012–2099 for the UK) throws a `RangeError`. To treat such dates as having no holidays, set `outOfRange: "ignore"`.
+Evaluating a date outside the holiday provider's supported years (1955–2099 for Japan, 2012–2099 for the UK, 2020–2027 for Singapore) throws a `RangeError`. To treat such dates as having no holidays, set `outOfRange: "ignore"`.
+
+### Unconfirmed holidays
+
+Years after the provider's `confirmedThrough` may contain predicted holidays (`confirmed: false`): the Japanese equinox days, whose dates are published in the Official Gazette every February for the next year, and UK bank holidays after the last year GOV.UK has published. By default the predictions are used. With `unconfirmedHolidays: "throw"` (next to `outOfRange`, on calendars and schedules), any evaluation that looks up an unconfirmed holiday throws a `RangeError` with `code: "unconfirmed-holiday"`, so that a result which would depend on a prediction, such as a due date in a five-year repayment schedule or a date written into a contract, is never produced silently. "Any evaluation" includes the days a search passes through (`addBusinessDays`, `adjust`, `dueDate`, `closingMonth` and so on) and the neighbouring day a `dayAfterHoliday` or `dayBeforeHoliday` rule looks at, not only the day asked about. `holidaysInYear` and `holidaysBetween` never throw, so they are the way out: after catching the error, list the days that are affected.
+
+```ts
+import { createCalendar, isBizdaysError } from "bizdays-toolkit";
+import { jp } from "bizdays-toolkit/jp";
+
+const strict = createCalendar({
+  holidays: jp,
+  closedWeekdays: [0, 6],
+  unconfirmedHolidays: "throw",
+});
+try {
+  strict.dueDate("2028-03", { day: 20, convention: "following" });
+} catch (e) {
+  if (isBizdaysError(e) && e.code === "unconfirmed-holiday") {
+    // Recompute after the Official Gazette of February 2028; these are the days involved
+    strict
+      .holidaysBetween("2028-01-01", "2028-12-31")
+      .filter((h) => !h.confirmed)
+      .map((h) => h.date); // ["2028-03-20", "2028-09-22"]
+  }
+}
+```
+
+- It matters only when the results depend on holidays. With `holidayPolicy: "ignore"` (or `holiday: "weekday"` in a schedule) and no holiday-based rule (`holiday`, `dayAfterHoliday`, `dayBeforeHoliday`, `"after-holiday"`), the results do not change, but `dayInfo` still looks up the holiday it reports and throws. Option diagnostics flag such options as `redundant`
+- Combined calendars throw if any of their calendars throws; a calendar made from a schedule follows the schedule
+- The option catches holidays that are predicted, not holidays that are unknown: a one-off UK bank holiday announced later is absent from the predictions, and Singapore has no predictions at all (later years are `out-of-range`)
 
 ### Errors
 
@@ -645,7 +693,7 @@ Main codes: `invalid-date`, `invalid-input`, `invalid-month`, `invalid-month-day
 
 ### Option diagnostics
 
-`diagnoseCalendar` and `diagnoseSchedule` from `bizdays-toolkit/diagnose` examine options and return a list of problems. They never throw (an empty array means no problems).
+`diagnoseCalendar` and `diagnoseSchedule` from `bizdays-toolkit/diagnose` examine options and return a list of problems. They never throw for a problem in the options (an empty array means no problems); only a wrong second argument (see `asOf` below) throws.
 
 ```ts
 import { diagnoseCalendar } from "bizdays-toolkit/diagnose";
@@ -670,16 +718,17 @@ diagnoseCalendar({
 // ]
 ```
 
-| `severity` | `code`                       | Meaning                                                                                                                                                                            |
-| ---------- | ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `error`    | The same codes as exceptions | Errors that make `createCalendar` or `createSchedule` throw. Creation stops at the first one; diagnostics return them all                                                          |
-| `error`    | `invalid-provider-data`      | Errors in the data returned by a holiday provider. Creation checks only the years used; diagnostics check every supported year                                                     |
-| `warning`  | `unknown-option`             | Unknown keys (ignored at creation). If a close known key exists, `message` suggests it                                                                                             |
-| `warning`  | `shadowed`                   | A rule fully covered by an earlier rule of the same type (`relatedPath`) and never used                                                                                            |
-| `warning`  | `never-matches`              | A recurring rule that matches no day (such as `{ day: 30, months: [2] }`, a 5th Wednesday with an effective period that has none, or `dayAfterHoliday` without a holiday provider) |
-| `warning`  | `out-of-range`               | A specific date, or the effective period of a rule, outside the supported years of the holiday provider (`relatedPath`)                                                            |
-| `warning`  | `no-business-day`            | No business day at all (calendars only; searching for a business day throws)                                                                                                       |
-| `info`     | `redundant`                  | A rule whose removal changes nothing (covered by a combination of earlier rules, same as a closed weekday, the same value as the weekday in a schedule, and so on)                 |
+| `severity` | `code`                       | Meaning                                                                                                                                                                                                                                            |
+| ---------- | ---------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `error`    | The same codes as exceptions | Errors that make `createCalendar` or `createSchedule` throw. Creation stops at the first one; diagnostics return them all                                                                                                                          |
+| `error`    | `invalid-provider-data`      | Errors in the data returned by a holiday provider. Creation checks only the years used; diagnostics check every supported year                                                                                                                     |
+| `warning`  | `unknown-option`             | Unknown keys (ignored at creation). If a close known key exists, `message` suggests it                                                                                                                                                             |
+| `warning`  | `shadowed`                   | A rule fully covered by an earlier rule of the same type (`relatedPath`) and never used                                                                                                                                                            |
+| `warning`  | `never-matches`              | A recurring rule that matches no day (such as `{ day: 30, months: [2] }`, a 5th Wednesday with an effective period that has none, or `dayAfterHoliday` without a holiday provider)                                                                 |
+| `warning`  | `out-of-range`               | A specific date, or the effective period of a rule, outside the supported years of the holiday provider (`relatedPath`)                                                                                                                            |
+| `warning`  | `no-business-day`            | No business day at all (calendars only; searching for a business day throws)                                                                                                                                                                       |
+| `info`     | `redundant`                  | A rule whose removal changes nothing (covered by a combination of earlier rules, same as a closed weekday, the same value as the weekday in a schedule, and so on), or `unconfirmedHolidays: "throw"` in options whose results do not use holidays |
+| `info`     | `expired`                    | Only with `asOf` (below): a rule or date that ended before the given day                                                                                                                                                                           |
 
 - Branch on `code`. `message` is in English and its wording may change. Future versions may add codes
 - When there is an `error`, the rule relation checks (`shadowed`, `redundant` and so on) are skipped
@@ -690,6 +739,25 @@ diagnoseCalendar({
 - `redundant` compares the results with and without the rule day by day. Specific dates are checked over their range; annual dates and recurring rules are checked, with specific dates removed, over the holiday provider's supported years (1955–2099 for Japan), or 2001–2028 without a provider (28 years cover every combination of weekday and date; with `interval` rules the range is extended to the length of their cycle, such as 56 years for every other week). Effective periods outside that range are checked as well (with `outOfRange: "throw"`, only within the supported years). `message` names the years checked. Schedule values are compared by content for arrays and plain objects, and by identity otherwise (such as `Date`)
 - With Japanese holidays, checking every day takes a few hundred milliseconds. Use it in tests or at startup, not per request. As a development and test tool, it lives in a subpath so it stays out of your app's main bundle
 
+**Finding rules that have ended** (`asOf`): options accumulate over the years, for example in a multi-store service that stores each store's options as JSON. Pass `{ asOf: "YYYY-MM-DD" }` as the second argument and every rule with an `effectiveTo` before that day, and every specific date or range that ends before it, is returned as `info` with code `expired` (independent of `redundant`: these rules did affect the past). Without `asOf` nothing is returned as `expired`, so a test such as `assert.deepEqual(diagnoseCalendar(options), [])` does not drift with the date. `asOf` takes only a date string (a `Date` would need a time zone); other values throw `invalid-date`, a second argument that is not an object throws `invalid-argument`, and unknown keys in it are ignored.
+
+```ts
+import { diagnoseCalendar } from "bizdays-toolkit/diagnose";
+import { jp } from "bizdays-toolkit/jp";
+
+diagnoseCalendar(
+  {
+    holidays: jp,
+    closedRecurring: [
+      { weekday: 1, name: "Closed on Mondays", effectiveTo: "2027-03-31" },
+      { weekday: 2, name: "Closed on Tuesdays", effectiveFrom: "2027-04-01" },
+    ],
+    closedDates: ["2026-02-10"],
+  },
+  { asOf: "2028-01-01" },
+).map((d) => [d.code, d.path]); // [["expired", "closedDates[0]"], ["expired", "closedRecurring[0]"]]
+```
+
 Keeping options safe with a test:
 
 ```ts
@@ -707,9 +775,9 @@ test("the shipping calendar options have no problems", () => {
 
 Versioning follows [Semantic Versioning](https://semver.org/). See [RELEASING.md](https://github.com/inohan77/bizdays-toolkit/blob/main/RELEASING.md) (Japanese) for details.
 
-- Official data updates (new, moved and one-off holidays by law, Official Gazette or proclamation, fixed equinox days in Japan, newly published years on GOV.UK) are released as **patch** versions, so they reach you with either `^` or `~`
+- Official data updates (new, moved and one-off holidays by law, Official Gazette or proclamation, fixed equinox days in Japan, newly published years on GOV.UK, newly gazetted years and revised dates in Singapore) are released as **patch** versions, so they reach you with either `^` or `~`
 - To freeze the holiday results, pin an exact version (for example `"bizdays-toolkit": "0.8.0"`)
-- The reflected data is shown by the provider's `dataVersion` (for Japan, the year and month of the Official Gazette reflected; for the UK, the year and month of the GOV.UK data reflected) and `confirmedThrough` (`jp.dataVersion`, `england.confirmedThrough` and so on). The module-level constants `dataVersion` and `confirmedThrough` in `bizdays-toolkit/jp` and `bizdays-toolkit/uk` are deprecated since 0.12.0 and will be removed in 1.0.0
+- The reflected data is shown by the provider's `dataVersion` (for Japan, the year and month of the Official Gazette reflected; for the UK and Singapore, the year and month of the GOV.UK or data.gov.sg data reflected) and `confirmedThrough` (`jp.dataVersion`, `england.confirmedThrough` and so on). The module-level constants `dataVersion` and `confirmedThrough` in `bizdays-toolkit/jp` and `bizdays-toolkit/uk` are deprecated since 0.12.0 and will be removed in 1.0.0
 - Before 1.0.0, minor versions may contain breaking changes. What you need to change when moving between minor versions is listed in the [migration guide](https://github.com/inohan77/bizdays-toolkit/blob/main/docs/migration.md) (Japanese) and in the "移行" (migration) part of each version in the CHANGELOG
 - Decision reasons (`reason`), holiday kinds (`kind`), error codes and diagnostic codes may gain values in future versions. When you branch on their values, handle "anything else" too (see "互換性の約束", the compatibility promise, in [RELEASING.md](https://github.com/inohan77/bizdays-toolkit/blob/main/RELEASING.md))
 
@@ -719,7 +787,9 @@ Japanese holidays are verified with the "National Holidays" CSV published on the
 
 UK bank holidays are verified with the GOV.UK bank holidays data (<https://www.gov.uk/bank-holidays.json>, and for earlier years the history of the official GOV.UK repositories [alphagov/calendars](https://github.com/alphagov/calendars) and [alphagov/frontend](https://github.com/alphagov/frontend)), and the Welsh names of the Wales holidays with the Welsh version of GOV.UK (the verification data is a test fixture only; not included in the package).
 
-Contains public sector information licensed under the [Open Government Licence v3.0](https://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/).
+Singapore public holidays are verified with the "Singapore Public Holidays" collection published by the Ministry of Manpower on data.gov.sg (<https://data.gov.sg/collections/691/view>), with the Ministry's press releases as the authority where the two differ (the verification data is a test fixture only; not included in the package).
+
+Contains public sector information licensed under the [Open Government Licence v3.0](https://www.nationalarchives.gov.uk/doc/open-government-licence/version/3/), and data from data.gov.sg made available under the [Singapore Open Data Licence](https://data.gov.sg/open-data-licence).
 
 ## License
 

package/dist/core/calendar.js

@@ -27,6 +27,7 @@ const CALENDAR_OPTION_KEYS = [
     "holidays",
     "timeZone",
     "outOfRange",
+    "unconfirmedHolidays",
     "closedWeekdays",
     "closedAnnual",
     "closedDates",
@@ -264,6 +265,7 @@ function buildCalendar(lookup, isOpen, info, maxSearchDays) {
         timeZone: lookup.timeZone,
         providers: lookup.providers,
         outOfRange: lookup.outOfRange,
+        unconfirmedHolidays: lookup.unconfirmedHolidays,
         dateOf,
         civilOf: lookup.civilOf,
         instantOf: lookup.instantOf,
@@ -401,6 +403,10 @@ export function combineCalendars(calendars, options) {
         providers: Object.freeze(providers),
         timeZone: zones[0],
         outOfRange: calendars.every((c) => c.outOfRange === "ignore") ? "ignore" : "throw",
+        // 未確定の祝日も同じ考え方: どれかが "throw" なら、そのカレンダーの判定が例外になるので合成の holiday も "throw"
+        unconfirmedHolidays: calendars.some((c) => c.unconfirmedHolidays === "throw")
+            ? "throw"
+            : "accept",
     });
     const isOpen = (date) => mode === "all"
         ? calendars.every((c) => c.isBusinessDay(date))

package/dist/core/diagnose.d.ts

@@ -11,7 +11,11 @@
  *     never-matches  … 当てはまる日がない繰り返しの規則（2 月 30 日、有効期間の中に第 5 水曜日がない、提供元のない設定の祝日の翌日・祝前日、など）
  *     out-of-range   … 個別の日付、または規則の有効期間が祝日の提供元の対応年の外にある（relatedPath に提供元）
  *     no-business-day … 営業日が 1 日もない設定（営業日カレンダーのみ）
- * - info    … redundant: 取り除いても結果が変わらない規則
+ * - info    … redundant: 取り除いても結果が変わらない規則・設定（判定に祝日を使わない設定の unconfirmedHolidays: "throw" を含む）
+ *             expired: 第 2 引数の asOf より前に終わった規則・日付（asOf を渡したときだけ）
+ *
+ * 未確定の祝日の扱い（unconfirmedHolidays）は診断では常に "accept" で評価する。診断は設定の形を調べるもので、
+ * 祝日が確定しているかどうかは関係がなく、"throw" のまま評価すると例外を握りつぶして「当てはまらない」と誤判定するため
  *
  * 判定の順番（個別の日付 → 毎年の月日 → 繰り返し（over）→ 祝日 → 繰り返し（under・振替先）→ 曜日）は
  * 固定なので、shadowed は同じ種類の規則どうしに限って調べる。種類をまたいで使われない規則は
@@ -19,6 +23,7 @@
  * 有効期間（effectiveFrom・effectiveTo）のある規則は期間の包含も、周期（interval）のある規則は周期の包含も
  * shadowed の条件にする。redundant の走査の範囲は、周期がそろう長さと、範囲の外にある有効期間まで広げる
  */
+import { type DateString } from "./date.ts";
 import { type CalendarOptions } from "./calendar.ts";
 import { type KnownErrorCode } from "./errors.ts";
 import { type ScheduleOptions } from "./schedule.ts";
@@ -44,7 +49,9 @@ export type KnownDiagnosticCode = KnownErrorCode
 /** 当てはまる日がない繰り返しの規則 */
  | "never-matches"
 /** 取り除いても結果が変わらない */
- | "redundant";
+ | "redundant"
+/** 基準日（asOf）より前に終わった規則・日付（整理の候補） */
+ | "expired";
 /**
  * 診断コード。将来の版で値が増えることがあるので、分岐では「その他」も扱うこと。
  * @public
@@ -63,6 +70,18 @@ export interface Diagnostic {
     /** 関係する別の位置（shadowed では覆っている先の規則、out-of-range では祝日の提供元） */
     readonly relatedPath?: string;
 }
+/** 診断を実行する。祝日の提供元の誤り（年ごとに初めて使うときに分かる）も error として返す */
+/**
+ * 診断のオプション（第 2 引数）。
+ * @public
+ */
+export interface DiagnoseOptions {
+    /**
+     * 基準日 "YYYY-MM-DD"。指定すると、この日より前に終わった規則・日付（有効期間の effectiveTo、個別の日付・期間の終わり）を
+     * info の expired として返す（整理の候補）。省略時は返さない（現在時刻は使わず、結果を決定的に保つ）
+     */
+    readonly asOf?: DateString;
+}
 /**
  * 営業日カレンダーの設定を診断する。例外は投げず、見つけた問題を返す（問題がなければ空の配列）。
  *
@@ -70,7 +89,7 @@ export interface Diagnostic {
  * JavaScript から渡された型の合わない設定も受け付ける。
  * @public
  */
-export declare function diagnoseCalendar(options?: CalendarOptions | object): readonly Diagnostic[];
+export declare function diagnoseCalendar(options?: CalendarOptions | object, diagnoseOptions?: DiagnoseOptions): readonly Diagnostic[];
 /**
  * スケジュールの設定を診断する。例外は投げず、見つけた問題を返す（問題がなければ空の配列）。
  *
@@ -78,4 +97,4 @@ export declare function diagnoseCalendar(options?: CalendarOptions | object): re
  * error があるときは、規則どうしの診断（shadowed・redundant など）は行わない。
  * @public
  */
-export declare function diagnoseSchedule(options: ScheduleOptions<unknown> | object): readonly Diagnostic[];
+export declare function diagnoseSchedule(options: ScheduleOptions<unknown> | object, diagnoseOptions?: DiagnoseOptions): readonly Diagnostic[];

package/dist/core/diagnose.js

@@ -11,7 +11,11 @@
  *     never-matches  … 当てはまる日がない繰り返しの規則（2 月 30 日、有効期間の中に第 5 水曜日がない、提供元のない設定の祝日の翌日・祝前日、など）
  *     out-of-range   … 個別の日付、または規則の有効期間が祝日の提供元の対応年の外にある（relatedPath に提供元）
  *     no-business-day … 営業日が 1 日もない設定（営業日カレンダーのみ）
- * - info    … redundant: 取り除いても結果が変わらない規則
+ * - info    … redundant: 取り除いても結果が変わらない規則・設定（判定に祝日を使わない設定の unconfirmedHolidays: "throw" を含む）
+ *             expired: 第 2 引数の asOf より前に終わった規則・日付（asOf を渡したときだけ）
+ *
+ * 未確定の祝日の扱い（unconfirmedHolidays）は診断では常に "accept" で評価する。診断は設定の形を調べるもので、
+ * 祝日が確定しているかどうかは関係がなく、"throw" のまま評価すると例外を握りつぶして「当てはまらない」と誤判定するため
  *
  * 判定の順番（個別の日付 → 毎年の月日 → 繰り返し（over）→ 祝日 → 繰り返し（under・振替先）→ 曜日）は
  * 固定なので、shadowed は同じ種類の規則どうしに限って調べる。種類をまたいで使われない規則は
@@ -19,9 +23,9 @@
  * 有効期間（effectiveFrom・effectiveTo）のある規則は期間の包含も、周期（interval）のある規則は周期の包含も
  * shadowed の条件にする。redundant の走査の範囲は、周期がそろう長さと、範囲の外にある有効期間まで広げる
  */
-import { daysInMonth, fromDayNumber, parseDate, toDayNumber } from "./date.js";
+import { daysInMonth, fromDayNumber, isValidDate, parseDate, toDayNumber, } from "./date.js";
 import { compileCalendarOptions } from "./calendar.js";
-import { IssueCollector } from "./errors.js";
+import { IssueCollector, rangeError } from "./errors.js";
 import { compileScheduleOptions, createHolidayLookup, createResolver, inPeriod, matchMonthDay, matchPattern, } from "./schedule.js";
 // ------------------------------------------------------------
 // 知らないキーの候補
@@ -306,7 +310,7 @@ function analyze(c, compiled, isCalendar) {
     const { source, dates, annual, recurring } = compiled;
     if (!checkProviderData(c, source))
         return;
-    const lookup = createHolidayLookup(source);
+    const lookup = createHolidayLookup({ ...source, unconfirmedHolidays: "accept" });
     const cycle = patternCycle(recurring);
     const window = scanWindow(source, [...annual, ...recurring], cycle);
     /** 使われないことが分かった規則（redundant を重ねて出さない） */
@@ -487,9 +491,59 @@ function analyze(c, compiled, isCalendar) {
             : `Removing this rule does not change any result (checked ${window.label})`);
     }
 }
-/** 診断を実行する。祝日の提供元の誤り（年ごとに初めて使うときに分かる）も error として返す */
-function run(c, compiled, isCalendar) {
+/** 第 2 引数を検証する（設定の誤りは診断結果で返すが、引数の誤りは例外。知らないキーは無視する） */
+function compileDiagnoseOptions(options) {
+    if (options === undefined)
+        return { asOf: null };
+    if (typeof options !== "object" || options === null || Array.isArray(options)) {
+        throw rangeError("invalid-argument", "the second argument must be an object of diagnose options");
+    }
+    const asOf = options.asOf;
+    if (asOf === undefined)
+        return { asOf: null };
+    if (!isValidDate(asOf)) {
+        throw rangeError("invalid-date", `asOf must be a date string "YYYY-MM-DD": ${JSON.stringify(asOf)}`);
+    }
+    return { asOf: toDayNumber(asOf) };
+}
+/** 基準日より前に終わった規則・日付を expired にする（暦日の大小比較だけで、祝日は引かない） */
+function checkExpired(c, compiled, asOf) {
+    const ended = (path, last, what) => {
+        if (last < asOf) {
+            c.info("expired", path, `This ${what} ended on ${fromDayNumber(last)}, before ${fromDayNumber(asOf)}; it no longer affects results and can be removed if the past need not be reproduced`);
+        }
+    };
+    for (const r of compiled.dates)
+        ended(r.path, r.to, "date");
+    for (const r of compiled.annual)
+        if (r.effectiveTo !== null)
+            ended(r.path, r.effectiveTo, "rule");
+    for (const r of compiled.recurring)
+        if (r.effectiveTo !== null)
+            ended(r.path, r.effectiveTo, "rule");
+}
+/**
+ * 判定に祝日を使わない設定（提供元がない、または holidayPolicy: "ignore" / holiday: "weekday" で祝日に従属する規則もない）の
+ * unconfirmedHolidays: "throw" は、結果に影響しないので redundant にする。dayInfo が holiday を付けるために祝日を引くので実行時には投げるが、
+ * 投げても結果が変わらない設定であることを知らせる
+ */
+function checkUnconfirmedOption(c, compiled, isCalendar) {
+    if (compiled.source.unconfirmedHolidays !== "throw")
+        return;
+    const noProvider = compiled.source.providers.length === 0;
+    const holidayUnused = compiled.holiday === "weekday" &&
+        !compiled.recurring.some((r) => r.holiday || r.dayAfterHoliday || r.dayBeforeHoliday || r.onHolidayRule === "after-holiday");
+    if (!noProvider && !holidayUnused)
+        return;
+    c.info("redundant", "unconfirmedHolidays", noProvider
+        ? 'unconfirmedHolidays: "throw" has no effect: there is no holiday provider'
+        : `unconfirmedHolidays: "throw" has no effect on results: holidays are not used (${isCalendar ? 'holidayPolicy: "ignore"' : 'holiday: "weekday"'} and no holiday-based rule); dayInfo still throws when it looks up the holiday to report`);
+}
+function run(c, compiled, isCalendar, asOf) {
     if (compiled && !c.hasErrors) {
+        if (asOf !== null)
+            checkExpired(c, compiled, asOf);
+        checkUnconfirmedOption(c, compiled, isCalendar);
         const before = c.issues.length;
         try {
             analyze(c, compiled, isCalendar);
@@ -518,10 +572,11 @@ function run(c, compiled, isCalendar) {
  * JavaScript から渡された型の合わない設定も受け付ける。
  * @public
  */
-export function diagnoseCalendar(options = {}) {
+export function diagnoseCalendar(options = {}, diagnoseOptions) {
+    const { asOf } = compileDiagnoseOptions(diagnoseOptions);
     const c = new IssueCollector();
     const compiled = compileCalendarOptions(c, options);
-    return run(c, compiled?.schedule, true);
+    return run(c, compiled?.schedule, true, asOf);
 }
 /**
  * スケジュールの設定を診断する。例外は投げず、見つけた問題を返す（問題がなければ空の配列）。
@@ -530,8 +585,9 @@ export function diagnoseCalendar(options = {}) {
  * error があるときは、規則どうしの診断（shadowed・redundant など）は行わない。
  * @public
  */
-export function diagnoseSchedule(options) {
+export function diagnoseSchedule(options, diagnoseOptions) {
+    const { asOf } = compileDiagnoseOptions(diagnoseOptions);
     const c = new IssueCollector();
     const compiled = compileScheduleOptions(c, options);
-    return run(c, compiled, false);
+    return run(c, compiled, false, asOf);
 }

package/dist/core/errors.d.ts

@@ -34,6 +34,8 @@ export type KnownErrorCode =
  | "time-zone-conflict"
 /** 対応している年の範囲の外 */
  | "out-of-range"
+/** 判定が未確定の祝日（confirmed: false）に触れた（unconfirmedHolidays: "throw"） */
+ | "unconfirmed-holiday"
 /** 祝日の提供元の形式の誤り */
  | "invalid-provider"
 /** 祝日の提供元が返したデータの誤り */

package/dist/core/schedule.d.ts

@@ -252,6 +252,14 @@ export interface HolidaySourceOptions<Kind extends string = string> {
     readonly timeZone?: string;
     /** 祝日の提供元の対応年を外れた日付の扱い（既定: "throw"） */
     readonly outOfRange?: "throw" | "ignore";
+    /**
+     * 判定が未確定の祝日（提供元の confirmed: false。日本の春分の日・秋分の日の予測など）に触れたときの扱い（既定: "accept"）。
+     * "throw" にすると、dayInfo・isBusinessDay に限らず、営業日の探索・調整・期日の計算の途中で評価した日や、祝日の翌日・祝前日の
+     * 規則が見る隣の日を含め、祝日を引いた日が未確定の祝日なら unconfirmed-holiday の RangeError を投げる。
+     * holidaysInYear・holidaysBetween は投げないので、影響する日の列挙に使える。
+     * 判定に祝日を使う設定（holidayPolicy が "ignore" でない、または祝日に従属する規則がある）でだけ意味がある
+     */
+    readonly unconfirmedHolidays?: "accept" | "throw";
 }
 /**
  * スケジュールの設定。
@@ -313,6 +321,8 @@ export interface HolidayLookup<Kind extends string = string> {
     readonly providers: readonly HolidayProvider<Kind>[];
     /** 祝日の提供元の対応年を外れた日付の扱い（設定の outOfRange） */
     readonly outOfRange: "throw" | "ignore";
+    /** 未確定の祝日に触れたときの扱い（設定の unconfirmedHolidays） */
+    readonly unconfirmedHolidays: "accept" | "throw";
     /** 入力をタイムゾーンでの暦日に変換する */
     dateOf(input: DateInput): DateString;
     /** 入力をタイムゾーンでの暦日と時刻に変換する */
@@ -432,6 +442,7 @@ export interface HolidaySource<Kind extends string> {
     readonly providers: readonly HolidayProvider<Kind>[];
     readonly timeZone: string;
     readonly outOfRange: "throw" | "ignore";
+    readonly unconfirmedHolidays: "accept" | "throw";
 }
 /** @internal 祝日の提供元とタイムゾーンの設定を検証する */
 export declare function compileHolidaySource<Kind extends string>(c: IssueCollector, options: Record<string, unknown>): HolidaySource<Kind>;

package/dist/core/schedule.js

@@ -494,10 +494,15 @@ export function compileHolidaySource(c, options) {
     if (outOfRange !== "throw" && outOfRange !== "ignore") {
         c.error("invalid-option", "outOfRange", 'must be "throw" or "ignore"');
     }
+    const unconfirmed = options["unconfirmedHolidays"] ?? "accept";
+    if (unconfirmed !== "accept" && unconfirmed !== "throw") {
+        c.error("invalid-option", "unconfirmedHolidays", 'must be "accept" or "throw"');
+    }
     return {
         providers: Object.freeze(providers),
         timeZone,
         outOfRange: outOfRange === "ignore" ? "ignore" : "throw",
+        unconfirmedHolidays: unconfirmed === "throw" ? "throw" : "accept",
     };
 }
 // ------------------------------------------------------------
@@ -570,7 +575,7 @@ function checkNames(names) {
 }
 /** @internal 祝日を調べる機能を作る（設定は検証済みであること） */
 export function createHolidayLookup(source) {
-    const { providers, timeZone, outOfRange } = source;
+    const { providers, timeZone, outOfRange, unconfirmedHolidays } = source;
     const yearCache = new Map();
     function holidayMap(year) {
         let map = yearCache.get(year);
@@ -596,7 +601,20 @@ export function createHolidayLookup(source) {
     function holidayOn(date) {
         if (providers.length === 0)
             return undefined;
-        return holidayMap(parseDate(date).year).get(date);
+        const h = holidayMap(parseDate(date).year).get(date);
+        // 判定に使う祝日が未確定なら止める（holidaysInYear・holidaysBetween はこの経路を通らないので投げない）
+        if (h !== undefined && unconfirmedHolidays === "throw" && !h.confirmed) {
+            // どの提供元の予測かを添える（提供元の confirmedThrough は、利用者が再計算の時期を知る手がかり）
+            const year = parseDate(date).year;
+            const provider = providers.find((p) => year >= p.supportedYears.from &&
+                year <= p.supportedYears.to &&
+                loadProviderYear(p, year).some((x) => x.date === date && !x.confirmed));
+            const through = provider?.confirmedThrough === undefined
+                ? ""
+                : ` (${provider.id} is confirmed through ${provider.confirmedThrough})`;
+            throw rangeError("unconfirmed-holiday", `${date} ${h.name} is not yet confirmed${through}; the result would depend on a predicted holiday`);
+        }
+        return h;
     }
     const dateOf = (input) => toCivil(input, timeZone).date;
     function holidaysInYear(year) {
@@ -608,6 +626,7 @@ export function createHolidayLookup(source) {
         timeZone,
         providers,
         outOfRange,
+        unconfirmedHolidays,
         holidayOn,
         dateOf,
         civilOf: ((input) => toDateTimeParts(input, timeZone)),
@@ -635,6 +654,7 @@ const SCHEDULE_OPTION_KEYS = [
     "holidays",
     "timeZone",
     "outOfRange",
+    "unconfirmedHolidays",
     "weekly",
     "holiday",
     "annual",
@@ -722,8 +742,11 @@ export function createResolver(compiled, lookup) {
         try {
             return lookup.holidayOn(date);
         }
-        catch {
-            return undefined;
+        catch (error) {
+            // 飲み込むのは対応年の外だけ。未確定の祝日（unconfirmed-holiday）などはそのまま投げる
+            if (error?.code === "out-of-range")
+                return undefined;
+            throw error;
         }
     }
     const isHolidaySafe = (date) => holidayOfSafe(date) !== undefined;
@@ -831,6 +854,7 @@ export function buildSchedule(compiled) {
         timeZone: lookup.timeZone,
         providers: lookup.providers,
         outOfRange: lookup.outOfRange,
+        unconfirmedHolidays: lookup.unconfirmedHolidays,
         dateOf: lookup.dateOf,
         civilOf: lookup.civilOf,
         instantOf: lookup.instantOf,

package/dist/diagnose/index.d.ts

@@ -4,4 +4,4 @@
  * 営業日カレンダー・スケジュールの設定を調べ、誤り・使われない規則・打ち間違いなどを返す。
  * 開発やテストで使う道具なので、アプリの本体のバンドルに入らないようサブパスに分けている。
  */
-export { diagnoseCalendar, diagnoseSchedule, type Diagnostic, type DiagnosticCode, type DiagnosticSeverity, type KnownDiagnosticCode, } from "../core/diagnose.ts";
+export { diagnoseCalendar, diagnoseSchedule, type DiagnoseOptions, type Diagnostic, type DiagnosticCode, type DiagnosticSeverity, type KnownDiagnosticCode, } from "../core/diagnose.ts";

package/dist/sg/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * シンガポールの祝日（public holidays。MOM が年ごとに告示する日付を data.gov.sg のデータで全日照合）。
+ *
+ * @example
+ * import { createCalendar } from "bizdays-toolkit";
+ * import { sg } from "bizdays-toolkit/sg";
+ * const calendar = createCalendar({ holidays: sg, closedWeekdays: [0, 6] });
+ */
+import type { Holiday, HolidayProvider } from "../core/types.ts";
+import { type SgHolidayKind } from "./rules.ts";
+export type { KnownSgHolidayKind, SgHolidayKind } from "./rules.ts";
+/**
+ * シンガポールの祝日。
+ * @public
+ */
+export type SgHoliday = Holiday<SgHolidayKind>;
+/**
+ * シンガポールの祝日の提供元。対応年は MOM が告示した年（2020 年〜）だけで、それより後の年は予測せず out-of-range
+ * （旧正月・Hari Raya・Vesak Day・Deepavali は規則で計算できないため）。日曜日に当たる祝日の振替（kind: "substitute"）は
+ * Holidays Act の規則で計算する。
+ * @public
+ */
+export declare const sg: HolidayProvider<SgHolidayKind>;

package/dist/sg/index.js

@@ -0,0 +1,31 @@
+/**
+ * シンガポールの祝日（public holidays。MOM が年ごとに告示する日付を data.gov.sg のデータで全日照合）。
+ *
+ * @example
+ * import { createCalendar } from "bizdays-toolkit";
+ * import { sg } from "bizdays-toolkit/sg";
+ * const calendar = createCalendar({ holidays: sg, closedWeekdays: [0, 6] });
+ */
+import { CONFIRMED_THROUGH, DATA_VERSION, SUPPORTED_YEARS, computeSgHolidays, } from "./rules.js";
+const cache = new Map();
+/**
+ * シンガポールの祝日の提供元。対応年は MOM が告示した年（2020 年〜）だけで、それより後の年は予測せず out-of-range
+ * （旧正月・Hari Raya・Vesak Day・Deepavali は規則で計算できないため）。日曜日に当たる祝日の振替（kind: "substitute"）は
+ * Holidays Act の規則で計算する。
+ * @public
+ */
+export const sg = Object.freeze({
+    id: "SG",
+    timeZone: "Asia/Singapore",
+    supportedYears: SUPPORTED_YEARS,
+    dataVersion: DATA_VERSION,
+    confirmedThrough: CONFIRMED_THROUGH,
+    holidaysInYear(year) {
+        let list = cache.get(year);
+        if (!list) {
+            list = Object.freeze(computeSgHolidays(year));
+            cache.set(year, list);
+        }
+        return list;
+    },
+});

package/dist/sg/rules.d.ts

@@ -0,0 +1,41 @@
+/**
+ * シンガポールの祝日（public holidays）の表と振替の規則。
+ *
+ * 旧正月・Hari Raya・Vesak Day・Deepavali は太陰暦・イスラム暦・ヒンドゥー暦で決まり、規則では計算できない。
+ * 日本・英国と違い、年ごとに MOM（Ministry of Manpower）が官報で告示した日付を正として表で持つ。
+ * 振替だけは Holidays Act（1998 年版）第 4 条の規則「日曜日に当たる祝日は、その翌日のうちそれ自体が祝日でない
+ * 最初の日を祝日とする」で計算し、表には書かない。土曜日に当たる祝日は振替にならない（雇用主が休みか手当を与える）。
+ *
+ * 名称は MOM の報道発表の綴り（アポストロフィは ’）。data.gov.sg のコレクション 691（MOM）のデータで
+ * 全日照合している（test/fixtures/datagovsg-public-holidays.json）。data.gov.sg の 2022 年分は MOM の改定後の告示と
+ * 食い違う（scripts/verify-datagovsg.ts の KNOWN_DIFFERENCES）ため、告示を正としている。
+ */
+import type { Holiday } from "../core/types.ts";
+/**
+ * シンガポールの祝日の種別（既知の値）。
+ * @public
+ */
+export type KnownSgHolidayKind = 
+/** 毎年の祝日（Holidays Act の別表と、年ごとに告示される日付） */
+"regular"
+/** 日曜日に当たった祝日の振替（Holidays Act 第 4 条） */
+ | "substitute"
+/** 告示による臨時の祝日（Polling Day など） */
+ | "special";
+/**
+ * シンガポールの祝日の種別。将来の版で値が増えることがあるので、分岐では「その他」も扱うこと。
+ * すべての値を網羅したことを型で確かめたい場合は KnownSgHolidayKind を使う。
+ * @public
+ */
+export type SgHolidayKind = KnownSgHolidayKind | (string & {});
+/** @internal 対応年（表のある年。それより後は予測できないので out-of-range） */
+export declare const SUPPORTED_YEARS: Readonly<{
+    from: 2020;
+    to: 2027;
+}>;
+/** @internal MOM が日付を告示している最後の年（対応年の終わりと同じ。表の年はすべて確定） */
+export declare const CONFIRMED_THROUGH = 2027;
+/** @internal 反映済みの data.gov.sg のコレクション 691 の更新年月（2027 年分の公開） */
+export declare const DATA_VERSION = "2026-07";
+/** @internal その年の祝日（表と振替の規則から。日付順） */
+export declare function computeSgHolidays(year: number): Holiday<SgHolidayKind>[];

package/dist/sg/rules.js

@@ -0,0 +1,156 @@
+/**
+ * シンガポールの祝日（public holidays）の表と振替の規則。
+ *
+ * 旧正月・Hari Raya・Vesak Day・Deepavali は太陰暦・イスラム暦・ヒンドゥー暦で決まり、規則では計算できない。
+ * 日本・英国と違い、年ごとに MOM（Ministry of Manpower）が官報で告示した日付を正として表で持つ。
+ * 振替だけは Holidays Act（1998 年版）第 4 条の規則「日曜日に当たる祝日は、その翌日のうちそれ自体が祝日でない
+ * 最初の日を祝日とする」で計算し、表には書かない。土曜日に当たる祝日は振替にならない（雇用主が休みか手当を与える）。
+ *
+ * 名称は MOM の報道発表の綴り（アポストロフィは ’）。data.gov.sg のコレクション 691（MOM）のデータで
+ * 全日照合している（test/fixtures/datagovsg-public-holidays.json）。data.gov.sg の 2022 年分は MOM の改定後の告示と
+ * 食い違う（scripts/verify-datagovsg.ts の KNOWN_DIFFERENCES）ため、告示を正としている。
+ */
+import { addDays, formatDate, weekdayOf } from "../core/date.js";
+import { rangeError } from "../core/errors.js";
+/** @internal 対応年（表のある年。それより後は予測できないので out-of-range） */
+export const SUPPORTED_YEARS = Object.freeze({ from: 2020, to: 2027 });
+/** @internal MOM が日付を告示している最後の年（対応年の終わりと同じ。表の年はすべて確定） */
+export const CONFIRMED_THROUGH = 2027;
+/** @internal 反映済みの data.gov.sg のコレクション 691 の更新年月（2027 年分の公開） */
+export const DATA_VERSION = "2026-07";
+const NEW_YEAR = "New Year’s Day";
+const CNY = "Chinese New Year";
+const GOOD_FRIDAY = "Good Friday";
+const LABOUR = "Labour Day";
+const PUASA = "Hari Raya Puasa";
+const VESAK = "Vesak Day";
+const HAJI = "Hari Raya Haji";
+const NATIONAL = "National Day";
+const DEEPAVALI = "Deepavali";
+const CHRISTMAS = "Christmas Day";
+const POLLING = "Polling Day";
+/** 年ごとに動く祝日（月日と名前）。固定日の祝日（1/1・5/1・8/9・12/25）は表に書かず、下で足す */
+const MOVABLE = {
+    2020: [
+        ["01-25", CNY],
+        ["01-26", CNY],
+        ["04-10", GOOD_FRIDAY],
+        ["05-07", VESAK],
+        ["05-24", PUASA],
+        ["07-31", HAJI],
+        ["11-14", DEEPAVALI],
+    ],
+    2021: [
+        ["02-12", CNY],
+        ["02-13", CNY],
+        ["04-02", GOOD_FRIDAY],
+        ["05-13", PUASA],
+        ["05-26", VESAK],
+        ["07-20", HAJI],
+        ["11-04", DEEPAVALI],
+    ],
+    // 2022 年の Hari Raya Puasa・Haji は 2021-10-21 の MOM の報道発表で 5/3・7/10 に改定された（data.gov.sg は改定前の形）
+    2022: [
+        ["02-01", CNY],
+        ["02-02", CNY],
+        ["04-15", GOOD_FRIDAY],
+        ["05-03", PUASA],
+        ["05-15", VESAK],
+        ["07-10", HAJI],
+        ["10-24", DEEPAVALI],
+    ],
+    2023: [
+        ["01-22", CNY],
+        ["01-23", CNY],
+        ["04-07", GOOD_FRIDAY],
+        ["04-22", PUASA],
+        ["06-02", VESAK],
+        ["06-29", HAJI],
+        ["11-12", DEEPAVALI],
+    ],
+    2024: [
+        ["02-10", CNY],
+        ["02-11", CNY],
+        ["03-29", GOOD_FRIDAY],
+        ["04-10", PUASA],
+        ["05-22", VESAK],
+        ["06-17", HAJI],
+        ["10-31", DEEPAVALI],
+    ],
+    2025: [
+        ["01-29", CNY],
+        ["01-30", CNY],
+        ["03-31", PUASA],
+        ["04-18", GOOD_FRIDAY],
+        ["05-12", VESAK],
+        ["06-07", HAJI],
+        ["10-20", DEEPAVALI],
+    ],
+    2026: [
+        ["02-17", CNY],
+        ["02-18", CNY],
+        ["03-21", PUASA],
+        ["04-03", GOOD_FRIDAY],
+        ["05-27", HAJI],
+        ["05-31", VESAK],
+        ["11-08", DEEPAVALI],
+    ],
+    2027: [
+        ["02-06", CNY],
+        ["02-07", CNY],
+        ["03-10", PUASA],
+        ["03-26", GOOD_FRIDAY],
+        ["05-17", HAJI],
+        ["05-20", VESAK],
+        ["10-28", DEEPAVALI],
+    ],
+};
+/** 告示による臨時の祝日（総選挙・大統領選挙の投票日） */
+const SPECIAL_DAYS = [
+    ["2020-07-10", POLLING],
+    ["2023-09-01", POLLING],
+    ["2025-05-03", POLLING],
+];
+const FIXED = [
+    [1, 1, NEW_YEAR],
+    [5, 1, LABOUR],
+    [8, 9, NATIONAL],
+    [12, 25, CHRISTMAS],
+];
+/** @internal その年の祝日（表と振替の規則から。日付順） */
+export function computeSgHolidays(year) {
+    const movable = MOVABLE[year];
+    if (movable === undefined) {
+        throw rangeError("out-of-range", `Singapore public holidays are available for ${SUPPORTED_YEARS.from}-${SUPPORTED_YEARS.to}: ${year}`);
+    }
+    const entries = [
+        ...FIXED.map(([m, d, name]) => ({
+            date: formatDate(year, m, d),
+            name,
+            kind: "regular",
+        })),
+        ...movable.map(([md, name]) => ({
+            date: `${year}-${md}`,
+            name,
+            kind: "regular",
+        })),
+        ...SPECIAL_DAYS.filter(([date]) => date.startsWith(`${year}-`)).map(([date, name]) => ({
+            date,
+            name,
+            kind: "special",
+        })),
+    ].sort((a, b) => (a.date < b.date ? -1 : 1));
+    // 日曜日に当たる祝日を日付順に振り替える（振替先は、それ自体が祝日でない翌日以降の最初の日）
+    const taken = new Set(entries.map((e) => e.date));
+    const sundays = entries.filter((e) => weekdayOf(e.date) === 0);
+    for (const e of sundays) {
+        let day = addDays(e.date, 1);
+        while (taken.has(day))
+            day = addDays(day, 1);
+        entries.push({ date: day, name: e.name, kind: "substitute" });
+        taken.add(day);
+    }
+    return entries
+        .sort((a, b) => (a.date < b.date ? -1 : 1))
+        .map((e) => Object.freeze({ date: e.date, name: e.name, nameEn: e.name, kind: e.kind, confirmed: true }));
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bizdays-toolkit",
-  "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 のデータで全日照合）",
+  "version": "0.17.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",
     "bizdays",
@@ -11,6 +11,7 @@
     "holiday",
     "holidays",
     "japan",
+    "singapore",
     "uk",
     "workday",
     "営業日",
@@ -46,6 +47,10 @@
       "types": "./dist/uk/index.d.ts",
       "default": "./dist/uk/index.js"
     },
+    "./sg": {
+      "types": "./dist/sg/index.d.ts",
+      "default": "./dist/sg/index.js"
+    },
     "./diagnose": {
       "types": "./dist/diagnose/index.d.ts",
       "default": "./dist/diagnose/index.js"
@@ -69,6 +74,7 @@
     "check": "node scripts/check-toolchain.ts && pnpm typecheck && pnpm lint && pnpm test && pnpm test:tz && pnpm build && pnpm test:compat && node scripts/check-readme-examples.ts && node scripts/check-consumer-types.ts && pnpm fmt:check && node scripts/check-package.ts && node scripts/check-size.ts && node scripts/api-report.ts",
     "verify:cao": "node scripts/verify-cao.ts",
     "verify:govuk": "node scripts/verify-govuk.ts",
+    "verify:datagovsg": "node scripts/verify-datagovsg.ts",
     "prepublishOnly": "pnpm check",
     "release-notes": "node scripts/release-notes.ts",
     "api:update": "pnpm build && node scripts/api-report.ts --update"