bizdays-toolkit 0.13.0 → 0.14.0

package/CHANGELOG.md

@@ -4,6 +4,27 @@
 
 ## [Unreleased]
 
+## [0.14.0] - 2026-10-20
+
+### 移行
+
+動作は変わりません（締め期間と、暦日と時刻から瞬間への変換の追加）。版ごとの作業は [docs/migration.md](./docs/migration.md) にまとめた。
+
+### Added
+
+- 締め日で区切ったときのその月分の期間を返す `closingPeriod(monthOrDate, closingDay)` を追加した（`closingMonth` の逆算。前月の締め日の翌日からその月の締め日まで、両端を含む `{ from, to }`）。暦日を渡すとその日が属する期間。返す値は変更できず、日付の期間の形なので `closedDates` や `listBusinessDays` にそのまま渡せる。締め日がその月にない場合の読み替え（末日）は `closingMonth` と同じ内部関数で行い、期間が隙間も重なりもなく敷き詰められることをテストで確かめた
+- 暦日と時刻（`"HH:mm"` または `"HH:mm:ss"`）からタイムゾーンでの瞬間を `Date` で返す `toInstant(date, time, timeZone)` と、営業日カレンダー・スケジュールのメソッド `instantOf(date, time)`（そのタイムゾーンで。合成したカレンダー・スケジュールからのカレンダーにも付く）を追加した。`civilOf`・`toDateTimeParts` の逆向き。夏時間で存在しない時刻は飛んだ分だけ後ろに、2 回ある時刻は先のほう（Temporal の `disambiguation: "compatible"` と同じ）。`Intl` だけで実装し、オフセットの差が 1 時間でないゾーン（`Australia/Lord_Howe`）と南半球（`Pacific/Auckland`）でも確かめた。受け付けるのは暦日の文字列だけ（`invalid-date`）。時刻の誤りは `invalid-time`
+
+### Changed
+
+- README: 月のヘルパーの節に `closingPeriod` を、日付・日時の入力の節に `toInstant`・`instantOf` と夏時間の例を足した。サイズの値を測り直した（ルート約 9.3KB・日本の祝日込み約 11.1KB・英国の祝日込み約 11.1KB。0.14.0 で測定）
+- `docs/decisions.md`: 39 番（`closingPeriod`）・40 番（`toInstant`）を追加した
+- `src/core/schedule.ts` の `buildSchedule` の注釈の位置を直した（0.13.0 で関数の間に別の定義が入り、注釈が離れていた。動作は変わらない）
+
+### 開発
+
+- サイズの上限（`size-limits.json`）を上げた。ルート 20,500 → 22,000、`./jp` 23,500 → 25,000、`./diagnose` 27,000 → 28,500（gzip）。`closingPeriod` と瞬間への変換（ルートで約 1.3KB）のため。0.13.0 で上限に近づいていた分も含めて余裕を持たせた
+
 ## [0.13.0] - 2026-10-20
 
 ### 移行
@@ -352,7 +373,8 @@
 
 - 日本: 2026 年 2 月の官報（2027 年の春分・秋分の日）まで反映（`dataVersion: "2026-02"`、`confirmedThrough: 2027`）
 
