bizdays-toolkit 0.1.2 → 0.3.0

package/dist/core/calendar.js

@@ -8,160 +8,122 @@
  *   4. 祝日            … holidayPolicy に従う（closed: 休業 / open: 営業 / ignore: 判定に使わない）
  *   5. closedWeekdays … 定休日の曜日
  *   6. それ以外は営業日
+ *
+ * 内部では、営業日かどうか（真偽値）を返すスケジュール（createSchedule）として作っている。
  */
-import { addDays, fromDayNumber, parseDate, toDayNumber, weekdayOf, } from "./date.js";
-import { instantToCivil, parseTimeOfDay, toCivil, validateTimeZone, } from "./input.js";
-const MONTH_DAY_RE = /^(\d{2})-(\d{2})$/;
-const MAX_DAYS_IN_MONTH = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-function parseMonthDay(value) {
-    const m = MONTH_DAY_RE.exec(value);
-    const month = Number(m?.[1]);
-    const day = Number(m?.[2]);
-    if (!m || month < 1 || month > 12 || day < 1 || day > MAX_DAYS_IN_MONTH[month - 1]) {
-        throw new RangeError(`Invalid month-day: ${JSON.stringify(value)} (expected MM-DD)`);
+import { addDays, fromDayNumber, toDayNumber } from "./date.js";
+import { checkUnknownKeys, IssueCollector, plainError, rangeError } from "./errors.js";
+import { parseTimeOfDay, toCivil } from "./input.js";
+import { buildSchedule, compileAnnualRules, compileDateRules, compileHolidaySource, isWeekday, } from "./schedule.js";
+const CALENDAR_OPTION_KEYS = [
+    "holidays",
+    "timeZone",
+    "outOfRange",
+    "closedWeekdays",
+    "closedAnnual",
+    "closedDates",
+    "openDates",
+    "holidayPolicy",
+    "maxSearchDays",
+];
+/** @internal 営業日カレンダーの設定を検証して取り込む（誤りは c に集める） */
+export function compileCalendarOptions(c, options) {
+    if (typeof options !== "object" || options === null || Array.isArray(options)) {
+        c.error("invalid-option", "", "options must be an object");
+        return undefined;
     }
-    return value;
-}
-function compileDates(entries, label) {
-    return (entries ?? []).map((e) => {
-        if (typeof e === "string") {
-            const n = toDayNumber(e);
-            return { from: n, to: n, name: undefined };
-        }
-        if ("date" in e) {
-            const n = toDayNumber(e.date);
-            return { from: n, to: n, name: e.name };
-        }
-        const from = toDayNumber(e.from);
-        const to = toDayNumber(e.to);
-        if (from > to)
-            throw new RangeError(`${label}: "from" must not be after "to" (${e.from} > ${e.to})`);
-        return { from, to, name: e.name };
-    });
-}
-function compileAnnual(entries) {
-    return (entries ?? []).map((e) => {
-        if (typeof e === "string") {
-            const md = parseMonthDay(e);
-            return { from: md, to: md, name: undefined };
-        }
-        if ("date" in e) {
-            const md = parseMonthDay(e.date);
-            return { from: md, to: md, name: e.name };
+    const o = options;
+    checkUnknownKeys(c, "", o, CALENDAR_OPTION_KEYS);
+    const source = compileHolidaySource(c, o);
+    const closedWeekdays = new Set();
+    const rawWeekdays = o["closedWeekdays"];
+    if (rawWeekdays !== undefined) {
+        if (!Array.isArray(rawWeekdays)) {
+            c.error("invalid-option", "closedWeekdays", "must be an array");
         }
-        return { from: parseMonthDay(e.from), to: parseMonthDay(e.to), name: e.name };
-    });
-}
-function matchAnnual(rule, monthDay) {
-    return rule.from <= rule.to
-        ? monthDay >= rule.from && monthDay <= rule.to
-        : monthDay >= rule.from || monthDay <= rule.to;
-}
-/** 祝日と休業日の規則から営業日カレンダーを作る */
-export function createCalendar(options = {}) {
-    const providers = Object.freeze(options.holidays === undefined
-        ? []
-        : Array.isArray(options.holidays)
-            ? [...options.holidays]
-            : [options.holidays]);
-    let timeZone;
-    if (options.timeZone !== undefined) {
-        timeZone = validateTimeZone(options.timeZone);
-    }
-    else {
-        const zones = [...new Set(providers.map((p) => validateTimeZone(p.timeZone)))];
-        if (zones.length > 1) {
-            throw new RangeError(`Holiday providers use different time zones (${zones.join(", ")}); specify options.timeZone`);
+        else {
+            rawWeekdays.forEach((w, i) => {
+                if (isWeekday(w))
+                    closedWeekdays.add(w);
+                else
+                    c.error("invalid-weekday", `closedWeekdays[${i}]`, "must be an integer from 0 (Sunday) to 6 (Saturday)");
+            });
         }
-        timeZone = zones[0] ?? "UTC";
     }
-    const closedWeekdays = new Set();
-    for (const w of options.closedWeekdays ?? []) {
-        if (!Number.isInteger(w) || w < 0 || w > 6)
-            throw new RangeError(`Invalid weekday: ${w}`);
-        closedWeekdays.add(w);
+    const holidayPolicy = o["holidayPolicy"] ?? "closed";
+    if (holidayPolicy !== "closed" && holidayPolicy !== "open" && holidayPolicy !== "ignore") {
+        c.error("invalid-option", "holidayPolicy", 'must be "closed", "open" or "ignore"');
     }
-    const closedAnnual = compileAnnual(options.closedAnnual);
-    const closedDates = compileDates(options.closedDates, "closedDates");
-    const openDates = compileDates(options.openDates, "openDates");
-    const holidayPolicy = options.holidayPolicy ?? "closed";
-    if (!["closed", "open", "ignore"].includes(holidayPolicy)) {
-        throw new RangeError(`Invalid holidayPolicy: ${String(holidayPolicy)}`);
-    }
-    const outOfRange = options.outOfRange ?? "throw";
-    const maxSearchDays = options.maxSearchDays ?? 3660;
+    const maxSearchDays = o["maxSearchDays"] ?? 3660;
     if (!Number.isInteger(maxSearchDays) || maxSearchDays < 1) {
-        throw new RangeError(`Invalid maxSearchDays: ${maxSearchDays}`);
+        c.error("invalid-option", "maxSearchDays", "must be a positive integer");
     }
-    const yearCache = new Map();
-    function providerYears(provider, year) {
-        const { from, to } = provider.supportedYears;
-        if (year < from || year > to) {
-            if (outOfRange === "ignore")
-                return [];
-            throw new RangeError(`Holidays for ${provider.id} are supported for ${from}-${to}; requested ${year}`);
-        }
-        return provider.holidaysInYear(year);
-    }
-    function holidayMap(year) {
-        let map = yearCache.get(year);
-        if (!map) {
-            map = new Map();
-            for (const provider of providers) {
-                for (const h of providerYears(provider, year)) {
-                    // 同じ日に複数の提供元の祝日がある場合は、先に渡した提供元を優先する
-                    if (!map.has(h.date))
-                        map.set(h.date, h);
-                }
+    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);
+    return {
+        schedule: {
+            source,
+            weekly: Object.freeze([0, 1, 2, 3, 4, 5, 6].map((w) => !closedWeekdays.has(w))),
+            holiday: holidayPolicy === "ignore" ? "weekday" : { value: holidayPolicy === "open" },
+            annual,
+            // 臨時営業日を先に並べて、臨時休業日より優先する
+            dates: [...open, ...closed],
+        },
+        maxSearchDays: Number.isInteger(maxSearchDays) ? maxSearchDays : 3660,
+    };
+}
+/**
+ * 祝日と休業日の規則から営業日カレンダーを作る。
+ *
+ * 設定は作る時点で取り込まれるので、あとから元の配列を書き換えても結果は変わらない。
+ * 設定の誤りは code 付きの RangeError になる。
+ * @public
+ */
+export function createCalendar(options = {}) {
+    const c = new IssueCollector();
+    const compiled = compileCalendarOptions(c, options);
+    c.throwFirstError();
+    const { maxSearchDays } = compiled;
+    const schedule = buildSchedule(compiled.schedule);
+    function info(date) {
+        const day = schedule.dayInfo(date);
+        let reason;
+        // 内部では閉じた型（KnownScheduleReason）で分岐し、値が増えたときの対応漏れを型で検出する
+        const known = day.reason;
+        switch (known) {
+            case "date":
+                reason = day.value ? "open-date" : "closed-date";
+                break;
+            case "annual":
+                reason = "closed-annual";
+                break;
+            case "holiday":
+                reason = "holiday";
+                break;
+            case "weekday":
+                reason = day.value ? "regular" : "closed-weekday";
+                break;
+            default: {
+                const unreachable = known;
+                throw plainError("invalid-option", `Unexpected schedule reason: ${String(unreachable)}`);
             }
-            yearCache.set(year, map);
         }
-        return map;
-    }
-    const dateOf = (input) => toCivil(input, timeZone).date;
-    function holidayOn(date) {
-        if (providers.length === 0)
-            return undefined;
-        return holidayMap(parseDate(date).year).get(date);
-    }
-    function findRule(rules, dayNumber) {
-        return rules.find((r) => dayNumber >= r.from && dayNumber <= r.to);
-    }
-    function info(date) {
-        const dayNumber = toDayNumber(date);
-        const weekday = weekdayOf(date);
-        const holiday = holidayOn(date);
-        const make = (businessDay, reason, name) => {
-            const result = {
-                date,
-                weekday,
-                businessDay,
-                reason,
-            };
-            if (name !== undefined)
-                result.name = name;
-            if (holiday !== undefined)
-                result.holiday = holiday;
-            return Object.freeze(result);
+        const result = {
+            date: day.date,
+            weekday: day.weekday,
+            businessDay: day.value,
+            reason,
         };
-        const open = findRule(openDates, dayNumber);
-        if (open)
-            return make(true, "open-date", open.name);
-        const closed = findRule(closedDates, dayNumber);
-        if (closed)
-            return make(false, "closed-date", closed.name);
-        const monthDay = date.slice(5);
-        const annual = closedAnnual.find((r) => matchAnnual(r, monthDay));
-        if (annual)
-            return make(false, "closed-annual", annual.name);
-        if (holiday && holidayPolicy !== "ignore") {
-            return make(holidayPolicy === "open", "holiday", holiday.name);
-        }
-        if (closedWeekdays.has(weekday))
-            return make(false, "closed-weekday", undefined);
-        return make(true, "regular", undefined);
+        // 曜日で決まった日には名前を付けない（祝日名は holiday で分かる）
+        if (day.name !== undefined && day.reason !== "weekday")
+            result.name = day.name;
+        if (day.holiday !== undefined)
+            result.holiday = day.holiday;
+        return Object.freeze(result);
     }
-    const isOpen = (date) => info(date).businessDay;
+    const isOpen = (date) => schedule.valueOn(date);
+    const dateOf = schedule.dateOf;
     function search(start, step) {
         let n = toDayNumber(start);
         for (let i = 0; i < maxSearchDays; i++, n += step) {
@@ -169,14 +131,7 @@ export function createCalendar(options = {}) {
             if (isOpen(date))
                 return date;
         }
-        throw new Error(`No business day found within ${maxSearchDays} days from ${start}`);
-    }
-    function ordered(from, to) {
-        const a = dateOf(from);
-        const b = dateOf(to);
-        if (a > b)
-            throw new RangeError(`"from" must not be after "to" (${a} > ${b})`);
-        return [a, b];
+        throw plainError("no-business-day", `No business day found within ${maxSearchDays} days from ${start}`);
     }
     function countOpen(from, toExclusive) {
         let count = 0;
@@ -186,33 +141,21 @@ export function createCalendar(options = {}) {
         return count;
     }
     const calendar = {
-        timeZone,
-        providers,
+        timeZone: schedule.timeZone,
+        providers: schedule.providers,
         dateOf,
-        today: (now = new Date()) => instantToCivil(now.getTime(), timeZone).date,
-        isHoliday: (input) => holidayOn(dateOf(input)) !== undefined,
-        getHoliday: (input) => holidayOn(dateOf(input)),
-        holidaysInYear(year) {
-            if (!Number.isInteger(year))
-                throw new RangeError(`Invalid year: ${year}`);
-            return Object.freeze([...holidayMap(year).values()].sort((a, b) => a.date < b.date ? -1 : a.date > b.date ? 1 : 0));
-        },
-        holidaysBetween(from, to) {
-            const [a, b] = ordered(from, to);
-            const result = [];
-            for (let y = parseDate(a).year; y <= parseDate(b).year; y++) {
-                for (const h of calendar.holidaysInYear(y))
-                    if (h.date >= a && h.date <= b)
-                        result.push(h);
-            }
-            return Object.freeze(result);
-        },
+        civilOf: schedule.civilOf,
+        today: schedule.today,
+        isHoliday: schedule.isHoliday,
+        getHoliday: schedule.getHoliday,
+        holidaysInYear: schedule.holidaysInYear,
+        holidaysBetween: schedule.holidaysBetween,
         dayInfo: (input) => info(dateOf(input)),
         isBusinessDay: (input) => isOpen(dateOf(input)),
         nextBusinessDay: (input) => search(addDays(dateOf(input), 1), 1),
         previousBusinessDay: (input) => search(addDays(dateOf(input), -1), -1),
         businessDayOnOrAfter(input, opts = {}) {
-            const civil = toCivil(input, timeZone);
+            const civil = toCivil(input, schedule.timeZone);
             let start = civil.date;
             if (opts.cutoff !== undefined) {
                 const cutoff = parseTimeOfDay(opts.cutoff);
@@ -224,7 +167,7 @@ export function createCalendar(options = {}) {
         businessDayOnOrBefore: (input) => search(dateOf(input), -1),
         addBusinessDays(input, n) {
             if (!Number.isInteger(n))
-                throw new RangeError(`n must be an integer: ${n}`);
+                throw rangeError("invalid-argument", `n must be an integer: ${n}`);
             let date = dateOf(input);
             if (n === 0)
                 return search(date, 1);
@@ -240,7 +183,10 @@ export function createCalendar(options = {}) {
             return a <= b ? countOpen(a, b) : -countOpen(b, a);
         },
         listBusinessDays(from, to) {
-            const [a, b] = ordered(from, to);
+            const a = dateOf(from);
+            const b = dateOf(to);
+            if (a > b)
+                throw rangeError("invalid-range", `"from" must not be after "to" (${a} > ${b})`);
             const result = [];
             for (let n = toDayNumber(a); n <= toDayNumber(b); n++) {
                 const date = fromDayNumber(n);

package/dist/core/date.d.ts

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

package/dist/core/date.js

@@ -4,6 +4,7 @@
  * 日付は常に "YYYY-MM-DD" 文字列で扱い、内部では 1970-01-01 からの日数（day number）に
  * 変換して計算する。Date オブジェクトのローカル時刻は使わない。
  */
+import { rangeError } from "./errors.js";
 const DATE_RE = /^(\d{4})-(\d{2})-(\d{2})$/;
 const MS_PER_DAY = 86_400_000;
 const MONTH_DAYS = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
@@ -11,17 +12,20 @@ const MONTH_DAYS = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
 export function parseDate(value) {
     const m = DATE_RE.exec(value);
     if (!m) {
-        throw new RangeError(`Invalid date string: ${JSON.stringify(value)} (expected YYYY-MM-DD)`);
+        throw rangeError("invalid-date", `Invalid date string: ${JSON.stringify(value)} (expected YYYY-MM-DD)`);
     }
     const year = Number(m[1]);
     const month = Number(m[2]);
     const day = Number(m[3]);
     if (year < 1000 || month < 1 || month > 12 || day < 1 || day > daysInMonth(year, month)) {
-        throw new RangeError(`Invalid date: ${value}`);
+        throw rangeError("invalid-date", `Invalid date: ${value}`);
     }
     return { year, month, day };
 }
-/** "YYYY-MM-DD" として正しい暦日か */
+/**
+ * "YYYY-MM-DD" として正しい暦日か。
+ * @public
+ */
 export function isValidDate(value) {
     if (typeof value !== "string")
         return false;
@@ -36,7 +40,7 @@ export function isValidDate(value) {
 /** 年月日から "YYYY-MM-DD" を作る（範囲外なら RangeError） */
 export function formatDate(year, month, day) {
     if (!Number.isInteger(year) || year < 1000 || year > 9999) {
-        throw new RangeError(`Year out of range (1000-9999): ${year}`);
+        throw rangeError("out-of-range", `Year out of range (1000-9999): ${year}`);
     }
     const s = `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
     parseDate(s);
@@ -52,7 +56,7 @@ export function daysInMonth(year, month) {
         return isLeapYear(year) ? 29 : 28;
     const days = MONTH_DAYS[month - 1];
     if (days === undefined)
-        throw new RangeError(`Invalid month: ${month}`);
+        throw rangeError("invalid-date", `Invalid month: ${month}`);
     return days;
 }
 /** 1970-01-01 からの日数 */
@@ -65,17 +69,27 @@ export function fromDayNumber(dayNumber) {
     const d = new Date(dayNumber * MS_PER_DAY);
     return formatDate(d.getUTCFullYear(), d.getUTCMonth() + 1, d.getUTCDate());
 }
-/** n 日後（負なら前）の日付 */
+/**
+ * n 日後（負なら前）の日付。
+ * @public
+ */
 export function addDays(date, days) {
-    if (!Number.isInteger(days))
-        throw new RangeError(`days must be an integer: ${days}`);
+    if (!Number.isInteger(days)) {
+        throw rangeError("invalid-argument", `days must be an integer: ${days}`);
+    }
     return fromDayNumber(toDayNumber(date) + days);
 }
-/** from から to までの日数（to が後なら正） */
+/**
+ * from から to までの日数（to が後なら正）。
+ * @public
+ */
 export function diffDays(from, to) {
     return toDayNumber(to) - toDayNumber(from);
 }
-/** 曜日（0 = 日曜日） */
+/**
+ * 曜日（0 = 日曜日）。
+ * @public
+ */
 export function weekdayOf(date) {
     // 1970-01-01 は木曜日（4）
     return ((((toDayNumber(date) + 4) % 7) + 7) % 7);

package/dist/core/errors.d.ts

@@ -0,0 +1,78 @@
+/**
+ * コード付きの例外と、入力の問題を集める仕組み。
+ *
+ * 例外は従来どおり RangeError・TypeError・Error のインスタンスで、code プロパティを持つ。
+ * 例外のメッセージの文言は API に含まない（変わることがある）。判定には code を使う。
+ */
+/**
+ * 既知のエラーコード（増えることがある）。
+ * @public
+ */
+export type KnownErrorCode = 
+/** 日付 "YYYY-MM-DD" の形式・値の誤り */
+"invalid-date"
+/** 毎年の月日 "MM-DD" の形式・値の誤り */
+ | "invalid-month-day"
+/** 時刻・日時の形式・値の誤り */
+ | "invalid-time"
+/** 受け付けない種類の入力 */
+ | "invalid-input"
+/** IANA タイムゾーン名の誤り */
+ | "invalid-time-zone"
+/** 期間の開始が終了より後 */
+ | "invalid-range"
+/** 曜日の番号（0〜6）の誤り */
+ | "invalid-weekday"
+/** 引数の値の誤り（整数でない日数など） */
+ | "invalid-argument"
+/** 設定の値の誤り */
+ | "invalid-option"
+/** 祝日の提供元どうしのタイムゾーンが異なり、timeZone の指定が必要 */
+ | "time-zone-conflict"
+/** 対応している年の範囲の外 */
+ | "out-of-range"
+/** 祝日の提供元の形式の誤り */
+ | "invalid-provider"
+/** 祝日の提供元が返したデータの誤り */
+ | "invalid-provider-data"
+/** 指定した日数の範囲に営業日がない */
+ | "no-business-day";
+/**
+ * エラーコード。将来の版で値が増えることがある。
+ * @public
+ */
+export type ErrorCode = KnownErrorCode | (string & {});
+/**
+ * このライブラリが投げた例外（code 付き）か。
+ * @public
+ */
+export declare function isBizdaysError(error: unknown): error is Error & {
+    readonly code: ErrorCode;
+};
+/** @internal */
+export declare function rangeError(code: KnownErrorCode, message: string): RangeError;
+/** @internal */
+export declare function typeError(code: KnownErrorCode, message: string): TypeError;
+/** @internal */
+export declare function plainError(code: KnownErrorCode, message: string): Error;
+/** @internal 問題の重さ */
+export type IssueSeverity = "error" | "warning" | "info";
+/** @internal 設定の問題 1 件 */
+export interface Issue {
+    readonly severity: IssueSeverity;
+    readonly code: string;
+    /** 設定の中の位置（例: "dates[1].from"） */
+    readonly path: string;
+    readonly message: string;
+}
+/** @internal 問題を集める */
+export declare class IssueCollector {
+    readonly issues: Issue[];
+    error(code: KnownErrorCode, path: string, message: string): void;
+    warning(code: string, path: string, message: string): void;
+    get hasErrors(): boolean;
+    /** 最初の誤りを例外にして投げる（誤りがなければ何もしない） */
+    throwFirstError(): void;
+}
+/** @internal 設定のオブジェクトに、知らないキーがあれば警告として記録する */
+export declare function checkUnknownKeys(collector: IssueCollector, path: string, value: object, known: readonly string[]): void;

package/dist/core/errors.js

@@ -0,0 +1,61 @@
+/**
+ * コード付きの例外と、入力の問題を集める仕組み。
+ *
+ * 例外は従来どおり RangeError・TypeError・Error のインスタンスで、code プロパティを持つ。
+ * 例外のメッセージの文言は API に含まない（変わることがある）。判定には code を使う。
+ */
+/**
+ * このライブラリが投げた例外（code 付き）か。
+ * @public
+ */
+export function isBizdaysError(error) {
+    return (error instanceof Error &&
+        typeof error.code === "string" &&
+        error.bizdays === true);
+}
+function withCode(error, code) {
+    Object.defineProperty(error, "code", { value: code, enumerable: true });
+    Object.defineProperty(error, "bizdays", { value: true, enumerable: false });
+    return error;
+}
+/** @internal */
+export function rangeError(code, message) {
+    return withCode(new RangeError(message), code);
+}
+/** @internal */
+export function typeError(code, message) {
+    return withCode(new TypeError(message), code);
+}
+/** @internal */
+export function plainError(code, message) {
+    return withCode(new Error(message), code);
+}
+/** @internal 問題を集める */
+export class IssueCollector {
+    issues = [];
+    error(code, path, message) {
+        this.issues.push({ severity: "error", code, path, message });
+    }
+    warning(code, path, message) {
+        this.issues.push({ severity: "warning", code, path, message });
+    }
+    get hasErrors() {
+        return this.issues.some((i) => i.severity === "error");
+    }
+    /** 最初の誤りを例外にして投げる（誤りがなければ何もしない） */
+    throwFirstError() {
+        const first = this.issues.find((i) => i.severity === "error");
+        if (!first)
+            return;
+        const message = first.path ? `${first.path}: ${first.message}` : first.message;
+        throw rangeError(first.code, message);
+    }
+}
+/** @internal 設定のオブジェクトに、知らないキーがあれば警告として記録する */
+export function checkUnknownKeys(collector, path, value, known) {
+    for (const key of Object.keys(value)) {
+        if (!known.includes(key)) {
+            collector.warning("unknown-option", path ? `${path}.${key}` : key, `Unknown option ${JSON.stringify(key)} is ignored`);
+        }
+    }
+}