-[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.13.0...HEAD
+[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.14.0...HEAD
+[0.14.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.13.0...v0.14.0
 [0.13.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.12.0...v0.13.0
 [0.12.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.11.1...v0.12.0
 [0.11.1]: https://github.com/inohan77/bizdays-toolkit/compare/v0.11.0...v0.11.1

package/README.md

@@ -28,7 +28,7 @@ A business-day calendar that combines public holidays with company or store clos
 - **A calendar from a schedule**: `createCalendarFromSchedule` turns a schedule such as store hours into a business-day calendar, so the hours are the only configuration and business-day arithmetic works on them
 - **Combining calendars**: `combineCalendars` builds a calendar of the days on which all of several calendars are open (your company and the bank, for a remittance date) or any of them is open (any of several stores), and business-day arithmetic works on the result
 - **Time-zone safe**: instants such as `Date` are converted to a civil date in the calendar's time zone (`Asia/Tokyo` for Japan, `Europe/London` for the UK) before evaluation. A server running in UTC does not treat 00:00–09:00 in Japan as the previous day
-- **Lightweight, zero dependencies**: about 9.0 KB min+gzip (about 10.8 KB with Japanese holidays, about 10.7 KB with UK bank holidays; measured for 0.13.0). ESM, bundled types and `sideEffects: false`. Written in standard JavaScript and `Intl` only (no Node.js APIs); CI tests it on Node.js, Chrome, Firefox, Edge, Safari and Cloudflare Workers
+- **Lightweight, zero dependencies**: about 9.3 KB min+gzip (about 11.1 KB with Japanese holidays, about 11.1 KB with UK bank holidays; measured for 0.14.0). ESM, bundled types and `sideEffects: false`. Written in standard JavaScript and `Intl` only (no Node.js APIs); CI tests it on Node.js, Chrome, Firefox, Edge, Safari and Cloudflare Workers
 - **Extensible to other countries and regions**: holiday providers are pluggable through the `HolidayProvider` interface. Japan and the UK are bundled
 
 ## Installation
@@ -397,6 +397,15 @@ calendar.dueDate(monthOf(billing, 1), { day: -1, convention: "preceding" }); //
 
 - `monthOf(dateOrMonth, offset?)`: the month `offset` months after (before, if negative) a date or a month `"YYYY-MM"`
 - `closingMonth(date, closingDay)`: the month a date belongs to when months are closed on `closingDay` (1–31, `-1` for the last day). The day after a closing day up to the next closing day belongs to the month of the next closing day. If the closing day does not exist in a month (closing on the 31st in February), the last day is used
+- `closingPeriod(monthOrDate, closingDay)`: the inverse: the period `{ from, to }` (both ends included) that belongs to the month, from the day after the previous closing day to the closing day. Given a date, the period that date belongs to. The result has the shape of a date range, so it can go straight into `closedDates` or `listBusinessDays`
+
+```ts
+closingPeriod("2026-11", 20); // { from: "2026-10-21", to: "2026-11-20" }
+closingPeriod("2026-03", 31); // { from: "2026-03-01", to: "2026-03-31" } (closing on the 31st in February means the 28th)
+const { from, to } = closingPeriod("2026-11-05", 20); // the period "2026-11-05" belongs to
+const office = createCalendar({ holidays: jp, closedWeekdays: [0, 6] });
+office.listBusinessDays(from, to).length; // 22 (business days in the November period)
+```
 
 The `day` of `dueDate` also maps days that do not exist in a month (such as February 30) to the last day. Recurring rules (`{ day: 31 }`) do not match such days, so the two behave differently: a due date must always fall somewhere in its month.
 
@@ -495,6 +504,26 @@ Temporal objects are recognized by their shape, so the package does not depend o
 
 The calendar's time zone is the `timeZone` option, then the holiday provider's time zone, then `"UTC"`.
 
+**From a civil date and time to an instant**: `toInstant(date, time, timeZone)` and `calendar.instantOf(date, time)` (also on schedules) go the other way from `civilOf`: a civil date `"YYYY-MM-DD"` and a time `"HH:mm"` or `"HH:mm:ss"` become a `Date` for that instant in the time zone. Only a date string is accepted (a `Date` would be ambiguous about which day it means), and the result is a `Date`, which is one line from an ISO string (`.toISOString()`) or a Temporal `Instant` (`Temporal.Instant.fromEpochMilliseconds(d.getTime())`).
+
+```ts
+import { toInstant } from "bizdays-toolkit";
+
+toInstant("2026-11-23", "10:00", "Asia/Tokyo").toISOString(); // "2026-11-23T01:00:00.000Z"
+const store = createCalendar({ holidays: jp, closedWeekdays: [0] });
+const opensAt = store.instantOf(store.nextBusinessDay(store.today()), "10:00"); // the next opening, as a Date
+```
+
+Around daylight-saving changes the result follows Temporal's default (`disambiguation: "compatible"`): a time that does not exist (in the UK, 01:00–01:59 on the last Sunday of March) is moved forward by the length of the gap, and a time that occurs twice (01:00–01:59 on the last Sunday of October) is the earlier one.
+
+```ts
+import { england } from "bizdays-toolkit/uk";
+
+const uk = createCalendar({ holidays: england });
+uk.instantOf("2026-03-29", "01:30").toISOString(); // "2026-03-29T01:30:00.000Z" (02:30 BST; 01:30 does not exist)
+uk.instantOf("2026-10-25", "01:30").toISOString(); // "2026-10-25T00:30:00.000Z" (the first 01:30, still BST)
+```
+
 ### Holidays of other countries and regions
 
 Implement `HolidayProvider` and pass it as `holidays`. Several providers give their union (if their time zones differ, `timeZone` is required).

package/dist/core/calendar.js

@@ -249,6 +249,7 @@ function buildCalendar(lookup, isOpen, info, maxSearchDays) {
         outOfRange: lookup.outOfRange,
         dateOf,
         civilOf: lookup.civilOf,
+        instantOf: lookup.instantOf,
         today: lookup.today,
         isHoliday: lookup.isHoliday,
         getHoliday: lookup.getHoliday,

package/dist/core/input.d.ts

@@ -82,5 +82,21 @@ export declare function toDateString(input: DateInput, timeZone: string): DateSt
 export declare function toDateTimeParts(input: DateTimeInput, timeZone: string): CivilDateTimeParts<string>;
 /** @public */
 export declare function toDateTimeParts(input: DateInput, timeZone: string): CivilDateTimeParts;
+/**
+ * @internal 暦日と時刻（0 時からの経過分）から、タイムゾーンでの瞬間（エポックミリ秒）を求める。
+ * 夏時間の扱いは Temporal の disambiguation: "compatible" と同じ。存在しない時刻（飛び）は切り替え前のオフセットで解釈して
+ * 飛んだ分だけ後ろの瞬間に、2 回ある時刻（重複）は先のほう（切り替え前のオフセット）にする。
+ * Intl 以外に依存しないよう、前後 1 日のオフセットを候補にして、暦日に戻して一致するものを選ぶ
+ */
+export declare function civilToInstant(date: DateString, minutes: number, timeZone: string): number;
+/** @internal "HH:mm" または "HH:mm:ss" を 0 時からの経過秒に変換する（00:00:00〜23:59:59） */
+export declare function parseTimeOfDaySeconds(value: unknown): number;
+/**
+ * 暦日と時刻（"HH:mm" または "HH:mm:ss"）から、タイムゾーンでのその瞬間を Date で返す（civilOf・toDateTimeParts の逆向き）。
+ * 夏時間の切り替えで存在しない時刻は、飛んだ分だけ後ろの瞬間（英国の 3 月の 01:30 は 02:30 BST）、2 回ある時刻は先のほう
+ * （Temporal の disambiguation: "compatible" と同じ）。
+ * @public
+ */
+export declare function toInstant(date: DateString, time: string, timeZone: string): Date;
 /** @internal "HH:mm" を 0 時からの経過分に変換する（00:00〜23:59） */
 export declare function parseTimeOfDay(value: string): number;

package/dist/core/input.js

@@ -143,6 +143,56 @@ export function toDateTimeParts(input, timeZone) {
         : `${String(Math.floor(civil.minutes / 60)).padStart(2, "0")}:${String(civil.minutes % 60).padStart(2, "0")}`;
     return Object.freeze({ date: civil.date, time });
 }
+/**
+ * @internal 暦日と時刻（0 時からの経過分）から、タイムゾーンでの瞬間（エポックミリ秒）を求める。
+ * 夏時間の扱いは Temporal の disambiguation: "compatible" と同じ。存在しない時刻（飛び）は切り替え前のオフセットで解釈して
+ * 飛んだ分だけ後ろの瞬間に、2 回ある時刻（重複）は先のほう（切り替え前のオフセット）にする。
+ * Intl 以外に依存しないよう、前後 1 日のオフセットを候補にして、暦日に戻して一致するものを選ぶ
+ */
+export function civilToInstant(date, minutes, timeZone) {
+    const { year, month, day } = parseDate(date);
+    const wall = Date.UTC(year, month - 1, day, Math.floor(minutes / 60), minutes % 60);
+    const offsetAt = (ms) => {
+        const civil = instantToCivil(ms, timeZone);
+        const c = parseDate(civil.date);
+        const m = civil.minutes ?? 0; // 瞬間からの変換では時刻が必ずある
+        return Date.UTC(c.year, c.month - 1, c.day, Math.floor(m / 60), m % 60) - ms;
+    };
+    const before = offsetAt(wall - 86_400_000);
+    const after = offsetAt(wall + 86_400_000);
+    const valid = (ms) => {
+        const civil = instantToCivil(ms, timeZone);
+        return civil.date === date && civil.minutes === minutes;
+    };
+    const candidates = before === after ? [wall - before] : [wall - before, wall - after];
+    const found = candidates.filter(valid);
+    // 重複なら先のほう（小さいミリ秒）、飛びなら切り替え前のオフセット（before）で解釈した瞬間
+    return found.length > 0 ? Math.min(...found) : wall - before;
+}
+/** @internal "HH:mm" または "HH:mm:ss" を 0 時からの経過秒に変換する（00:00:00〜23:59:59） */
+export function parseTimeOfDaySeconds(value) {
+    const m = typeof value === "string" ? /^(\d{2}):(\d{2})(?::(\d{2}))?$/.exec(value) : null;
+    const seconds = m ? Number(m[3] ?? "0") : NaN;
+    if (!m || seconds > 59) {
+        throw rangeError("invalid-time", `Invalid time of day: ${JSON.stringify(value)} (expected HH:mm or HH:mm:ss)`);
+    }
+    return wallTime(Number(m[1]), Number(m[2])) * 60 + seconds;
+}
+/**
+ * 暦日と時刻（"HH:mm" または "HH:mm:ss"）から、タイムゾーンでのその瞬間を Date で返す（civilOf・toDateTimeParts の逆向き）。
+ * 夏時間の切り替えで存在しない時刻は、飛んだ分だけ後ろの瞬間（英国の 3 月の 01:30 は 02:30 BST）、2 回ある時刻は先のほう
+ * （Temporal の disambiguation: "compatible" と同じ）。
+ * @public
+ */
+export function toInstant(date, time, timeZone) {
+    const zone = validateTimeZone(timeZone);
+    if (typeof date !== "string")
+        throw typeError("invalid-date", `Invalid date: ${String(date)}`);
+    parseDate(date);
+    const seconds = parseTimeOfDaySeconds(time);
+    const ms = civilToInstant(date, Math.floor(seconds / 60), zone) + (seconds % 60) * 1000;
+    return new Date(ms);
+}
 /** @internal "HH:mm" を 0 時からの経過分に変換する（00:00〜23:59） */
 export function parseTimeOfDay(value) {
     const m = /^(\d{2}):(\d{2})$/.exec(value);

package/dist/core/month.d.ts

@@ -48,3 +48,20 @@ export declare function monthOf(input: DateString | MonthString, offset?: number
  * @public
  */
 export declare function closingMonth(date: DateString, closingDay: number): MonthString;
+/**
+ * 締め日で区切ったときの、その月分の期間（両端を含む暦日）。closingMonth の逆算。
+ *
+ * 前月の締め日の翌日から、その月の締め日まで。月の代わりに暦日を渡すと、その日が属する期間（closingMonth で求めた月の期間）。
+ * 返す値は変更できず、name は付かない（DateRange の形なので、そのまま closedDates などに渡せる）。
+ *
+ * @example
+ * closingPeriod("2026-11", 20); // { from: "2026-10-21", to: "2026-11-20" }
+ * closingPeriod("2026-10", -1); // { from: "2026-10-01", to: "2026-10-31" }（末日締め）
+ * closingPeriod("2026-03", 31); // { from: "2026-03-01", to: "2026-03-31" }（2 月の 31 日締めは 2 月末日）
+ * closingPeriod("2026-11-05", 20); // { from: "2026-10-21", to: "2026-11-20" }（この日が属する期間）
+ * @public
+ */
+export declare function closingPeriod(input: DateString | MonthString, closingDay: number): {
+    readonly from: DateString;
+    readonly to: DateString;
+};

package/dist/core/month.js

@@ -4,7 +4,7 @@
  * 営業日を考えない暦の計算なので、カレンダーなしで使える。営業日を考えた月の計算
  * （月の第 n 営業日・期日）は営業日カレンダーのメソッドにある。
  */
-import { daysInMonth, formatDate, parseDate } from "./date.js";
+import { addDays, daysInMonth, formatDate, parseDate } from "./date.js";
 import { rangeError } from "./errors.js";
 const MONTH_RE = /^(\d{4})-(\d{2})$/;
 /** @internal "YYYY-MM" を年と月に分解する（誤りは code: "invalid-month"） */
@@ -67,10 +67,40 @@ export function monthOf(input, offset = 0) {
  * @public
  */
 export function closingMonth(date, closingDay) {
+    checkClosingDay(closingDay);
+    const { year, month, day } = parseDate(date);
+    return formatMonth(shiftMonth({ year, month }, day <= closingDayIn({ year, month }, closingDay) ? 0 : 1));
+}
+function checkClosingDay(closingDay) {
     if (!isDayOfMonthValue(closingDay)) {
         throw rangeError("invalid-argument", `closingDay must be an integer from 1 to 31, or -1 (last day): ${closingDay}`);
     }
-    const { year, month, day } = parseDate(date);
-    const closing = closingDay === -1 ? daysInMonth(year, month) : closingDay;
-    return formatMonth(shiftMonth({ year, month }, day <= closing ? 0 : 1));
+}
+/** その月の締め日（日）。-1 またはその月の日数以上なら末日（decisions.md の 16 番の読み替えはここだけで行う） */
+function closingDayIn({ year, month }, closingDay) {
+    const last = daysInMonth(year, month);
+    return closingDay === -1 || closingDay > last ? last : closingDay;
+}
+/**
+ * 締め日で区切ったときの、その月分の期間（両端を含む暦日）。closingMonth の逆算。
+ *
+ * 前月の締め日の翌日から、その月の締め日まで。月の代わりに暦日を渡すと、その日が属する期間（closingMonth で求めた月の期間）。
+ * 返す値は変更できず、name は付かない（DateRange の形なので、そのまま closedDates などに渡せる）。
+ *
+ * @example
+ * closingPeriod("2026-11", 20); // { from: "2026-10-21", to: "2026-11-20" }
+ * closingPeriod("2026-10", -1); // { from: "2026-10-01", to: "2026-10-31" }（末日締め）
+ * closingPeriod("2026-03", 31); // { from: "2026-03-01", to: "2026-03-31" }（2 月の 31 日締めは 2 月末日）
+ * closingPeriod("2026-11-05", 20); // { from: "2026-10-21", to: "2026-11-20" }（この日が属する期間）
+ * @public
+ */
+export function closingPeriod(input, closingDay) {
+    checkClosingDay(closingDay);
+    const month = typeof input === "string" && input.split("-").length === 3
+        ? parseMonth(closingMonth(input, closingDay))
+        : parseMonth(input);
+    const previous = shiftMonth(month, -1);
+    const to = dayOfMonth(month, closingDayIn(month, closingDay));
+    const from = addDays(dayOfMonth(previous, closingDayIn(previous, closingDay)), 1);
+    return Object.freeze({ from, to });
 }

package/dist/core/schedule.d.ts

@@ -283,6 +283,11 @@ export interface HolidayLookup<Kind extends string = string> {
     /** 入力をタイムゾーンでの暦日と時刻に変換する */
     civilOf(input: DateTimeInput): CivilDateTimeParts<string>;
     civilOf(input: DateInput): CivilDateTimeParts;
+    /**
+     * 暦日 "YYYY-MM-DD" と時刻（"HH:mm" または "HH:mm:ss"）から、タイムゾーンでのその瞬間を Date で返す（civilOf の逆向き）。
+     * 夏時間で存在しない時刻は飛んだ分だけ後ろに、2 回ある時刻は先のほう（toInstant と同じ）
+     */
+    instantOf(date: DateString, time: string): Date;
     /** 今日の日付（タイムゾーン） */
     today(now?: Date): DateString;
     /** 祝日か */
@@ -431,6 +436,7 @@ export declare function createResolver<T, Kind extends string>(compiled: Compile
 export declare function mapDays<R>(from: DateString, to: DateString, fn: (date: DateString) => R): readonly R[];
 /** @internal スケジュールの内部の判定を取り出す（createSchedule が作ったものでなければ undefined） */
 export declare function infoOfSchedule<T, Kind extends string>(schedule: Schedule<T, Kind>): ((date: DateString) => ScheduleDay<T, Kind>) | undefined;
+/** @internal 検証済みの規則からスケジュールを作る */
 export declare function buildSchedule<T, Kind extends string>(compiled: CompiledSchedule<T, Kind>): Schedule<T, Kind>;
 /**
  * 曜日・祝日・特定日の規則から、日ごとに値を返すスケジュールを作る。

package/dist/core/schedule.js

@@ -19,7 +19,7 @@
  */
 import { addDays, daysInMonth, fromDayNumber, isValidDate, parseDate, toDayNumber, weekdayOf, } from "./date.js";
 import { checkUnknownKeys, IssueCollector, rangeError } from "./errors.js";
-import { instantToCivil, toCivil, toDateTimeParts, validateTimeZone, } from "./input.js";
+import { instantToCivil, toCivil, toDateTimeParts, toInstant, validateTimeZone, } from "./input.js";
 // ------------------------------------------------------------
 // 入力チェック（誤りを集める。作成時は最初の誤りを例外にする）
 // ------------------------------------------------------------
@@ -577,6 +577,7 @@ export function createHolidayLookup(source) {
         holidayOn,
         dateOf,
         civilOf: ((input) => toDateTimeParts(input, timeZone)),
+        instantOf: (date, time) => toInstant(date, time, timeZone),
         today: (now = new Date()) => instantToCivil(now.getTime(), timeZone).date,
         isHoliday: (input) => holidayOn(dateOf(input)) !== undefined,
         getHoliday: (input) => holidayOn(dateOf(input)),
@@ -773,7 +774,6 @@ export function mapDays(from, to, fn) {
         result.push(fn(fromDayNumber(n)));
     return Object.freeze(result);
 }
-/** @internal 検証済みの規則からスケジュールを作る */
 /**
  * @internal スケジュールの内部の判定（暦日の文字列を直接受け取る）。createCalendarFromSchedule が、公開メソッド
  * （入力の解析を通る）を経由せずに 1 日分の結果を得るために使う。スケジュールごとに作成時に登録する
@@ -783,6 +783,7 @@ const internalInfo = new WeakMap();
 export function infoOfSchedule(schedule) {
     return internalInfo.get(schedule);
 }
+/** @internal 検証済みの規則からスケジュールを作る */
 export function buildSchedule(compiled) {
     const lookup = createHolidayLookup(compiled.source);
     const resolve = createResolver(compiled, lookup);
@@ -793,6 +794,7 @@ export function buildSchedule(compiled) {
         outOfRange: lookup.outOfRange,
         dateOf: lookup.dateOf,
         civilOf: lookup.civilOf,
+        instantOf: lookup.instantOf,
         today: lookup.today,
         isHoliday: lookup.isHoliday,
         getHoliday: lookup.getHoliday,

package/dist/index.d.ts

@@ -10,7 +10,7 @@
 export { combineCalendars, createCalendar, createCalendarFromSchedule, type AdjustOptions, type AnnualDate, type AnnualRange, type BusinessDayConvention, type BusinessDayOptions, type Calendar, type CalendarOptions, type CombineOptions, type DateRange, type DayInfo, type DayReason, type DueDateOptions, type HolidayPolicy, type KnownDayReason, type SpecificDate, } from "./core/calendar.ts";
 export { createSchedule, type AnnualRangeValue, type AnnualValue, type CivilDateTimeParts, type DateRangeValue, type DateValue, type DayAfterHolidayPattern, type DayOfMonth, type DayOfMonthPattern, type EffectivePeriod, type HolidayLookup, type HolidayPattern, type HolidaySourceOptions, type HolidayValueRule, type KnownScheduleReason, type Month, type Nth, type OnHolidayRule, type RecurringPattern, type RecurringRule, type RecurringValue, type Schedule, type ScheduleDay, type ScheduleOptions, type ScheduleReason, type WeekdayPattern, } from "./core/schedule.ts";
 export { addDays, diffDays, isValidDate, weekdayOf, type DateString, type Weekday, } from "./core/date.ts";
-export { closingMonth, monthOf, type MonthString } from "./core/month.ts";
+export { closingMonth, closingPeriod, monthOf, type MonthString } from "./core/month.ts";
 export { isBizdaysError, type ErrorCode, type KnownErrorCode } from "./core/errors.ts";
-export { toDateString, toDateTimeParts, type DateInput, type DateTimeInput, type TemporalDateLike, type TemporalDateTimeLike, type TemporalInstantLike, } from "./core/input.ts";
+export { toDateString, toDateTimeParts, toInstant, type DateInput, type DateTimeInput, type TemporalDateLike, type TemporalDateTimeLike, type TemporalInstantLike, } from "./core/input.ts";
 export type { Holiday, HolidayProvider } from "./core/types.ts";

package/dist/index.js

@@ -10,6 +10,6 @@
 export { combineCalendars, createCalendar, createCalendarFromSchedule, } from "./core/calendar.js";
 export { createSchedule, } from "./core/schedule.js";
 export { addDays, diffDays, isValidDate, weekdayOf, } from "./core/date.js";
-export { closingMonth, monthOf } from "./core/month.js";
+export { closingMonth, closingPeriod, monthOf } from "./core/month.js";
 export { isBizdaysError } from "./core/errors.js";
-export { toDateString, toDateTimeParts, } from "./core/input.js";
+export { toDateString, toDateTimeParts, toInstant, } from "./core/input.js";

package/package.json

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