@choice-ui/react 1.3.13 → 1.4.0

package/dist/cjs/components/calendar/dist/index.cjs

@@ -1,4591 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const locale = require("date-fns/locale");
-const React = require("react");
-const usehooksTs = require("usehooks-ts");
-const dateFns = require("date-fns");
-const tz = require("@date-fns/tz");
-const require$$0 = require("react/jsx-runtime");
-const index$1 = require("../../icon-button/dist/index.cjs");
-const iconsReact = require("@choiceform/icons-react");
-const index = require("../../text-field/dist/index.cjs");
-const index$2 = require("../../menus/dist/index.cjs");
-const tcx = require("../../../shared/utils/tcx/tcx.cjs");
-const useMergedValue = require("../../../shared/hooks/use-merged-value/use-merged-value.cjs");
-const useModifierKeys = require("../../../shared/hooks/use-modifier-keys/use-modifier-keys.cjs");
-const usePressMove = require("../../../shared/hooks/use-press/use-press-move.cjs");
-const mergeRefs = require("../../../shared/utils/merge-refs/merge-refs.cjs");
-var TimeZoneCache = class {
-  constructor() {
-    __publicField(this, "cache", /* @__PURE__ */ new Map());
-    __publicField(this, "maxSize", 100);
-  }
-  get(key) {
-    const value = this.cache.get(key);
-    if (value) {
-      this.cache.delete(key);
-      this.cache.set(key, value);
-    }
-    return value;
-  }
-  set(key, value) {
-    if (this.cache.size >= this.maxSize) {
-      const firstKey = this.cache.keys().next().value;
-      if (firstKey) this.cache.delete(firstKey);
-    }
-    this.cache.set(key, value);
-  }
-  clear() {
-    this.cache.clear();
-  }
-};
-var tzDateCache = new TimeZoneCache();
-function createTZDateCached(date, timeZone) {
-  if (!dateFns.isValid(date)) {
-    throw new Error(`Invalid date: ${date}`);
-  }
-  try {
-    const cacheKey = `${date.getTime()}-${timeZone}`;
-    let tzDate = tzDateCache.get(cacheKey);
-    if (!tzDate) {
-      tzDate = tz.tz(timeZone)(date);
-      tzDateCache.set(cacheKey, tzDate);
-    }
-    return tzDate;
-  } catch (error) {
-    console.warn(`Invalid timezone: ${timeZone}, falling back to local timezone`);
-    return date;
-  }
-}
-function createTimeZoneContext(timeZone) {
-  if (!timeZone) return void 0;
-  try {
-    return { in: tz.tz(timeZone) };
-  } catch (error) {
-    console.warn(`Invalid timezone: ${timeZone}, using default context`);
-    return void 0;
-  }
-}
-function isSameDayInTimeZone(date1, date2, timeZone) {
-  if (!dateFns.isValid(date1) || !dateFns.isValid(date2)) return false;
-  if (!timeZone) return dateFns.isSameDay(date1, date2);
-  try {
-    const tz1 = createTZDateCached(date1, timeZone);
-    const tz2 = createTZDateCached(date2, timeZone);
-    return dateFns.isSameDay(tz1, tz2);
-  } catch (error) {
-    console.warn("Date comparison failed, falling back to local timezone:", error);
-    return dateFns.isSameDay(date1, date2);
-  }
-}
-function isWithinRange(date, rangeStart, rangeEnd, timeZone, mode = "date-only") {
-  if (!dateFns.isValid(date) || !dateFns.isValid(rangeStart) || !dateFns.isValid(rangeEnd)) return false;
-  const contextOptions = createTimeZoneContext(timeZone);
-  try {
-    if (mode === "exact-time") {
-      const interval = { start: rangeStart, end: rangeEnd };
-      return dateFns.isWithinInterval(date, interval, contextOptions);
-    } else {
-      const dateStart = dateFns.startOfDay(date, contextOptions);
-      const rangeStartDay = dateFns.startOfDay(rangeStart, contextOptions);
-      const rangeEndDay = dateFns.endOfDay(rangeEnd, contextOptions);
-      const interval = { start: rangeStartDay, end: rangeEndDay };
-      return dateFns.isWithinInterval(dateStart, interval, contextOptions);
-    }
-  } catch (error) {
-    console.warn("Range comparison failed:", error);
-    return false;
-  }
-}
-function getDateParts(date, timeZone) {
-  if (!dateFns.isValid(date)) {
-    throw new Error(`Invalid date: ${date}`);
-  }
-  if (!timeZone) {
-    return {
-      year: date.getFullYear(),
-      month: date.getMonth(),
-      day: date.getDate(),
-      weekday: date.getDay()
-    };
-  }
-  try {
-    const tzDate = createTZDateCached(date, timeZone);
-    return {
-      year: tzDate.getFullYear(),
-      month: tzDate.getMonth(),
-      day: tzDate.getDate(),
-      weekday: tzDate.getDay()
-    };
-  } catch (error) {
-    console.warn("Failed to get date parts with timezone, using local timezone:", error);
-    return {
-      year: date.getFullYear(),
-      month: date.getMonth(),
-      day: date.getDate(),
-      weekday: date.getDay()
-    };
-  }
-}
-function getDateKey(date, timeZone, includeTime = false) {
-  if (!dateFns.isValid(date)) {
-    throw new Error(`Invalid date: ${date}`);
-  }
-  const { year, month, day } = getDateParts(date, timeZone);
-  const dateKey = `${year}-${(month + 1).toString().padStart(2, "0")}-${day.toString().padStart(2, "0")}`;
-  if (!includeTime) return dateKey;
-  const timeKey = timeZone ? createTZDateCached(date, timeZone).toISOString().split("T")[1] : date.toISOString().split("T")[1];
-  return `${dateKey}T${timeKey}`;
-}
-var LOCALE_MAP = {
-  "zh-CN": locale.zhCN,
-  "en-US": locale.enUS,
-  "ja-JP": locale.ja,
-  "ko-KR": locale.ko,
-  "de-DE": locale.de,
-  "fr-FR": locale.fr,
-  "es-ES": locale.es
-};
-function resolveLocale(locale$1) {
-  if (locale$1 && typeof locale$1 === "object" && locale$1.code) {
-    return locale$1;
-  }
-  if (typeof locale$1 === "string") {
-    const mapped = LOCALE_MAP[locale$1];
-    if (mapped) {
-      return mapped;
-    }
-    console.warn(`⚠️ Unknown locale string: ${locale$1}, falling back to zhCN`);
-  }
-  if (locale$1 !== void 0 && locale$1 !== null) {
-    console.warn(`⚠️ Invalid locale type: ${typeof locale$1}, falling back to zhCN`);
-  }
-  return locale.zhCN;
-}
-function isChineseLocale(locale$1) {
-  const resolved = resolveLocale(locale$1);
-  return resolved === locale.zhCN || resolved.code === "zh-CN";
-}
-var dateUtils = {
-  now: () => /* @__PURE__ */ new Date(),
-  isSameDay: dateFns.isSameDay,
-  isSameMonth: dateFns.isSameMonth,
-  isSameYear: dateFns.isSameYear,
-  addMonths: dateFns.addMonths,
-  startOfMonth: dateFns.startOfMonth,
-  endOfMonth: dateFns.endOfMonth,
-  startOfWeek: dateFns.startOfWeek,
-  endOfWeek: dateFns.endOfWeek
-};
-function generateWeekdayNames(locale$1 = locale.zhCN, weekStartsOn = 1) {
-  const safeLocale = resolveLocale(locale$1);
-  const baseSunday = new Date(2024, 0, 7);
-  const weekdays = [];
-  for (let i = 0; i < 7; i++) {
-    const dayIndex = (weekStartsOn + i) % 7;
-    const day = dateFns.addDays(baseSunday, dayIndex);
-    const formatPattern = isChineseLocale(safeLocale) ? "EEEEE" : "EEE";
-    const dayName = dateFns.format(day, formatPattern, { locale: safeLocale });
-    weekdays.push(dayName);
-  }
-  return weekdays;
-}
-function generateCalendarDays(currentMonth, weekStartsOn = 0, fixedGrid = true) {
-  const start = dateFns.startOfWeek(dateFns.startOfMonth(currentMonth), {
-    weekStartsOn
-  });
-  if (fixedGrid) {
-    const end = dateFns.addDays(start, 41);
-    return dateFns.eachDayOfInterval({ start, end });
-  } else {
-    const end = dateFns.endOfWeek(dateFns.endOfMonth(currentMonth), {
-      weekStartsOn
-    });
-    return dateFns.eachDayOfInterval({ start, end });
-  }
-}
-function formatMonthTitle(date, locale$1 = locale.zhCN) {
-  const safeLocale = resolveLocale(locale$1);
-  const formatPattern = isChineseLocale(safeLocale) ? "yyyy年M月" : "MMMM yyyy";
-  return dateFns.format(date, formatPattern, { locale: safeLocale });
-}
-function calculateWeekNumbers(calendarDays, locale$1 = locale.zhCN) {
-  const safeLocale = resolveLocale(locale$1);
-  const weekNumbers = [];
-  for (let i = 0; i < calendarDays.length; i += 7) {
-    const weekFirstDay = calendarDays[i];
-    const weekNumber = dateFns.getWeek(weekFirstDay, {
-      locale: safeLocale,
-      weekStartsOn: 1
-      // ISO周数标准，周一开始
-    });
-    weekNumbers.push(weekNumber);
-  }
-  return weekNumbers;
-}
-function inferSelectionMode(value) {
-  if (value === void 0 || value === null) {
-    return "single";
-  }
-  if (Array.isArray(value)) {
-    return "multiple";
-  }
-  if (typeof value === "object" && "start" in value && "end" in value) {
-    return "range";
-  }
-  return "single";
-}
-function inferMonthFromValue(value) {
-  if (!value) return null;
-  if (value instanceof Date) {
-    return value;
-  }
-  if (Array.isArray(value) && value.length > 0) {
-    return value[value.length - 1];
-  }
-  if (typeof value === "object" && "start" in value) {
-    return value.start;
-  }
-  return null;
-}
-function isCalendarValueEqual(a, b, timeZone, dateComparisonMode = "date-only") {
-  if (a === b) return true;
-  if (!a || !b) return a === b;
-  if (a instanceof Date && b instanceof Date) {
-    if (dateComparisonMode === "date-only") {
-      return isSameDayInTimeZone(a, b, timeZone);
-    } else {
-      return getDateKey(a, timeZone, true) === getDateKey(b, timeZone, true);
-    }
-  }
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) return false;
-    return a.every((dateA, index2) => {
-      const dateB = b[index2];
-      if (!(dateA instanceof Date && dateB instanceof Date)) return false;
-      if (dateComparisonMode === "date-only") {
-        return isSameDayInTimeZone(dateA, dateB, timeZone);
-      } else {
-        return getDateKey(dateA, timeZone, true) === getDateKey(dateB, timeZone, true);
-      }
-    });
-  }
-  if (typeof a === "object" && "start" in a && typeof b === "object" && "start" in b) {
-    if (dateComparisonMode === "date-only") {
-      return isSameDayInTimeZone(a.start, b.start, timeZone) && isSameDayInTimeZone(a.end, b.end, timeZone);
-    } else {
-      return getDateKey(a.start, timeZone, true) === getDateKey(b.start, timeZone, true) && getDateKey(a.end, timeZone, true) === getDateKey(b.end, timeZone, true);
-    }
-  }
-  return false;
-}
-function generateMonthMapping(locale2, patterns) {
-  const mapping = {};
-  for (let month = 0; month < 12; month++) {
-    const date = new Date(2024, month, 1);
-    for (const pattern of patterns) {
-      const monthName = dateFns.format(date, pattern, { locale: locale2 }).toLowerCase();
-      mapping[monthName] = month + 1;
-    }
-  }
-  return mapping;
-}
-var englishMonthsCache = null;
-var chineseMonthsCache = null;
-function getEnglishMonths() {
-  if (!englishMonthsCache) {
-    englishMonthsCache = {
-      ...generateMonthMapping(locale.enUS, ["MMMM", "MMM", "MMM."]),
-      // 全称、缩写、带点缩写
-      // 常见变体
-      sept: 9,
-      "sept.": 9
-    };
-  }
-  return englishMonthsCache;
-}
-function getChineseMonths() {
-  if (!chineseMonthsCache) {
-    chineseMonthsCache = {
-      ...generateMonthMapping(locale.zhCN, ["MMMM", "M月"])
-      // 中文月份名和数字月份
-    };
-  }
-  return chineseMonthsCache;
-}
-function parseMonthName(input, locale2) {
-  const normalized = input.toLowerCase().trim();
-  const isChineseLocale2 = /[\u4e00-\u9fff]/.test(input);
-  if (isChineseLocale2) {
-    const chineseMonths2 = getChineseMonths();
-    if (chineseMonths2[normalized]) {
-      return chineseMonths2[normalized];
-    }
-  }
-  const englishMonths2 = getEnglishMonths();
-  if (englishMonths2[normalized]) {
-    return englishMonths2[normalized];
-  }
-  if (normalized.length >= 2) {
-    for (const [monthName, monthNum] of Object.entries(englishMonths2)) {
-      if (monthName.startsWith(normalized) && monthName.length >= normalized.length) {
-        return monthNum;
-      }
-    }
-  }
-  return null;
-}
-new Proxy(
-  {},
-  {
-    get: () => getEnglishMonths()
-  }
-);
-new Proxy(
-  {},
-  {
-    get: () => getChineseMonths()
-  }
-);
-function getLastDayOfMonth(year, month) {
-  const date = new Date(year, month - 1, 1);
-  return dateFns.getDaysInMonth(date);
-}
-function smartCorrectDate(year, month, day) {
-  const correctedYear = smartCorrectYear(year);
-  let correctedMonth = month;
-  if (month < 1) {
-    correctedMonth = 1;
-  } else if (month > 12) {
-    correctedMonth = 12;
-  }
-  let correctedDay = day;
-  if (day < 1) {
-    correctedDay = 1;
-  } else {
-    const lastDay = getLastDayOfMonth(correctedYear, correctedMonth);
-    if (day > lastDay) {
-      correctedDay = lastDay;
-    }
-  }
-  return {
-    year: correctedYear,
-    month: correctedMonth,
-    day: correctedDay
-  };
-}
-function smartCorrectYear(year) {
-  if (year < 1950) {
-    if (year < 100) {
-      return year < 50 ? 2e3 + year : 1900 + year;
-    } else if (year < 1e3) {
-      return 2e3 + year;
-    } else {
-      return 2e3 + year % 100;
-    }
-  } else if (year > 2100) {
-    return 2024 + year % 10;
-  }
-  return year;
-}
-function handleShortcuts(input) {
-  const lower = input.toLowerCase().trim();
-  const now = /* @__PURE__ */ new Date();
-  const shortcuts = {
-    t: () => dateFns.startOfDay(now),
-    today: () => dateFns.startOfDay(now),
-    今: () => dateFns.startOfDay(now),
-    今天: () => dateFns.startOfDay(now),
-    y: () => dateFns.startOfDay(dateFns.subDays(now, 1)),
-    yesterday: () => dateFns.startOfDay(dateFns.subDays(now, 1)),
-    昨: () => dateFns.startOfDay(dateFns.subDays(now, 1)),
-    昨天: () => dateFns.startOfDay(dateFns.subDays(now, 1)),
-    tm: () => dateFns.startOfDay(dateFns.addDays(now, 1)),
-    tomorrow: () => dateFns.startOfDay(dateFns.addDays(now, 1)),
-    明: () => dateFns.startOfDay(dateFns.addDays(now, 1)),
-    明天: () => dateFns.startOfDay(dateFns.addDays(now, 1)),
-    w: () => dateFns.startOfWeek(now),
-    week: () => dateFns.startOfWeek(now),
-    周: () => dateFns.startOfWeek(now),
-    本周: () => dateFns.startOfWeek(now),
-    m: () => dateFns.startOfMonth(now),
-    month: () => dateFns.startOfMonth(now),
-    月: () => dateFns.startOfMonth(now),
-    本月: () => dateFns.startOfMonth(now)
-  };
-  const handler = shortcuts[lower];
-  return handler ? handler() : null;
-}
-var defaultLocaleMap = {
-  "zh-CN": locale.zhCN,
-  "en-US": locale.enUS
-};
-var naturalLanguageMap = {
-  "zh-CN": {
-    today: ["今天", "今日", "现在"],
-    tomorrow: ["明天", "明日"],
-    yesterday: ["昨天", "昨日"],
-    thisWeek: ["本周", "这周", "这个星期", "本星期"],
-    nextWeek: ["下周", "下个星期"],
-    lastWeek: ["上周", "上个星期"],
-    thisMonth: ["本月", "这个月"],
-    nextMonth: ["下月", "下个月"],
-    lastMonth: ["上月", "上个月"],
-    thisYear: ["今年", "本年"],
-    nextYear: ["明年", "下年"],
-    lastYear: ["去年", "上年"],
-    now: ["现在", "此刻"],
-    morning: ["早上", "上午", "晨"],
-    afternoon: ["下午", "午后"],
-    evening: ["晚上", "傍晚"],
-    night: ["深夜", "夜里", "夜间", "午夜"]
-  },
-  "en-US": {
-    today: ["today", "now"],
-    tomorrow: ["tomorrow", "tmr"],
-    yesterday: ["yesterday"],
-    thisWeek: ["this week"],
-    nextWeek: ["next week"],
-    lastWeek: ["last week"],
-    thisMonth: ["this month"],
-    nextMonth: ["next month"],
-    lastMonth: ["last month"],
-    thisYear: ["this year"],
-    nextYear: ["next year"],
-    lastYear: ["last year"],
-    now: ["now"],
-    morning: ["morning", "am"],
-    afternoon: ["afternoon", "pm"],
-    evening: ["evening"],
-    night: ["night"]
-  }
-};
-var relativeDatePatterns = [
-  // 数字 + 天/日
-  { pattern: /(\d+)\s*天[后前]?/g, type: "day", multiplier: 1 },
-  { pattern: /(\d+)\s*日[后前]?/g, type: "day", multiplier: 1 },
-  { pattern: /(\d+)\s*days?\s*(later|ago)?/gi, type: "day", multiplier: 1 },
-  // 数字 + 周/星期
-  { pattern: /(\d+)\s*周[后前]?/g, type: "week", multiplier: 1 },
-  { pattern: /(\d+)\s*星期[后前]?/g, type: "week", multiplier: 1 },
-  { pattern: /(\d+)\s*weeks?\s*(later|ago)?/gi, type: "week", multiplier: 1 },
-  // 数字 + 月
-  { pattern: /(\d+)\s*个?月[后前]?/g, type: "month", multiplier: 1 },
-  { pattern: /(\d+)\s*months?\s*(later|ago)?/gi, type: "month", multiplier: 1 },
-  // 数字 + 年
-  { pattern: /(\d+)\s*年[后前]?/g, type: "year", multiplier: 1 },
-  { pattern: /(\d+)\s*years?\s*(later|ago)?/gi, type: "year", multiplier: 1 }
-];
-var commonDateFormats = [
-  "yyyy-MM-dd",
-  // 最常用的 ISO 格式
-  "MM/dd/yyyy",
-  // 美式格式
-  "dd/MM/yyyy",
-  // 欧式格式
-  "yyyy/MM/dd",
-  // 日式格式
-  "yyyyMMdd",
-  // 紧凑格式
-  "yyyy-M-d",
-  // 宽松格式
-  "yyyy/M/d",
-  "M/d/yyyy",
-  "d/M/yyyy",
-  "dd.MM.yyyy",
-  // 德式格式
-  "yyyy.MM.dd"
-];
-var commonTimeFormats = [
-  "HH:mm",
-  // 24小时制（最常用）
-  "H:mm",
-  // 24小时制不补零
-  "HH:mm:ss",
-  // 带秒
-  "h:mm a",
-  // 12小时制
-  "hh:mm a",
-  // 12小时制补零
-  "h:mm aa",
-  "HHmm",
-  // 紧凑格式
-  "Hmm"
-];
-var parserConfig = {
-  // 缓存配置
-  cache: {
-    enabled: true,
-    maxSize: 100,
-    // 最大缓存条目数
-    ttl: 6e4
-    // 缓存时间 (ms)
-  },
-  // 性能阈值
-  performance: {
-    maxParseTime: 50
-  }
-};
-var SimpleCache = class {
-  constructor(maxSize = 100, ttl = 6e4) {
-    __publicField(this, "cache", /* @__PURE__ */ new Map());
-    __publicField(this, "maxSize");
-    __publicField(this, "ttl");
-    this.maxSize = maxSize;
-    this.ttl = ttl;
-  }
-  get(key) {
-    const item = this.cache.get(key);
-    if (!item) return null;
-    if (Date.now() - item.timestamp > this.ttl) {
-      this.cache.delete(key);
-      return null;
-    }
-    return item.value;
-  }
-  set(key, value) {
-    if (this.cache.size >= this.maxSize) {
-      const firstKey = Array.from(this.cache.keys())[0];
-      if (firstKey) {
-        this.cache.delete(firstKey);
-      }
-    }
-    this.cache.set(key, { value, timestamp: Date.now() });
-  }
-  clear() {
-    this.cache.clear();
-  }
-};
-var parseCache = new SimpleCache(
-  parserConfig.cache.maxSize,
-  parserConfig.cache.ttl
-);
-function parseRelativeDate(input) {
-  const now = /* @__PURE__ */ new Date();
-  for (const pattern of relativeDatePatterns) {
-    const match = pattern.pattern.exec(input);
-    if (match) {
-      const amount = parseInt(match[1], 10);
-      const isAgo = input.includes("前") || input.includes("ago");
-      const actualAmount = isAgo ? -amount : amount;
-      switch (pattern.type) {
-        case "day":
-          return dateFns.addDays(now, actualAmount);
-        case "week":
-          return dateFns.addWeeks(now, actualAmount);
-        case "month":
-          return dateFns.addMonths(now, actualAmount);
-        case "year":
-          return dateFns.addYears(now, actualAmount);
-      }
-    }
-  }
-  return null;
-}
-function parseExtendedRelativeDate(input) {
-  const now = /* @__PURE__ */ new Date();
-  const patterns = [
-    // +数字 (天数)
-    {
-      regex: /^\+(\d+)$/,
-      handler: (match) => dateFns.addDays(now, parseInt(match[1], 10))
-    },
-    // -数字 (天数)
-    {
-      regex: /^-(\d+)$/,
-      handler: (match) => dateFns.subDays(now, parseInt(match[1], 10))
-    },
-    // w+数字 (周数)
-    {
-      regex: /^w\+(\d+)$/i,
-      handler: (match) => dateFns.addWeeks(now, parseInt(match[1], 10))
-    },
-    {
-      regex: /^w-(\d+)$/i,
-      handler: (match) => dateFns.subWeeks(now, parseInt(match[1], 10))
-    },
-    // m+数字 (月数)
-    {
-      regex: /^m\+(\d+)$/i,
-      handler: (match) => dateFns.addMonths(now, parseInt(match[1], 10))
-    },
-    {
-      regex: /^m-(\d+)$/i,
-      handler: (match) => dateFns.subMonths(now, parseInt(match[1], 10))
-    },
-    // y+数字 (年数)
-    {
-      regex: /^y\+(\d+)$/i,
-      handler: (match) => dateFns.addYears(now, parseInt(match[1], 10))
-    },
-    {
-      regex: /^y-(\d+)$/i,
-      handler: (match) => dateFns.subYears(now, parseInt(match[1], 10))
-    },
-    // 中文相对表达
-    {
-      regex: /^(\d+)天后$/,
-      handler: (match) => dateFns.addDays(now, parseInt(match[1], 10))
-    },
-    {
-      regex: /^(\d+)天前$/,
-      handler: (match) => dateFns.subDays(now, parseInt(match[1], 10))
-    },
-    {
-      regex: /^(\d+)周后$/,
-      handler: (match) => dateFns.addWeeks(now, parseInt(match[1], 10))
-    },
-    {
-      regex: /^(\d+)周前$/,
-      handler: (match) => dateFns.subWeeks(now, parseInt(match[1], 10))
-    },
-    {
-      regex: /^(\d+)月后$/,
-      handler: (match) => dateFns.addMonths(now, parseInt(match[1], 10))
-    },
-    {
-      regex: /^(\d+)月前$/,
-      handler: (match) => dateFns.subMonths(now, parseInt(match[1], 10))
-    },
-    {
-      regex: /^(\d+)年后$/,
-      handler: (match) => dateFns.addYears(now, parseInt(match[1], 10))
-    },
-    {
-      regex: /^(\d+)年前$/,
-      handler: (match) => dateFns.subYears(now, parseInt(match[1], 10))
-    }
-  ];
-  for (const pattern of patterns) {
-    const match = input.trim().match(pattern.regex);
-    if (match) {
-      return pattern.handler(match);
-    }
-  }
-  return null;
-}
-function parseNaturalLanguage(input, localeKey = "zh-CN") {
-  const normalizedInput = input.toLowerCase().trim();
-  const keywords = naturalLanguageMap[localeKey] || naturalLanguageMap["en-US"];
-  const now = /* @__PURE__ */ new Date();
-  const locale2 = defaultLocaleMap[localeKey];
-  for (const [key, values] of Object.entries(keywords)) {
-    for (const value of values) {
-      if (normalizedInput.includes(value.toLowerCase())) {
-        switch (key) {
-          case "today":
-            return dateFns.startOfDay(now);
-          case "tomorrow":
-            return dateFns.startOfDay(dateFns.addDays(now, 1));
-          case "yesterday":
-            return dateFns.startOfDay(dateFns.subDays(now, 1));
-          case "thisWeek":
-            return dateFns.startOfWeek(now, { locale: locale2 });
-          case "nextWeek":
-            return dateFns.startOfWeek(dateFns.addWeeks(now, 1), { locale: locale2 });
-          case "lastWeek":
-            return dateFns.startOfWeek(dateFns.subWeeks(now, 1), { locale: locale2 });
-          case "thisMonth":
-            return dateFns.startOfMonth(now);
-          case "nextMonth":
-            return dateFns.startOfMonth(dateFns.addMonths(now, 1));
-          case "lastMonth":
-            return dateFns.startOfMonth(dateFns.subMonths(now, 1));
-          case "thisYear":
-            return dateFns.startOfYear(now);
-          case "nextYear":
-            return dateFns.startOfYear(dateFns.addYears(now, 1));
-          case "lastYear":
-            return dateFns.startOfYear(dateFns.subYears(now, 1));
-          case "now":
-            return now;
-        }
-      }
-    }
-  }
-  return null;
-}
-function getLocaleKey(locale2) {
-  if (!locale2) return "en-US";
-  for (const [key, value] of Object.entries(defaultLocaleMap)) {
-    if (value === locale2) {
-      return key;
-    }
-  }
-  return "en-US";
-}
-function parseEnglishDate(input) {
-  const normalized = input.toLowerCase().trim();
-  const now = /* @__PURE__ */ new Date();
-  const currentYear = now.getFullYear();
-  const fullDatePattern = /^(?:([a-z]+)\s+(\d{1,2})(?:st|nd|rd|th)?,?\s+(\d{4})|(\d{1,2})(?:st|nd|rd|th)?\s+([a-z]+)\s+(\d{4}))$/;
-  const fullDateMatch = normalized.match(fullDatePattern);
-  if (fullDateMatch) {
-    const monthName = fullDateMatch[1] || fullDateMatch[5];
-    const dayStr = fullDateMatch[2] || fullDateMatch[4];
-    const yearStr = fullDateMatch[3] || fullDateMatch[6];
-    const month = parseMonthName(monthName);
-    const day = parseInt(dayStr, 10);
-    const year = parseInt(yearStr, 10);
-    if (month && day >= 1 && day <= 31 && year >= 1900 && year <= 2100) {
-      const date = new Date(year, month - 1, day);
-      if (dateFns.isValid(date) && date.getDate() === day) {
-        return date;
-      }
-    }
-  }
-  const monthDayPattern = /^(?:([a-z]+)\s+(\d{1,2})(?:st|nd|rd|th)?|(\d{1,2})(?:st|nd|rd|th)?\s+([a-z]+))$/;
-  const monthDayMatch = normalized.match(monthDayPattern);
-  if (monthDayMatch) {
-    const monthName = monthDayMatch[1] || monthDayMatch[4];
-    const dayStr = monthDayMatch[2] || monthDayMatch[3];
-    const month = parseMonthName(monthName);
-    const day = parseInt(dayStr, 10);
-    if (month && day >= 1 && day <= 31) {
-      const date = new Date(currentYear, month - 1, day);
-      if (dateFns.isValid(date) && date.getDate() === day) {
-        return date;
-      }
-    }
-  }
-  const monthOnlyPattern = /^[a-z]{3,}$/;
-  if (monthOnlyPattern.test(normalized)) {
-    const month = parseMonthName(normalized);
-    if (month) {
-      const date = new Date(currentYear, month - 1, 1);
-      if (dateFns.isValid(date)) {
-        return date;
-      }
-    }
-  }
-  return null;
-}
-var DigitExtractor = class {
-  constructor(digits) {
-    this.digits = digits;
-  }
-  /** 提取指定位置的数字 */
-  extract(start, length) {
-    return parseInt(this.digits.substring(start, start + length), 10);
-  }
-  /** 提取年份 (前2位) */
-  getYear2() {
-    return this.extract(0, 2);
-  }
-  /** 提取年份 (前4位) */
-  getYear4() {
-    return this.extract(0, 4);
-  }
-  /** 提取月份 (前2位) */
-  getMonth() {
-    return this.extract(0, 2);
-  }
-  /** 提取日期 (第3-4位) */
-  getDay() {
-    return this.extract(2, 2);
-  }
-  /** 提取6位数字的各个部分 (YYMMDD格式) */
-  getYYMMDD() {
-    return {
-      year: this.extract(0, 2),
-      month: this.extract(2, 2),
-      day: this.extract(4, 2)
-    };
-  }
-  /** 提取8位数字的各个部分 (YYYYMMDD格式) */
-  getYYYYMMDD() {
-    return {
-      year: this.extract(0, 4),
-      month: this.extract(4, 2),
-      day: this.extract(6, 2)
-    };
-  }
-  /** 提取3位数字的各个部分 */
-  get3DigitParts() {
-    return {
-      first: this.extract(0, 1),
-      lastTwo: this.extract(1, 2)
-    };
-  }
-};
-function convertTwoDigitYear(year) {
-  return year < 50 ? 2e3 + year : 1900 + year;
-}
-function isValidMonthDay(month, day) {
-  return month >= 1 && month <= 12 && day >= 1 && day <= 31;
-}
-function canBeMonthDay(firstDigit, lastTwoDigits) {
-  return firstDigit >= 1 && firstDigit <= 12 && lastTwoDigits >= 1 && lastTwoDigits <= 31;
-}
-function isReasonableYear(year) {
-  return year >= 1950 && year <= 2100;
-}
-function parseYYMMDD(digits, targetFormat) {
-  const extractor = new DigitExtractor(digits);
-  const { year: yy, month, day } = extractor.getYYMMDD();
-  if (!isValidMonthDay(month, day)) {
-    return null;
-  }
-  const fullYear = convertTwoDigitYear(yy);
-  const corrected = smartCorrectDate(fullYear, month, day);
-  let formatted;
-  if (targetFormat === "yyyy-MM-dd") {
-    formatted = `${corrected.year}-${corrected.month.toString().padStart(2, "0")}-${corrected.day.toString().padStart(2, "0")}`;
-  } else if (targetFormat === "MM/dd/yyyy") {
-    formatted = `${corrected.month.toString().padStart(2, "0")}/${corrected.day.toString().padStart(2, "0")}/${corrected.year}`;
-  } else {
-    return null;
-  }
-  return {
-    year: corrected.year,
-    month: corrected.month,
-    day: corrected.day,
-    formatted
-  };
-}
-function parseYYYYMMDD(digits, targetFormat) {
-  const extractor = new DigitExtractor(digits);
-  const { year, month, day } = extractor.getYYYYMMDD();
-  if (!isReasonableYear(year)) {
-    return null;
-  }
-  const corrected = smartCorrectDate(year, month, day);
-  let formatted;
-  {
-    formatted = `${corrected.year}-${corrected.month.toString().padStart(2, "0")}-${corrected.day.toString().padStart(2, "0")}`;
-  }
-  return {
-    year: corrected.year,
-    month: corrected.month,
-    day: corrected.day,
-    formatted
-  };
-}
-function parse3Digits(digits, currentYear, targetFormat) {
-  const extractor = new DigitExtractor(digits);
-  const { first, lastTwo } = extractor.get3DigitParts();
-  if (canBeMonthDay(first, lastTwo)) {
-    const corrected = smartCorrectDate(currentYear, first, lastTwo);
-    let formatted;
-    {
-      formatted = `${corrected.year}-${corrected.month.toString().padStart(2, "0")}-${corrected.day.toString().padStart(2, "0")}`;
-    }
-    return {
-      year: corrected.year,
-      month: corrected.month,
-      day: corrected.day,
-      formatted
-    };
-  }
-  return null;
-}
-function parseDate(input, options = {}) {
-  const {
-    format: dateFormat = "yyyy-MM-dd",
-    locale: locale$1 = locale.enUS,
-    enableNaturalLanguage = true,
-    enableRelativeDate = true,
-    enableSmartCorrection = true,
-    strict = false,
-    detailed = false
-  } = options;
-  const detailedResult = {
-    input,
-    date: null,
-    formatted: "",
-    isValid: false,
-    error: null
-  };
-  const trimmedInput = input.trim();
-  if (!trimmedInput) {
-    return detailed ? detailedResult : null;
-  }
-  let result = null;
-  try {
-    try {
-      result = dateFns.parse(trimmedInput, dateFormat, /* @__PURE__ */ new Date(), { locale: locale$1 });
-      if (dateFns.isValid(result)) {
-        return formatResult(result, dateFormat, locale$1, detailed, detailedResult);
-      }
-    } catch {
-    }
-    if (enableSmartCorrection) {
-      result = parseInvalidFormattedDate(trimmedInput, dateFormat, locale$1);
-      if (result && dateFns.isValid(result)) {
-        return formatResult(result, dateFormat, locale$1, detailed, detailedResult);
-      }
-    }
-    if (hasWeekdayInFormat(dateFormat)) {
-      result = parseCompositeFormat(trimmedInput, dateFormat, locale$1);
-      if (result && dateFns.isValid(result)) {
-        return formatResult(result, dateFormat, locale$1, detailed, detailedResult);
-      }
-    }
-    if (enableSmartCorrection) {
-      result = parseNumericInput(trimmedInput, dateFormat, locale$1);
-      if (result && dateFns.isValid(result)) {
-        return formatResult(result, dateFormat, locale$1, detailed, detailedResult);
-      }
-    }
-    result = handleShortcuts(trimmedInput);
-    if (result && dateFns.isValid(result)) {
-      return formatResult(result, dateFormat, locale$1, detailed, detailedResult);
-    }
-    if (enableRelativeDate) {
-      result = parseExtendedRelativeDate(trimmedInput);
-      if (result && dateFns.isValid(result)) {
-        return formatResult(result, dateFormat, locale$1, detailed, detailedResult);
-      }
-    }
-    if (enableNaturalLanguage) {
-      result = parseNaturalLanguage(trimmedInput, getLocaleKey(locale$1));
-      if (result && dateFns.isValid(result)) {
-        return formatResult(result, dateFormat, locale$1, detailed, detailedResult);
-      }
-    }
-    if (enableRelativeDate) {
-      result = parseRelativeDate(trimmedInput);
-      if (result && dateFns.isValid(result)) {
-        return formatResult(result, dateFormat, locale$1, detailed, detailedResult);
-      }
-    }
-    result = parseEnglishDate(trimmedInput);
-    if (result && dateFns.isValid(result)) {
-      return formatResult(result, dateFormat, locale$1, detailed, detailedResult);
-    }
-    for (const tryFormat of commonDateFormats) {
-      if (tryFormat !== dateFormat) {
-        try {
-          result = dateFns.parse(trimmedInput, tryFormat, /* @__PURE__ */ new Date(), { locale: locale$1 });
-          if (dateFns.isValid(result)) {
-            return formatResult(result, dateFormat, locale$1, detailed, detailedResult);
-          }
-        } catch {
-        }
-      }
-    }
-    if (detailed) {
-      detailedResult.error = strict ? "Invalid date format" : null;
-      return detailedResult;
-    }
-    return null;
-  } catch (error) {
-    if (detailed) {
-      detailedResult.error = error instanceof Error ? error.message : "Parse error";
-      return detailedResult;
-    }
-    return null;
-  }
-}
-function formatResult(date, dateFormat, locale2, detailed, detailedResult) {
-  if (detailed) {
-    detailedResult.date = date;
-    detailedResult.formatted = dateFns.format(date, dateFormat, { locale: locale2 });
-    detailedResult.isValid = true;
-    return detailedResult;
-  }
-  return date;
-}
-function parseNumericInput(input, targetFormat, locale2) {
-  if (!/^\d+$/.test(input.trim())) {
-    return null;
-  }
-  const digitOnlyInput = input.trim();
-  const now = /* @__PURE__ */ new Date();
-  const currentYear = now.getFullYear().toString();
-  const currentMonth = (now.getMonth() + 1).toString().padStart(2, "0");
-  const currentDay = now.getDate().toString().padStart(2, "0");
-  let tempDisplayValue = "";
-  if (targetFormat === "yyyy-MM-dd") {
-    tempDisplayValue = buildYYYYMMDDFormat(
-      digitOnlyInput,
-      digitOnlyInput.length,
-      currentYear,
-      currentMonth,
-      currentDay
-    );
-  } else if (targetFormat === "MM/dd/yyyy") {
-    tempDisplayValue = buildMMDDYYYYFormat(
-      digitOnlyInput,
-      digitOnlyInput.length,
-      currentYear,
-      currentMonth,
-      currentDay
-    );
-  } else {
-    return tryGenericNumericParsing(digitOnlyInput, digitOnlyInput.length, now);
-  }
-  try {
-    const parsedDate = dateFns.parse(tempDisplayValue, targetFormat, /* @__PURE__ */ new Date(), { locale: locale2 });
-    if (dateFns.isValid(parsedDate)) {
-      return parsedDate;
-    }
-  } catch {
-  }
-  return null;
-}
-function buildYYYYMMDDFormat(digitOnlyInput, length, currentYear, currentMonth, currentDay) {
-  if (length === 1) {
-    return `${currentYear.substring(0, 3)}${digitOnlyInput}-${currentMonth}-${currentDay}`;
-  } else if (length === 2) {
-    const num = parseInt(digitOnlyInput, 10);
-    if (num >= 1 && num <= 31) {
-      const month = parseInt(currentMonth, 10);
-      const corrected = smartCorrectDate(parseInt(currentYear, 10), month, num);
-      return `${corrected.year}-${corrected.month.toString().padStart(2, "0")}-${corrected.day.toString().padStart(2, "0")}`;
-    } else {
-      return `${currentYear.substring(0, 2)}${digitOnlyInput}-${currentMonth}-${currentDay}`;
-    }
-  } else if (length === 3) {
-    const result = parse3Digits(digitOnlyInput, parseInt(currentYear, 10));
-    if (result) {
-      return result.formatted;
-    }
-    const year = digitOnlyInput + currentYear.substring(3, 4);
-    return `${year}-${currentMonth}-${currentDay}`;
-  } else if (length === 4) {
-    const asYear = parseInt(digitOnlyInput, 10);
-    const asMonth = parseInt(digitOnlyInput.substring(0, 2), 10);
-    const asDay = parseInt(digitOnlyInput.substring(2, 4), 10);
-    const isReasonableYear2 = asYear >= 1950 && asYear <= 2100;
-    const isValidMMDD = asMonth >= 1 && asMonth <= 12 && asDay >= 1 && asDay <= 31;
-    if (isReasonableYear2 && !isValidMMDD) {
-      const year = smartCorrectYear(asYear);
-      return `${year}-${currentMonth}-${currentDay}`;
-    } else if (isValidMMDD) {
-      return `${currentYear}-${asMonth.toString().padStart(2, "0")}-${asDay.toString().padStart(2, "0")}`;
-    } else {
-      const year = smartCorrectYear(asYear);
-      return `${year}-${currentMonth}-${currentDay}`;
-    }
-  } else if (length === 5) {
-    const year = smartCorrectYear(parseInt(digitOnlyInput.substring(0, 4), 10));
-    const monthTens = digitOnlyInput.substring(4, 5);
-    return `${year}-${monthTens}-${currentDay}`;
-  } else if (length === 6) {
-    const result = parseYYMMDD(digitOnlyInput, "yyyy-MM-dd");
-    return (result == null ? void 0 : result.formatted) || // 降级到智能修正，强制使用 YYMMDD 格式
-    (() => {
-      const yymmddYear = parseInt(digitOnlyInput.substring(0, 2), 10);
-      const yymmddMonth = parseInt(digitOnlyInput.substring(2, 4), 10);
-      const yymmddDay = parseInt(digitOnlyInput.substring(4, 6), 10);
-      const correctedYear = convertTwoDigitYear(yymmddYear);
-      const corrected = smartCorrectDate(correctedYear, yymmddMonth, yymmddDay);
-      return `${corrected.year}-${corrected.month.toString().padStart(2, "0")}-${corrected.day.toString().padStart(2, "0")}`;
-    })();
-  } else if (length === 7) {
-    const year = smartCorrectYear(parseInt(digitOnlyInput.substring(0, 4), 10));
-    const month = parseInt(digitOnlyInput.substring(4, 6), 10);
-    const dayTens = digitOnlyInput.substring(6, 7);
-    const validMonth = month >= 1 && month <= 12 ? month.toString().padStart(2, "0") : currentMonth;
-    return `${year}-${validMonth}-${dayTens}`;
-  } else if (length === 8) {
-    const result = parseYYYYMMDD(digitOnlyInput);
-    return (result == null ? void 0 : result.formatted) || // 降级到智能修正
-    (() => {
-      const year = parseInt(digitOnlyInput.substring(0, 4), 10);
-      const month = parseInt(digitOnlyInput.substring(4, 6), 10);
-      const day = parseInt(digitOnlyInput.substring(6, 8), 10);
-      const corrected = smartCorrectDate(year, month, day);
-      return `${corrected.year}-${corrected.month.toString().padStart(2, "0")}-${corrected.day.toString().padStart(2, "0")}`;
-    })();
-  } else {
-    return buildYYYYMMDDFormat(
-      digitOnlyInput.substring(0, 8),
-      8,
-      currentYear,
-      currentMonth,
-      currentDay
-    );
-  }
-}
-function buildMMDDYYYYFormat(digitOnlyInput, length, currentYear, currentMonth, currentDay) {
-  if (length === 1) {
-    const year = parseInt(`${currentYear.substring(0, 3)}${digitOnlyInput}`, 10);
-    return `${currentMonth}/${currentDay}/${year}`;
-  } else if (length === 2) {
-    const num = parseInt(digitOnlyInput, 10);
-    if (num >= 1 && num <= 31) {
-      const corrected = smartCorrectDate(parseInt(currentYear, 10), parseInt(currentMonth, 10), num);
-      return `${corrected.month.toString().padStart(2, "0")}/${corrected.day.toString().padStart(2, "0")}/${corrected.year}`;
-    } else {
-      const year = parseInt(`${currentYear.substring(0, 2)}${digitOnlyInput}`, 10);
-      return `${currentMonth}/${currentDay}/${year}`;
-    }
-  } else if (length === 3) {
-    const firstDigit = parseInt(digitOnlyInput.substring(0, 1), 10);
-    const lastTwoDigits = parseInt(digitOnlyInput.substring(1, 3), 10);
-    if (firstDigit >= 1 && firstDigit <= 12 && lastTwoDigits >= 1 && lastTwoDigits <= 31) {
-      return `${firstDigit.toString().padStart(2, "0")}/${lastTwoDigits.toString().padStart(2, "0")}/${currentYear}`;
-    } else {
-      const month = parseInt(digitOnlyInput.substring(0, 2), 10);
-      const dayTens = digitOnlyInput.substring(2, 3);
-      const validMonth = month >= 1 && month <= 12 ? month.toString().padStart(2, "0") : currentMonth;
-      return `${validMonth}/${dayTens}/${currentYear}`;
-    }
-  } else if (length === 4) {
-    const month = parseInt(digitOnlyInput.substring(0, 2), 10);
-    const day = parseInt(digitOnlyInput.substring(2, 4), 10);
-    const corrected = smartCorrectDate(parseInt(currentYear, 10), month, day);
-    return `${corrected.month.toString().padStart(2, "0")}/${corrected.day.toString().padStart(2, "0")}/${corrected.year}`;
-  } else if (length === 6) {
-    const result = parseYYMMDD(digitOnlyInput, "MM/dd/yyyy");
-    if (result) {
-      return result.formatted;
-    }
-  } else if (length >= 5) {
-    const month = parseInt(digitOnlyInput.substring(0, 2), 10);
-    const day = parseInt(digitOnlyInput.substring(2, 4), 10);
-    const yearPart = digitOnlyInput.substring(4);
-    let year = parseInt(currentYear, 10);
-    if (yearPart.length === 1) {
-      year = parseInt(`${currentYear.substring(0, 3)}${yearPart}`, 10);
-    } else if (yearPart.length === 2) {
-      year = parseInt(`${currentYear.substring(0, 2)}${yearPart}`, 10);
-    } else if (yearPart.length === 3) {
-      year = parseInt(`${yearPart}${currentYear.substring(3, 4)}`, 10);
-    } else if (yearPart.length >= 4) {
-      year = parseInt(yearPart.substring(0, 4), 10);
-    }
-    year = smartCorrectYear(year);
-    const corrected = smartCorrectDate(year, month, day);
-    return `${corrected.month.toString().padStart(2, "0")}/${corrected.day.toString().padStart(2, "0")}/${corrected.year}`;
-  }
-  return "";
-}
-function tryGenericNumericParsing(digitOnly, length, now) {
-  const currentYear = now.getFullYear().toString();
-  if (length === 1) {
-    const year = parseInt(`${currentYear.substring(0, 3)}${digitOnly}`, 10);
-    return new Date(year, now.getMonth(), now.getDate());
-  } else if (length === 2) {
-    const num = parseInt(digitOnly, 10);
-    if (num >= 1 && num <= 31) {
-      const corrected = smartCorrectDate(parseInt(currentYear, 10), now.getMonth() + 1, num);
-      return new Date(corrected.year, corrected.month - 1, corrected.day);
-    } else {
-      const year = convertTwoDigitYear(num);
-      return new Date(year, now.getMonth(), now.getDate());
-    }
-  } else if (length === 3) {
-    const result = parse3Digits(digitOnly, parseInt(currentYear, 10));
-    if (result) {
-      return new Date(result.year, result.month - 1, result.day);
-    }
-    const year = parseInt(`${digitOnly}${currentYear.substring(3, 4)}`, 10);
-    return new Date(year, now.getMonth(), now.getDate());
-  } else if (length === 4) {
-    const month = parseInt(digitOnly.substring(0, 2), 10);
-    const day = parseInt(digitOnly.substring(2, 4), 10);
-    const corrected = smartCorrectDate(parseInt(currentYear, 10), month, day);
-    return new Date(corrected.year, corrected.month - 1, corrected.day);
-  } else if (length === 6) {
-    const result = parseYYMMDD(digitOnly, "yyyy-MM-dd");
-    if (result) {
-      return new Date(result.year, result.month - 1, result.day);
-    }
-  } else if (length === 8) {
-    const result = parseYYYYMMDD(digitOnly);
-    if (result) {
-      return new Date(result.year, result.month - 1, result.day);
-    }
-  }
-  return null;
-}
-function hasWeekdayInFormat(format10) {
-  const weekdayPatterns = [
-    /\be{1,4}\b/,
-    // e, ee, eee, eeee (localized weekday)
-    /\bE{1,4}\b/,
-    // E, EE, EEE, EEEE (weekday)
-    /\bi{1,4}\b/,
-    // i, ii, iii, iiii (ISO weekday)
-    /\bc{1,4}\b/
-    // c, cc, ccc, cccc (standalone weekday)
-  ];
-  return weekdayPatterns.some((pattern) => pattern.test(format10));
-}
-function parseCompositeFormat(input, format10, locale2) {
-  try {
-    const dateOnlyFormat = removeWeekdayFromFormat(format10);
-    const dateOnlyInput = removeWeekdayFromInput(input, locale2);
-    if (!dateOnlyFormat || !dateOnlyInput) {
-      return null;
-    }
-    const result = dateFns.parse(dateOnlyInput, dateOnlyFormat, /* @__PURE__ */ new Date(), { locale: locale2 });
-    return dateFns.isValid(result) ? result : null;
-  } catch {
-    return null;
-  }
-}
-function removeWeekdayFromFormat(format10) {
-  return format10.replace(/\s*[eEic]{1,4}\s*/g, "").replace(/\s+/g, " ").replace(/\s*([,，、])\s*/g, "$1").trim();
-}
-function removeWeekdayFromInput(input, locale2) {
-  try {
-    const weekdayNames = generateWeekdayNames2(locale2);
-    if (weekdayNames.length === 0) {
-      return input;
-    }
-    const sortedNames = weekdayNames.sort((a, b) => b.length - a.length);
-    const pattern = new RegExp(`\\s*(${sortedNames.join("|")})\\s*`, "gi");
-    return input.replace(pattern, "").replace(/\s+/g, " ").trim();
-  } catch {
-    return input.replace(/\s*(星期[一二三四五六日天]|周[一二三四五六日天])\s*/g, "").replace(/\s+/g, " ").trim();
-  }
-}
-function generateWeekdayNames2(locale2) {
-  const names = [];
-  try {
-    const baseDate = new Date(2024, 0, 7);
-    for (let i = 0; i < 7; i++) {
-      const currentDate = new Date(baseDate);
-      currentDate.setDate(baseDate.getDate() + i);
-      const fullName = dateFns.format(currentDate, "eeee", { locale: locale2 });
-      if (fullName && fullName !== "eeee") {
-        names.push(fullName);
-      }
-      const shortName = dateFns.format(currentDate, "eee", { locale: locale2 });
-      if (shortName && shortName !== "eee" && shortName !== fullName) {
-        names.push(shortName);
-      }
-      const veryShortName = dateFns.format(currentDate, "ee", { locale: locale2 });
-      if (veryShortName && veryShortName !== "ee" && veryShortName !== shortName && veryShortName !== fullName) {
-        names.push(veryShortName);
-      }
-      const localeKey = getLocaleKey(locale2);
-      if (localeKey === "zh") {
-        const weekFormat = dateFns.format(currentDate, "eeee", { locale: locale2 }).replace("星期", "周");
-        if (weekFormat !== fullName) {
-          names.push(weekFormat);
-        }
-      }
-    }
-    return [...new Set(names)].filter(
-      (name) => name && name.length > 0 && !name.includes("e") && // 过滤掉格式化失败的情况
-      name !== "Invalid Date"
-    );
-  } catch {
-    return [];
-  }
-}
-function parseInvalidFormattedDate(input, targetFormat, locale2) {
-  const formatPatterns = {
-    "yyyy-MM-dd": /^(\d{4})-(\d{1,2})-(\d{1,2})$/,
-    "yyyy/MM/dd": /^(\d{4})\/(\d{1,2})\/(\d{1,2})$/,
-    "MM/dd/yyyy": /^(\d{1,2})\/(\d{1,2})\/(\d{4})$/,
-    "dd/MM/yyyy": /^(\d{1,2})\/(\d{1,2})\/(\d{4})$/,
-    "dd.MM.yyyy": /^(\d{1,2})\.(\d{1,2})\.(\d{4})$/,
-    "yyyy.MM.dd": /^(\d{4})\.(\d{1,2})\.(\d{1,2})$/,
-    yyyy年MM月dd日: /^(\d{4})年(\d{1,2})月(\d{1,2})日$/
-  };
-  const pattern = formatPatterns[targetFormat];
-  if (!pattern) {
-    return null;
-  }
-  const match = input.match(pattern);
-  if (!match) {
-    return null;
-  }
-  let year, month, day;
-  switch (targetFormat) {
-    case "yyyy-MM-dd":
-    case "yyyy/MM/dd":
-    case "yyyy.MM.dd":
-    case "yyyy年MM月dd日":
-      year = parseInt(match[1], 10);
-      month = parseInt(match[2], 10);
-      day = parseInt(match[3], 10);
-      break;
-    case "MM/dd/yyyy":
-      month = parseInt(match[1], 10);
-      day = parseInt(match[2], 10);
-      year = parseInt(match[3], 10);
-      break;
-    case "dd/MM/yyyy":
-    case "dd.MM.yyyy":
-      day = parseInt(match[1], 10);
-      month = parseInt(match[2], 10);
-      year = parseInt(match[3], 10);
-      break;
-    default:
-      return null;
-  }
-  const corrected = smartCorrectDate(year, month, day);
-  const correctedDate = new Date(corrected.year, corrected.month - 1, corrected.day);
-  return dateFns.isValid(correctedDate) ? correctedDate : null;
-}
-function getEnhancedPrediction(input, targetFormat = "yyyy-MM-dd") {
-  if (!input.trim()) return null;
-  const trimmedInput = input.trim();
-  try {
-    const parsed = parseDate(trimmedInput, {
-      format: targetFormat,
-      enableSmartCorrection: true,
-      enableNaturalLanguage: true,
-      enableRelativeDate: true
-    });
-    if (parsed && !isNaN(parsed.getTime())) {
-      const formatted = dateFns.format(parsed, targetFormat);
-      const description = generateDescription(trimmedInput, parsed);
-      const confidence = calculateConfidence(trimmedInput, parsed);
-      const type = determineType(trimmedInput);
-      return {
-        prediction: formatted,
-        description,
-        confidence,
-        type
-      };
-    }
-  } catch {
-  }
-  return null;
-}
-function generateDescription(input, parsedDate) {
-  const trimmedInput = input.trim().toLowerCase();
-  const now = /* @__PURE__ */ new Date();
-  const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
-  const parsed = new Date(parsedDate.getFullYear(), parsedDate.getMonth(), parsedDate.getDate());
-  const shortcuts = {
-    t: "今天",
-    today: "今天",
-    今: "今天",
-    今天: "今天",
-    y: "昨天",
-    yesterday: "昨天",
-    昨: "昨天",
-    tm: "明天",
-    tomorrow: "明天",
-    明: "明天"
-  };
-  if (shortcuts[trimmedInput]) {
-    return shortcuts[trimmedInput];
-  }
-  const dayDiff = Math.round((parsed.getTime() - today.getTime()) / (1e3 * 60 * 60 * 24));
-  if (dayDiff === 0) {
-    return "今天";
-  } else if (dayDiff === 1) {
-    return "明天";
-  } else if (dayDiff === -1) {
-    return "昨天";
-  } else if (dayDiff > 0 && dayDiff <= 7) {
-    return `${dayDiff}天后`;
-  } else if (dayDiff < 0 && dayDiff >= -7) {
-    return `${Math.abs(dayDiff)}天前`;
-  }
-  const year = parsedDate.getFullYear();
-  const month = parsedDate.getMonth() + 1;
-  const day = parsedDate.getDate();
-  const currentYear = now.getFullYear();
-  if (year === currentYear) {
-    return `当年${month}月${day}日`;
-  } else {
-    return `${year}年${month}月${day}日`;
-  }
-}
-function calculateConfidence(input, parsedDate) {
-  const trimmedInput = input.trim().toLowerCase();
-  const shortcuts = ["t", "today", "今", "今天", "y", "yesterday", "昨", "tm", "tomorrow", "明"];
-  if (shortcuts.includes(trimmedInput)) {
-    return 1;
-  }
-  if (/^\d+$/.test(trimmedInput)) {
-    const length = trimmedInput.length;
-    if (length === 8) return 0.95;
-    if (length === 6) return 0.9;
-    if (length === 4) return 0.85;
-    if (length === 3) return 0.8;
-    if (length === 2) return 0.75;
-    if (length === 1) return 0.6;
-    return 0.7;
-  }
-  if (trimmedInput.includes("年") || trimmedInput.includes("月") || trimmedInput.includes("日")) {
-    return 0.85;
-  }
-  if (trimmedInput.includes("-") || trimmedInput.includes("/")) {
-    return 0.8;
-  }
-  return 0.7;
-}
-function determineType(input) {
-  const trimmedInput = input.trim().toLowerCase();
-  const shortcuts = ["t", "today", "今", "今天", "y", "yesterday", "昨", "tm", "tomorrow", "明"];
-  if (shortcuts.includes(trimmedInput)) {
-    return "shortcut";
-  }
-  if (/^\d+$/.test(trimmedInput)) {
-    return "numeric";
-  }
-  if (trimmedInput.includes("天前") || trimmedInput.includes("天后") || trimmedInput.includes("周") || trimmedInput.includes("月") || trimmedInput.includes("ago") || trimmedInput.includes("later")) {
-    return "relative";
-  }
-  return "parsed";
-}
-var yearUtils = {
-  extractYear(input) {
-    if (dateFns.isDate(input) && dateFns.isValid(input)) {
-      return input.getFullYear();
-    }
-    if (typeof input === "number" && Number.isFinite(input)) {
-      return input;
-    }
-    return void 0;
-  },
-  /** 创建年份的开始日期 */
-  createYearDate(year) {
-    return new Date(year, 0, 1);
-  },
-  /** 获取当前年份 */
-  getCurrentYear() {
-    return (/* @__PURE__ */ new Date()).getFullYear();
-  },
-  /** 验证年份是否在有效范围内 */
-  isYearInRange(year, minYear, maxYear) {
-    const minValid = minYear === void 0 || year >= minYear;
-    const maxValid = maxYear === void 0 || year <= maxYear;
-    return minValid && maxValid;
-  }
-};
-var quarterUtils = {
-  /** 安全地从各种输入中提取年份数字 */
-  extractYear(input) {
-    if (dateFns.isDate(input) && dateFns.isValid(input)) {
-      return input.getFullYear();
-    }
-    if (typeof input === "number" && Number.isFinite(input)) {
-      return input;
-    }
-    return void 0;
-  },
-  /** 获取当前年份 */
-  getCurrentYear() {
-    return (/* @__PURE__ */ new Date()).getFullYear();
-  },
-  /** 获取当前季度数字 (1-4) */
-  getCurrentQuarterNumber() {
-    const currentMonth = (/* @__PURE__ */ new Date()).getMonth() + 1;
-    return Math.ceil(currentMonth / 3);
-  },
-  /** 验证年份是否在有效范围内 */
-  isYearInRange(year, minYear, maxYear) {
-    const minValid = minYear === void 0 || year >= minYear;
-    const maxValid = maxYear === void 0 || year <= maxYear;
-    return minValid && maxValid;
-  },
-  /** 创建季度的开始日期 */
-  createQuarterStartDate(quarter, year) {
-    const startMonth = (quarter - 1) * 3;
-    return new Date(year, startMonth, 1);
-  },
-  /** 创建季度的结束日期 */
-  createQuarterEndDate(quarter, year) {
-    const endMonth = (quarter - 1) * 3 + 2;
-    return new Date(year, endMonth + 1, 0);
-  }
-};
-function getQuarterMonths(quarter, locale$1 = locale.zhCN) {
-  const safeLocale = resolveLocale(locale$1);
-  const quarterStartMonth = (quarter - 1) * 3;
-  const months = [];
-  for (let i = 0; i < 3; i++) {
-    const monthIndex = quarterStartMonth + i;
-    const date = new Date(2024, monthIndex, 1);
-    const monthFormat = isChineseLocale(safeLocale) ? "MMMM" : "MMM";
-    const monthName = dateFns.format(date, monthFormat, { locale: safeLocale });
-    months.push(monthName);
-  }
-  return months;
-}
-function createQuarter(quarter, year, locale$1 = locale.zhCN) {
-  const safeLocale = resolveLocale(locale$1);
-  const quarterLabels = {
-    "zh-CN": (q) => `${["一", "二", "三", "四"][q - 1]}季度`,
-    "en-US": (q) => `Q${q}`,
-    "ja-JP": (q) => `第${q}四半期`,
-    "ko-KR": (q) => `${q}분기`,
-    "fr-FR": (q) => `T${q}`,
-    "de-DE": (q) => `Q${q}`,
-    "es-ES": (q) => `T${q}`
-  };
-  const localeCode = safeLocale.code || "en-US";
-  const labelGenerator = quarterLabels[localeCode] || quarterLabels["en-US"];
-  const label = labelGenerator(quarter);
-  const months = getQuarterMonths(quarter, locale$1);
-  return {
-    quarter,
-    year,
-    label,
-    months
-  };
-}
-function getCurrentQuarter(year, locale$1 = locale.zhCN) {
-  const currentYear = quarterUtils.getCurrentYear();
-  const currentQuarter = quarterUtils.getCurrentQuarterNumber();
-  return createQuarter(currentQuarter, currentYear, locale$1);
-}
-function getYearQuarters(year, locale$1 = locale.zhCN) {
-  return [1, 2, 3, 4].map((quarter) => createQuarter(quarter, year, locale$1));
-}
-function isQuarterEqual(quarter1, quarter2) {
-  return quarter1.quarter === quarter2.quarter && quarter1.year === quarter2.year;
-}
-function formatQuarter(quarter) {
-  return `${quarter.year}年 ${quarter.label}`;
-}
-var timeStringDateCache = null;
-var cacheDateKey = null;
-function dateToTimeString(date) {
-  if (!date) return null;
-  return dateFns.format(date, "HH:mm");
-}
-function timeStringToDate(timeStr) {
-  const today = /* @__PURE__ */ new Date();
-  const dateKey = today.toDateString();
-  if (cacheDateKey !== dateKey) {
-    timeStringDateCache = /* @__PURE__ */ new Map();
-    cacheDateKey = dateKey;
-  }
-  if (timeStringDateCache.has(timeStr)) {
-    return timeStringDateCache.get(timeStr);
-  }
-  const baseDate = dateFns.startOfDay(today);
-  const [hours, minutes] = timeStr.split(":").map(Number);
-  const dateObject = dateFns.setMinutes(dateFns.setHours(baseDate, hours), minutes);
-  timeStringDateCache.set(timeStr, dateObject);
-  return dateObject;
-}
-function normalizeTimeValue(value) {
-  return dateToTimeString(value ?? null);
-}
-function smartParseTimeValue(input, options) {
-  const { format: timeFormat, locale: locale2, strict } = options;
-  const dateFnsLocale = resolveLocale(locale2);
-  const result = {
-    input,
-    time: null,
-    formatted: "",
-    isValid: false,
-    error: null
-  };
-  if (!input.trim()) {
-    return result;
-  }
-  let parsedDate = null;
-  try {
-    const baseDate = new Date(2e3, 0, 1);
-    parsedDate = dateFns.parse(input, timeFormat, baseDate, { locale: dateFnsLocale });
-    if (dateFns.isValid(parsedDate)) {
-      const todayWithTime = timeStringToDate(dateFns.format(parsedDate, "HH:mm"));
-      result.time = todayWithTime;
-      result.formatted = dateFns.format(parsedDate, timeFormat, { locale: dateFnsLocale });
-      result.isValid = true;
-      return result;
-    }
-    for (const tryFormat of commonTimeFormats) {
-      if (tryFormat !== timeFormat) {
-        try {
-          parsedDate = dateFns.parse(input, tryFormat, baseDate, { locale: dateFnsLocale });
-          if (dateFns.isValid(parsedDate)) {
-            const todayWithTime = timeStringToDate(dateFns.format(parsedDate, "HH:mm"));
-            result.time = todayWithTime;
-            result.formatted = dateFns.format(parsedDate, timeFormat, { locale: dateFnsLocale });
-            result.isValid = true;
-            return result;
-          }
-        } catch {
-        }
-      }
-    }
-    const relaxedResult = tryRelaxedTimeParsing(input, timeFormat, locale2 || dateFnsLocale);
-    if (relaxedResult) {
-      const todayWithTime = timeStringToDate(relaxedResult);
-      result.time = todayWithTime;
-      result.formatted = dateFns.format(todayWithTime, timeFormat, { locale: dateFnsLocale });
-      result.isValid = true;
-      return result;
-    }
-    result.error = strict ? "Invalid time format" : null;
-  } catch (error) {
-    result.error = error instanceof Error ? error.message : "Parse error";
-  }
-  return result;
-}
-function tryRelaxedTimeParsing(input, targetFormat, locale2) {
-  const trimmedInput = input.trim();
-  if (!trimmedInput) return null;
-  resolveLocale(locale2);
-  try {
-    if (/^\d+$/.test(trimmedInput)) {
-      const len = trimmedInput.length;
-      if (len <= 2) {
-        const hours = parseInt(trimmedInput, 10);
-        if (hours >= 0 && hours <= 23) {
-          return `${hours.toString().padStart(2, "0")}:00`;
-        }
-      }
-      if (len === 3) {
-        const hours = parseInt(trimmedInput.substring(0, 1), 10);
-        const minutes = parseInt(trimmedInput.substring(1, 3), 10);
-        if (hours >= 0 && hours <= 23 && minutes >= 0 && minutes <= 59) {
-          return `${hours.toString().padStart(2, "0")}:${minutes.toString().padStart(2, "0")}`;
-        }
-      }
-      if (len === 4) {
-        const hours = parseInt(trimmedInput.substring(0, 2), 10);
-        const minutes = parseInt(trimmedInput.substring(2, 4), 10);
-        if (hours >= 0 && hours <= 23 && minutes >= 0 && minutes <= 59) {
-          return `${hours.toString().padStart(2, "0")}:${minutes.toString().padStart(2, "0")}`;
-        }
-      }
-    }
-    const ampmMatch = trimmedInput.match(/(\d{1,2})(?::(\d{1,2}))?\s*(am|pm|上午|下午)/i);
-    if (ampmMatch) {
-      let hours = parseInt(ampmMatch[1], 10);
-      const minutes = parseInt(ampmMatch[2] || "0", 10);
-      const period = ampmMatch[3].toLowerCase();
-      if (hours >= 1 && hours <= 12 && minutes >= 0 && minutes <= 59) {
-        if ((period === "pm" || period === "下午") && hours !== 12) {
-          hours += 12;
-        } else if ((period === "am" || period === "上午") && hours === 12) {
-          hours = 0;
-        }
-        return `${hours.toString().padStart(2, "0")}:${minutes.toString().padStart(2, "0")}`;
-      }
-    }
-    const chineseTimePatterns = [
-      { pattern: /(?:下午)\s*(\d{1,2})\s*[点时]/, hour: true, isPM: true },
-      { pattern: /(?:上午)\s*(\d{1,2})\s*[点时]/, hour: true, isPM: false },
-      { pattern: /(\d{1,2})\s*[点时]/, hour: true, isPM: null },
-      { pattern: /(\d{1,2})\s*分/, hour: false, isPM: null }
-    ];
-    let parsedHour = null;
-    let parsedMinute = null;
-    let isPM = null;
-    for (const { pattern, hour, isPM: isAfternoon } of chineseTimePatterns) {
-      const match = trimmedInput.match(pattern);
-      if (match) {
-        const num = parseInt(match[1], 10);
-        if (hour && num >= 1 && num <= 12) {
-          parsedHour = num;
-          isPM = isAfternoon !== void 0 ? isAfternoon : null;
-          break;
-        } else if (!hour && num >= 0 && num <= 59) {
-          parsedMinute = num;
-        }
-      }
-    }
-    if (parsedHour !== null) {
-      let finalHour = parsedHour;
-      if (isPM === true && finalHour !== 12) {
-        finalHour += 12;
-      } else if (isPM === false && finalHour === 12) {
-        finalHour = 0;
-      }
-      const minutes = parsedMinute || 0;
-      if (finalHour >= 0 && finalHour <= 23) {
-        return `${finalHour.toString().padStart(2, "0")}:${minutes.toString().padStart(2, "0")}`;
-      }
-    }
-    const timeMatch = trimmedInput.match(/(\d{1,2})[:.](\d{1,2})/);
-    if (timeMatch) {
-      const hours = parseInt(timeMatch[1], 10);
-      const minuteStr = timeMatch[2];
-      let minutes;
-      if (minuteStr.length === 1) {
-        minutes = parseInt(minuteStr, 10) * 10;
-      } else {
-        minutes = parseInt(minuteStr, 10);
-      }
-      if (hours >= 0 && hours <= 23 && minutes >= 0 && minutes <= 59) {
-        return `${hours.toString().padStart(2, "0")}:${minutes.toString().padStart(2, "0")}`;
-      }
-    }
-  } catch (error) {
-  }
-  return null;
-}
-var generateTimeOptions = (format10, step = 15) => {
-  const options = [];
-  const totalMinutes = 24 * 60;
-  const is12Hour = format10.toLowerCase().includes("a") || format10 === "12h";
-  for (let i = 0; i < totalMinutes; i += step) {
-    const hours = Math.floor(i / 60);
-    const minutes = i % 60;
-    if (is12Hour) {
-      const displayHour = hours === 0 ? 12 : hours > 12 ? hours - 12 : hours;
-      const ampm = hours < 12 ? "AM" : "PM";
-      const value = `${hours.toString().padStart(2, "0")}:${minutes.toString().padStart(2, "0")}`;
-      const label = `${displayHour}:${minutes.toString().padStart(2, "0")} ${ampm}`;
-      options.push({ value, label });
-    } else {
-      const value = `${hours.toString().padStart(2, "0")}:${minutes.toString().padStart(2, "0")}`;
-      const label = value;
-      options.push({ value, label });
-    }
-  }
-  return options;
-};
-var MonthCalendarTv = tcx.tcv({
-  slots: {
-    // 容器
-    container: "select-none",
-    // 头部
-    header: "grid items-center pt-2 pr-1 pl-3",
-    headerWrapper: "flex h-6 items-center",
-    title: "flex-1 truncate font-strong",
-    // 星期标题区域
-    weekdaysContainer: "grid gap-0 px-2 text-center",
-    weekday: "flex h-8 items-center justify-center text-body-small",
-    // 日期网格
-    daysGrid: "grid gap-0 px-2 pb-2",
-    // 日期单元格
-    day: [
-      "relative aspect-square w-full rounded-md",
-      "flex items-center justify-center",
-      "cursor-default select-none",
-      "border border-transparent",
-      "before:absolute before:z-0 before:content-['']",
-      "after:absolute after:z-1 after:content-['']"
-    ],
-    // 日期数字
-    dayNumber: "relative z-2",
-    weekNumber: "flex aspect-square items-center justify-center text-body-small",
-    emptyDay: ""
-  },
-  variants: {
-    // 是否在当前月
-    inMonth: {
-      false: {}
-    },
-    showWeekNumbers: {
-      true: {
-        header: "grid-cols-8",
-        daysGrid: "grid-cols-8",
-        weekdaysContainer: "grid-cols-8",
-        headerWrapper: "col-span-7"
-      },
-      false: {
-        header: "grid-cols-7",
-        daysGrid: "grid-cols-7",
-        weekdaysContainer: "grid-cols-7",
-        headerWrapper: "col-span-full"
-      }
-    },
-    // 是否选中
-    selected: {
-      true: {}
-    },
-    // 是否在选中范围内
-    inRange: {
-      true: {
-        day: "before:-inset-x-px before:inset-y-0.25"
-      }
-    },
-    // 是否在悬停范围内（范围选择的预览）
-    inHoverRange: {
-      true: {
-        day: "before:-inset-x-px before:inset-y-0.25"
-      }
-    },
-    // 是否为范围内第一个
-    isFirstInRange: {
-      true: {}
-    },
-    // 是否为范围内最后一个
-    isLastInRange: {
-      true: {}
-    },
-    // 是否为悬停范围内第一个
-    isFirstInHoverRange: {
-      true: {}
-    },
-    // 是否为悬停范围内最后一个
-    isLastInHoverRange: {
-      true: {}
-    },
-    // 是否为范围内行首
-    isFirstInRow: {
-      true: {}
-    },
-    // 是否为范围内行尾
-    isLastInRow: {
-      true: {}
-    },
-    // 是否为今天
-    today: {
-      true: {
-        day: "text-on-accent-foreground after:bg-danger-background after:inset-0.5 after:rounded-md"
-      }
-    },
-    // 是否高亮
-    highlighted: {
-      true: {
-        day: "after:border-selected-boundary after:inset-0.5 after:rounded-md after:border"
-      }
-    },
-    // 是否禁用
-    disabled: {
-      true: {},
-      false: {}
-    },
-    // 是否显示当月外的日期
-    showOutsideDays: {
-      false: {}
-    },
-    selectionMode: {
-      single: {},
-      multiple: {},
-      range: {}
-    },
-    variant: {
-      default: {
-        container: "bg-default-background",
-        weekdaysContainer: "text-secondary-foreground",
-        weekNumber: "text-secondary-foreground"
-      },
-      dark: {
-        container: "bg-menu-background text-white",
-        weekdaysContainer: "text-white/40",
-        weekNumber: "text-white/40"
-      }
-    }
-  },
-  compoundVariants: [
-    {
-      inMonth: false,
-      today: false,
-      variant: "default",
-      className: { day: "text-disabled-foreground" }
-    },
-    {
-      inMonth: false,
-      today: false,
-      variant: "dark",
-      className: { day: "text-white/40" }
-    },
-    {
-      inMonth: false,
-      showOutsideDays: false,
-      className: { day: "invisible" }
-    },
-    {
-      selectionMode: ["single", "multiple"],
-      selected: true,
-      today: false,
-      className: {
-        day: "after:inset-0 after:rounded-md"
-      }
-    },
-    {
-      selectionMode: ["single", "multiple"],
-      selected: true,
-      today: false,
-      variant: "default",
-      className: {
-        day: "after:bg-selected-background"
-      }
-    },
-    {
-      selectionMode: ["single", "multiple"],
-      selected: true,
-      today: false,
-      variant: "dark",
-      className: {
-        day: "after:bg-gray-600"
-      }
-    },
-    {
-      selectionMode: ["single", "multiple"],
-      selected: true,
-      today: true,
-      className: {
-        day: "after:ring-accent-background"
-      }
-    },
-    {
-      selectionMode: ["single", "multiple"],
-      selected: true,
-      today: true,
-      variant: "default",
-      className: {
-        day: "after:ring-offset-default-background after:ring-1 after:ring-offset-1"
-      }
-    },
-    {
-      selectionMode: ["single", "multiple"],
-      selected: true,
-      today: true,
-      variant: "dark",
-      className: {
-        day: "after:ring-2 after:ring-gray-600"
-      }
-    },
-    // Hover
-    {
-      disabled: false,
-      inRange: false,
-      inHoverRange: false,
-      className: {
-        day: "before:inset-0 before:rounded-md"
-      }
-    },
-    {
-      disabled: false,
-      inRange: false,
-      inHoverRange: false,
-      variant: "default",
-      className: {
-        day: "hover:before:bg-secondary-background"
-      }
-    },
-    {
-      disabled: false,
-      inRange: false,
-      inHoverRange: false,
-      variant: "dark",
-      className: {
-        day: "hover:before:bg-gray-700"
-      }
-    },
-    {
-      inHoverRange: true,
-      variant: "default",
-      className: {
-        day: "before:bg-secondary-background"
-      }
-    },
-    {
-      inRange: true,
-      inHoverRange: false,
-      variant: "default",
-      className: {
-        day: "before:bg-selected-background"
-      }
-    },
-    {
-      inHoverRange: true,
-      variant: "dark",
-      className: {
-        day: "before:bg-gray-600"
-      }
-    },
-    {
-      inRange: true,
-      inHoverRange: false,
-      variant: "dark",
-      className: {
-        day: "before:bg-accent-background/20"
-      }
-    },
-    // Rounded
-    {
-      isFirstInRow: true,
-      className: { day: "before:rounded-l-md" }
-    },
-    {
-      isLastInRow: true,
-      className: { day: "before:rounded-r-md" }
-    },
-    {
-      isFirstInRange: true,
-      isFirstInHoverRange: true,
-      inHoverRange: true,
-      className: { day: "before:rounded-l-md" }
-    },
-    {
-      isLastInRange: true,
-      isLastInHoverRange: true,
-      inHoverRange: true,
-      className: { day: "before:rounded-r-md" }
-    },
-    {
-      isFirstInRange: true,
-      inHoverRange: false,
-      className: { day: "before:rounded-l-md" }
-    },
-    {
-      isLastInRange: true,
-      inHoverRange: false,
-      className: { day: "before:rounded-r-md" }
-    },
-    {
-      isFirstInHoverRange: true,
-      className: { day: "before:rounded-l-md" }
-    },
-    {
-      isLastInHoverRange: true,
-      className: { day: "before:rounded-r-md" }
-    },
-    // Disabled
-    {
-      disabled: true,
-      variant: "default",
-      className: { day: "text-disabled-foreground" }
-    },
-    {
-      disabled: true,
-      variant: "dark",
-      className: { day: "text-white/20" }
-    }
-  ],
-  // 默认变体
-  defaultVariants: {
-    inMonth: true,
-    showWeekNumbers: false,
-    disabled: false,
-    showOutsideDays: true,
-    selected: false,
-    today: false,
-    highlighted: false,
-    inRange: false,
-    inHoverRange: false,
-    isFirstInRange: false,
-    isLastInRange: false,
-    selectionMode: "single",
-    variant: "default"
-  }
-});
-var MonthCalendarDateCell = React.memo(function MonthCalendarDateCell2(props) {
-  const { date, className, disabled, selected, onDateClick, onMouseEnter, onMouseLeave } = props;
-  const tv = MonthCalendarTv();
-  const handleClick = usehooksTs.useEventCallback(() => {
-    if (!disabled && onDateClick) {
-      onDateClick(date);
-    }
-  });
-  const handleMouseEnter = usehooksTs.useEventCallback(() => {
-    onMouseEnter(date);
-  });
-  const dateNumber = React.useMemo(() => date.getDate(), [date]);
-  const testId = React.useMemo(() => {
-    const year = date.getFullYear();
-    const month = date.getMonth() + 1;
-    const day = date.getDate();
-    return `${year}-${month}-${day}`;
-  }, [date]);
-  return /* @__PURE__ */ require$$0.jsx(
-    "div",
-    {
-      className,
-      onClick: handleClick,
-      onMouseEnter: handleMouseEnter,
-      onMouseLeave,
-      "data-testid": testId,
-      "data-selected": selected,
-      "data-disabled": disabled,
-      children: /* @__PURE__ */ require$$0.jsx("span", { className: tv.dayNumber(), children: dateNumber })
-    }
-  );
-});
-MonthCalendarDateCell.displayName = "MonthCalendarDateCell";
-var MonthCalendarHeader = React.memo(function MonthCalendarHeader2(props) {
-  const {
-    direction = "horizontal",
-    formattedMonthTitle,
-    currentMonthContainsToday,
-    handleToday,
-    handlePrevMonth,
-    handleNextMonth,
-    showWeekNumbers,
-    variant
-  } = props;
-  const tv = MonthCalendarTv({
-    showWeekNumbers,
-    variant
-  });
-  return /* @__PURE__ */ require$$0.jsxs("div", { className: tv.header(), children: [
-    showWeekNumbers && /* @__PURE__ */ require$$0.jsx("div", {}),
-    /* @__PURE__ */ require$$0.jsxs("div", { className: tv.headerWrapper(), children: [
-      /* @__PURE__ */ require$$0.jsx("div", { className: tv.title(), children: formattedMonthTitle }),
-      currentMonthContainsToday ? null : /* @__PURE__ */ require$$0.jsx(
-        index$1.IconButton,
-        {
-          variant,
-          onClick: handleToday,
-          "aria-label": "Today",
-          children: /* @__PURE__ */ require$$0.jsx(iconsReact.Undo, {})
-        }
-      ),
-      /* @__PURE__ */ require$$0.jsx(
-        index$1.IconButton,
-        {
-          variant,
-          onClick: handlePrevMonth,
-          "aria-label": "Previous month",
-          children: direction === "vertical" ? /* @__PURE__ */ require$$0.jsx(iconsReact.ChevronUpSmall, {}) : /* @__PURE__ */ require$$0.jsx(iconsReact.ChevronLeftSmall, {})
-        }
-      ),
-      /* @__PURE__ */ require$$0.jsx(
-        index$1.IconButton,
-        {
-          variant,
-          onClick: handleNextMonth,
-          "aria-label": "Next month",
-          children: direction === "vertical" ? /* @__PURE__ */ require$$0.jsx(iconsReact.ChevronDownSmall, {}) : /* @__PURE__ */ require$$0.jsx(iconsReact.ChevronRightSmall, {})
-        }
-      )
-    ] })
-  ] });
-});
-var MonthCalendarWeekDay = React.memo(function MonthCalendarWeekDay2(props) {
-  const { day } = props;
-  const tv = MonthCalendarTv();
-  return /* @__PURE__ */ require$$0.jsx("div", { className: tv.weekday(), children: day });
-});
-MonthCalendarWeekDay.displayName = "MonthCalendarWeekDay";
-var MonthCalendarWeekNumber = React.memo(function MonthCalendarWeekNumber2(props) {
-  const { className, weekNumber } = props;
-  const tv = MonthCalendarTv();
-  return /* @__PURE__ */ require$$0.jsx(
-    "div",
-    {
-      className: tcx.tcx(tv.weekNumber(), className),
-      "data-testid": `week-number-${weekNumber}`,
-      children: weekNumber
-    }
-  );
-});
-var MonthCalendar = React.memo(function MonthCalendar2(props) {
-  const {
-    className,
-    children,
-    direction = "horizontal",
-    currentMonth: propCurrentMonth,
-    dateComparisonMode = "date-only",
-    defaultValue,
-    disabledDates = [],
-    highlightDates = [],
-    highlightToday = true,
-    locale: locale$1 = locale.enUS,
-    maxDate,
-    minDate,
-    onChange,
-    onMonthChange,
-    readOnly = false,
-    selectionMode: propSelectionMode,
-    showOutsideDays = true,
-    showWeekNumbers = false,
-    timeZone = "Asia/Shanghai",
-    value,
-    weekStartsOn = 1,
-    weekdayNames: customWeekdayNames,
-    fixedGrid = true,
-    variant = "default"
-  } = props;
-  const dataFlowRef = React.useRef({
-    direction: "idle",
-    lastExternalValue: null,
-    isUserInteracting: false,
-    interactionType: null
-  });
-  const [currentValue, setCurrentValue] = useMergedValue.useMergedValue({
-    value,
-    defaultValue,
-    onChange
-  });
-  React.useEffect(() => {
-    const flow = dataFlowRef.current;
-    const normalizedValue = value ?? null;
-    const isExternalChange = !isCalendarValueEqual(
-      normalizedValue,
-      flow.lastExternalValue,
-      timeZone,
-      dateComparisonMode
-    );
-    if (isExternalChange) {
-      if (flow.isUserInteracting) {
-        flow.lastExternalValue = normalizedValue;
-        return;
-      }
-      flow.direction = "external";
-      flow.lastExternalValue = normalizedValue;
-      setTimeout(() => {
-        if (dataFlowRef.current.direction === "external") {
-          dataFlowRef.current.direction = "idle";
-        }
-      }, 50);
-    }
-  }, [value, currentValue, timeZone, dateComparisonMode]);
-  const [internalMonth, setInternalMonth] = React.useState(null);
-  const currentMonth = React.useMemo(() => {
-    if (propCurrentMonth) {
-      return propCurrentMonth;
-    }
-    if (internalMonth) {
-      return internalMonth;
-    }
-    const inferFromValue = inferMonthFromValue(currentValue);
-    if (inferFromValue) {
-      return inferFromValue;
-    }
-    return /* @__PURE__ */ new Date();
-  }, [propCurrentMonth, internalMonth, currentValue]);
-  const selectionMode = propSelectionMode || inferSelectionMode(currentValue);
-  const [hoverDate, setHoverDate] = React.useState(null);
-  const [selectingRange, setSelectingRange] = React.useState(false);
-  React.useEffect(() => {
-    const flow = dataFlowRef.current;
-    if (selectionMode === "range") {
-      if (selectingRange) {
-        flow.isUserInteracting = true;
-        flow.interactionType = "range-selecting";
-      } else if (flow.interactionType === "range-selecting") {
-        setTimeout(() => {
-          dataFlowRef.current.isUserInteracting = false;
-          dataFlowRef.current.interactionType = null;
-          dataFlowRef.current.direction = "idle";
-        }, 200);
-      }
-    }
-  }, [selectingRange, selectionMode]);
-  const weekdayNames = React.useMemo(() => {
-    if (customWeekdayNames) {
-      return customWeekdayNames;
-    }
-    return generateWeekdayNames(locale$1, weekStartsOn);
-  }, [customWeekdayNames, locale$1, weekStartsOn]);
-  const calendarDays = React.useMemo(() => {
-    return generateCalendarDays(currentMonth, weekStartsOn, fixedGrid);
-  }, [currentMonth, weekStartsOn, fixedGrid]);
-  const weekNumbers = React.useMemo(() => {
-    if (!showWeekNumbers) return [];
-    return calculateWeekNumbers(calendarDays, locale$1);
-  }, [showWeekNumbers, calendarDays, locale$1]);
-  const formattedMonthTitle = React.useMemo(() => {
-    return formatMonthTitle(currentMonth, locale$1);
-  }, [currentMonth, locale$1]);
-  const isToday2 = React.useCallback(
-    (date) => {
-      if (!highlightToday) return false;
-      return dateUtils.isSameDay(date, dateUtils.now());
-    },
-    [highlightToday]
-  );
-  const isDateDisabled = React.useCallback(
-    (date) => {
-      if (minDate && date < minDate) return true;
-      if (maxDate && date > maxDate) return true;
-      return disabledDates.some((disabledDate) => isSameDayInTimeZone(date, disabledDate, timeZone));
-    },
-    [minDate, maxDate, disabledDates, timeZone]
-  );
-  const isHighlighted = React.useCallback(
-    (date) => {
-      return highlightDates.some(
-        (highlightDate) => isSameDayInTimeZone(date, highlightDate, timeZone)
-      );
-    },
-    [highlightDates, timeZone]
-  );
-  const isSelected = React.useCallback(
-    (date) => {
-      if (!currentValue) return false;
-      if (selectionMode === "multiple" && Array.isArray(currentValue)) {
-        return currentValue.some(
-          (selectedDate) => isSameDayInTimeZone(date, selectedDate, timeZone)
-        );
-      }
-      if (selectionMode === "single" && currentValue instanceof Date) {
-        return isSameDayInTimeZone(date, currentValue, timeZone);
-      }
-      if (selectionMode === "range" && !Array.isArray(currentValue) && typeof currentValue === "object" && "start" in currentValue) {
-        const range = currentValue;
-        return isSameDayInTimeZone(date, range.start, timeZone) || isSameDayInTimeZone(date, range.end, timeZone);
-      }
-      return false;
-    },
-    [currentValue, selectionMode, timeZone]
-  );
-  const isInRange = React.useCallback(
-    (date) => {
-      if (selectionMode !== "range" || !currentValue || Array.isArray(currentValue) || typeof currentValue !== "object") {
-        return false;
-      }
-      const range = currentValue;
-      return isWithinRange(date, range.start, range.end, timeZone, dateComparisonMode);
-    },
-    [currentValue, selectionMode, timeZone, dateComparisonMode]
-  );
-  const handleToday = usehooksTs.useEventCallback(() => {
-    const today2 = dateUtils.now();
-    setInternalMonth(today2);
-    onMonthChange == null ? void 0 : onMonthChange(today2);
-  });
-  const handlePrevMonth = usehooksTs.useEventCallback(() => {
-    const prevMonth = dateUtils.addMonths(currentMonth, -1);
-    setInternalMonth(prevMonth);
-    onMonthChange == null ? void 0 : onMonthChange(prevMonth);
-  });
-  const handleNextMonth = usehooksTs.useEventCallback(() => {
-    const nextMonth = dateUtils.addMonths(currentMonth, 1);
-    setInternalMonth(nextMonth);
-    onMonthChange == null ? void 0 : onMonthChange(nextMonth);
-  });
-  const updateInternalValue = React.useCallback(
-    (newValue) => {
-      const flow = dataFlowRef.current;
-      flow.direction = "internal";
-      flow.lastExternalValue = newValue;
-      setCurrentValue(newValue);
-      setTimeout(() => {
-        if (dataFlowRef.current.direction === "internal") {
-          dataFlowRef.current.direction = "idle";
-        }
-      }, 100);
-    },
-    [setCurrentValue]
-  );
-  const handleDateClick = usehooksTs.useEventCallback((date) => {
-    if (readOnly) return;
-    if (isDateDisabled(date)) return;
-    const flow = dataFlowRef.current;
-    if (selectionMode === "range") {
-      const currentRange = currentValue && !Array.isArray(currentValue) && typeof currentValue === "object" ? currentValue : null;
-      if (!currentRange || !selectingRange) {
-        flow.isUserInteracting = true;
-        flow.interactionType = "range-selecting";
-        const newRange = { start: date, end: date };
-        updateInternalValue(newRange);
-        setSelectingRange(true);
-      } else {
-        const start = currentRange.start;
-        const end = date;
-        const orderedRange = {
-          start: start <= end ? start : end,
-          end: start <= end ? end : start
-        };
-        updateInternalValue(orderedRange);
-        setSelectingRange(false);
-        setHoverDate(null);
-      }
-    } else if (selectionMode === "multiple") {
-      flow.isUserInteracting = true;
-      flow.interactionType = "multi-selecting";
-      const currentDates = Array.isArray(currentValue) ? currentValue : [];
-      const isCurrentlySelected = currentDates.some(
-        (selectedDate) => isSameDayInTimeZone(date, selectedDate, timeZone)
-      );
-      let newSelectedDates;
-      if (isCurrentlySelected) {
-        newSelectedDates = currentDates.filter(
-          (selectedDate) => !isSameDayInTimeZone(date, selectedDate, timeZone)
-        );
-      } else {
-        newSelectedDates = [...currentDates, date];
-      }
-      updateInternalValue(newSelectedDates);
-      setTimeout(() => {
-        dataFlowRef.current.isUserInteracting = false;
-        dataFlowRef.current.interactionType = null;
-      }, 100);
-    } else {
-      flow.isUserInteracting = true;
-      flow.interactionType = "single-selecting";
-      updateInternalValue(date);
-      setTimeout(() => {
-        dataFlowRef.current.isUserInteracting = false;
-        dataFlowRef.current.interactionType = null;
-      }, 100);
-    }
-  });
-  const rangeHelpers = React.useMemo(() => {
-    const isSameDay3 = (date1, date2) => {
-      if (!date1 || !date2) return false;
-      return isSameDayInTimeZone(date1, date2, timeZone);
-    };
-    const currentRange = selectionMode === "range" && currentValue && !Array.isArray(currentValue) && typeof currentValue === "object" ? currentValue : null;
-    return {
-      isSameDay: isSameDay3,
-      isFirstInRange: (date) => {
-        if (!currentRange) return false;
-        return isSameDay3(date, currentRange.start);
-      },
-      isLastInRange: (date) => {
-        if (!currentRange) return false;
-        return isSameDay3(date, currentRange.end);
-      },
-      isInHoverRange: (date) => {
-        if (!selectingRange || !currentRange || !hoverDate) return false;
-        const minDate2 = currentRange.start <= hoverDate ? currentRange.start : hoverDate;
-        const maxDate2 = currentRange.start <= hoverDate ? hoverDate : currentRange.start;
-        return isWithinRange(date, minDate2, maxDate2, timeZone, dateComparisonMode);
-      },
-      isFirstInHoverRange: (date) => {
-        if (!selectingRange || !currentRange || !hoverDate) return false;
-        if (currentRange.start <= hoverDate) {
-          return isSameDay3(date, currentRange.start);
-        } else {
-          return isSameDay3(date, hoverDate);
-        }
-      },
-      isLastInHoverRange: (date) => {
-        if (!selectingRange || !currentRange || !hoverDate) return false;
-        if (currentRange.start <= hoverDate) {
-          return isSameDay3(date, hoverDate);
-        } else {
-          return isSameDay3(date, currentRange.start);
-        }
-      }
-    };
-  }, [currentValue, selectionMode, selectingRange, hoverDate, timeZone, dateComparisonMode]);
-  const handleMouseEnter = usehooksTs.useEventCallback((date) => {
-    if (!isDateDisabled(date)) {
-      setHoverDate(date);
-    }
-  });
-  const handleMouseLeave = usehooksTs.useEventCallback(() => {
-    setHoverDate(null);
-  });
-  const today = dateUtils.now();
-  const currentMonthContainsToday = dateUtils.isSameMonth(today, currentMonth);
-  const tv = MonthCalendarTv({
-    showWeekNumbers,
-    variant
-  });
-  return /* @__PURE__ */ require$$0.jsxs("div", { className: tcx.tcx(tv.container(), className), children: [
-    /* @__PURE__ */ require$$0.jsx(
-      MonthCalendarHeader,
-      {
-        formattedMonthTitle,
-        currentMonthContainsToday,
-        handleToday,
-        handlePrevMonth,
-        handleNextMonth,
-        showWeekNumbers,
-        variant,
-        direction
-      }
-    ),
-    /* @__PURE__ */ require$$0.jsxs("div", { className: tv.weekdaysContainer(), children: [
-      showWeekNumbers && /* @__PURE__ */ require$$0.jsx("div", {}),
-      weekdayNames.map((day, index2) => /* @__PURE__ */ require$$0.jsx(
-        MonthCalendarWeekDay,
-        {
-          day
-        },
-        index2
-      ))
-    ] }),
-    /* @__PURE__ */ require$$0.jsx("div", { className: tv.daysGrid(), children: calendarDays.map((date, index2) => {
-      const dayInMonth = date.getMonth() === currentMonth.getMonth();
-      const disabled = isDateDisabled(date);
-      const selected = isSelected(date);
-      const inRange = isInRange(date);
-      const highlighted = isHighlighted(date);
-      const today2 = isToday2(date);
-      const isFirstInRow = index2 % 7 === 0;
-      const isLastInRow = index2 % 7 === 6;
-      const inHoverRange = rangeHelpers.isInHoverRange(date);
-      const firstInRange = rangeHelpers.isFirstInRange(date);
-      const lastInRange = rangeHelpers.isLastInRange(date);
-      const firstInHoverRange = rangeHelpers.isFirstInHoverRange(date);
-      const lastInHoverRange = rangeHelpers.isLastInHoverRange(date);
-      const firstInRow = inRange && isFirstInRow && !firstInRange || inHoverRange && isFirstInRow && !firstInHoverRange;
-      const lastInRow = inRange && isLastInRow && !lastInRange || inHoverRange && isLastInRow && !lastInHoverRange;
-      const dayClasses = tv.day({
-        selected,
-        inRange,
-        today: today2,
-        highlighted,
-        disabled,
-        showOutsideDays,
-        inMonth: dayInMonth,
-        isFirstInRow: firstInRow,
-        isLastInRow: lastInRow,
-        isFirstInRange: firstInRange,
-        isLastInRange: lastInRange,
-        isFirstInHoverRange: firstInHoverRange,
-        isLastInHoverRange: lastInHoverRange,
-        inHoverRange,
-        selectionMode
-      });
-      const elements = [];
-      if (showWeekNumbers && isFirstInRow) {
-        const weekIndex = Math.floor(index2 / 7);
-        const weekNumber = weekNumbers[weekIndex];
-        elements.push(
-          /* @__PURE__ */ require$$0.jsx(
-            MonthCalendarWeekNumber,
-            {
-              weekNumber
-            },
-            `week-${weekIndex}`
-          )
-        );
-      }
-      elements.push(
-        /* @__PURE__ */ require$$0.jsx(
-          MonthCalendarDateCell,
-          {
-            date,
-            className: dayClasses,
-            disabled,
-            selected,
-            inRange,
-            inHoverRange,
-            onDateClick: handleDateClick,
-            onMouseEnter: handleMouseEnter,
-            onMouseLeave: handleMouseLeave
-          },
-          index2
-        )
-      );
-      return elements;
-    }) }),
-    children
-  ] });
-});
-MonthCalendar.displayName = "MonthCalendar";
-function useDateInput(props) {
-  const {
-    value,
-    defaultValue,
-    onChange,
-    disabled = false,
-    readOnly = false,
-    minDate,
-    maxDate,
-    step = 1,
-    shiftStep = 7,
-    metaStep = 30,
-    onPressStart,
-    onPressEnd,
-    format: dateFormat,
-    locale: propLocale,
-    enableCache = true,
-    enableKeyboardNavigation = true,
-    enableProfiling = false,
-    onEnterKeyDown,
-    ref
-  } = props;
-  const locale2 = resolveLocale(propLocale);
-  const innerRef = React.useRef(null);
-  const [inputValue, setInputValue] = React.useState("");
-  const dataFlowRef = React.useRef({
-    direction: "idle",
-    lastExternalValue: null,
-    lastInternalInput: "",
-    handledByEnter: false
-  });
-  const { shiftPressed, metaPressed } = useModifierKeys.useModifierKeys(disabled);
-  const getCurrentStep = React.useCallback(() => {
-    if (metaPressed) {
-      return metaStep;
-    }
-    if (shiftPressed) {
-      return shiftStep;
-    }
-    return step;
-  }, [metaPressed, shiftPressed, step, metaStep, shiftStep]);
-  const [innerValue, setValue] = useMergedValue.useMergedValue({
-    value,
-    defaultValue,
-    onChange,
-    allowEmpty: true
-  });
-  const isDateInRange = React.useCallback(
-    (date) => {
-      if (!dateFns.isValid(date)) return false;
-      if (minDate && date < minDate) return false;
-      if (maxDate && date > maxDate) return false;
-      return true;
-    },
-    [minDate, maxDate]
-  );
-  const clampDateToRange = React.useCallback(
-    (date) => {
-      if (!dateFns.isValid(date)) return null;
-      if (minDate && date < minDate) return minDate;
-      if (maxDate && date > maxDate) return maxDate;
-      return date;
-    },
-    [minDate, maxDate]
-  );
-  React.useEffect(() => {
-    const flow = dataFlowRef.current;
-    const normalizedValue = innerValue ?? null;
-    const isExternalChange = normalizedValue !== flow.lastExternalValue;
-    if (isExternalChange) {
-      flow.direction = "external";
-      flow.lastExternalValue = normalizedValue;
-      if (normalizedValue && dateFns.isValid(normalizedValue)) {
-        try {
-          const formatted = dateFns.format(normalizedValue, dateFormat || "yyyy-MM-dd", { locale: locale2 });
-          setInputValue(formatted);
-          flow.lastInternalInput = formatted;
-        } catch (error) {
-          console.warn("Date formatting error:", error);
-          try {
-            const formatted = dateFns.format(normalizedValue, "yyyy-MM-dd", { locale: locale2 });
-            setInputValue(formatted);
-            flow.lastInternalInput = formatted;
-          } catch {
-            const isoString = normalizedValue.toISOString().split("T")[0];
-            setInputValue(isoString);
-            flow.lastInternalInput = isoString;
-          }
-        }
-      } else {
-        setInputValue("");
-        flow.lastInternalInput = "";
-      }
-      setTimeout(() => {
-        flow.direction = "idle";
-      }, 50);
-    }
-  }, [innerValue, dateFormat, locale2]);
-  React.useEffect(() => {
-    if (innerValue && dateFns.isValid(innerValue) && dataFlowRef.current.direction !== "external") {
-      try {
-        const formatted = dateFns.format(innerValue, dateFormat || "yyyy-MM-dd", { locale: locale2 });
-        setInputValue(formatted);
-        dataFlowRef.current.lastInternalInput = formatted;
-      } catch (error) {
-        console.warn("Date formatting error:", error);
-        try {
-          const formatted = dateFns.format(innerValue, "yyyy-MM-dd", { locale: locale2 });
-          setInputValue(formatted);
-          dataFlowRef.current.lastInternalInput = formatted;
-        } catch {
-          const isoString = innerValue.toISOString().split("T")[0];
-          setInputValue(isoString);
-          dataFlowRef.current.lastInternalInput = isoString;
-        }
-      }
-    }
-  }, [dateFormat, locale2]);
-  const updateValue = React.useCallback(
-    (updateFn) => {
-      if (disabled || readOnly) return;
-      setValue((prev) => {
-        let baseDate = prev;
-        if (!baseDate || !dateFns.isValid(baseDate)) {
-          if (minDate && maxDate) {
-            const minTime = minDate.getTime();
-            const maxTime = maxDate.getTime();
-            const midTime = Math.floor((minTime + maxTime) / 2);
-            baseDate = new Date(midTime);
-          } else if (minDate) {
-            baseDate = minDate;
-          } else if (maxDate) {
-            baseDate = dateFns.addDays(maxDate, -1);
-          } else {
-            baseDate = /* @__PURE__ */ new Date();
-          }
-        }
-        const newDate = updateFn ? updateFn(baseDate) : baseDate;
-        if (!isDateInRange(newDate)) {
-          return prev;
-        }
-        if (!dateFns.isValid(newDate)) {
-          return prev;
-        }
-        return newDate;
-      });
-    },
-    [disabled, readOnly, setValue, isDateInRange, minDate, maxDate]
-  );
-  const parseWithOptimization = usehooksTs.useEventCallback((text) => {
-    const startTime = enableProfiling ? Date.now() : 0;
-    if (enableCache && parserConfig.cache.enabled) {
-      const cacheKey = `${text}-${dateFormat || "yyyy-MM-dd"}-${locale2.code || "unknown"}`;
-      const cached = parseCache.get(cacheKey);
-      if (cached !== null) {
-        return cached;
-      }
-    }
-    const result = parseDate(text, {
-      format: dateFormat || "yyyy-MM-dd",
-      locale: locale2,
-      enableSmartCorrection: true,
-      enableNaturalLanguage: true,
-      enableRelativeDate: true
-    });
-    if (enableCache && parserConfig.cache.enabled) {
-      const cacheKey = `${text}-${dateFormat || "yyyy-MM-dd"}-${locale2.code || "unknown"}`;
-      parseCache.set(cacheKey, result);
-    }
-    if (enableProfiling) {
-      const parseTime = Date.now() - startTime;
-      if (parseTime > parserConfig.performance.maxParseTime) {
-        console.warn(`Slow parse detected: ${parseTime}ms for "${text}"`);
-      }
-    }
-    return result;
-  });
-  const ensureValidDate = React.useCallback((date) => {
-    const year = date.getFullYear();
-    const month = date.getMonth() + 1;
-    const day = date.getDate();
-    const testDate = new Date(year, month - 1, day);
-    if (testDate.getFullYear() === year && testDate.getMonth() === month - 1 && testDate.getDate() === day) {
-      return date;
-    }
-    const corrected = smartCorrectDate(year, month, day);
-    return new Date(corrected.year, corrected.month - 1, corrected.day);
-  }, []);
-  const handleInputChange = usehooksTs.useEventCallback((newValue) => {
-    const flow = dataFlowRef.current;
-    if (flow.direction === "external") {
-      return;
-    }
-    flow.direction = "internal";
-    flow.lastInternalInput = newValue;
-    setInputValue(newValue);
-  });
-  const handleSubmit = usehooksTs.useEventCallback(() => {
-    const flow = dataFlowRef.current;
-    if (flow.direction === "external") {
-      return;
-    }
-    const text = inputValue.trim();
-    if (!text) {
-      setValue(null);
-      return;
-    }
-    const isRepeatInput = text === flow.lastInternalInput && flow.direction !== "internal";
-    try {
-      const parsedDate = parseWithOptimization(text);
-      if (parsedDate && dateFns.isValid(parsedDate)) {
-        const validDate = ensureValidDate(parsedDate);
-        let finalDate = validDate;
-        if (!isDateInRange(validDate)) {
-          const clampedDate = clampDateToRange(validDate);
-          if (!clampedDate) {
-            return;
-          }
-          finalDate = clampedDate;
-        }
-        const currentValue = flow.lastExternalValue;
-        const isSameDate = currentValue && finalDate.getFullYear() === currentValue.getFullYear() && finalDate.getMonth() === currentValue.getMonth() && finalDate.getDate() === currentValue.getDate();
-        if (!isRepeatInput && !isSameDate) {
-          setValue(finalDate);
-        }
-        try {
-          const formatted = dateFns.format(finalDate, dateFormat || "yyyy-MM-dd", { locale: locale2 });
-          if (formatted !== text) {
-            setInputValue(formatted);
-            flow.lastInternalInput = formatted;
-          } else if (!isRepeatInput) {
-            flow.lastInternalInput = text;
-          }
-        } catch (error) {
-          console.warn("Date formatting error in handleSubmit:", error);
-          try {
-            const formatted = dateFns.format(finalDate, "yyyy-MM-dd", { locale: locale2 });
-            setInputValue(formatted);
-            flow.lastInternalInput = formatted;
-          } catch {
-            if (!isRepeatInput) {
-              flow.lastInternalInput = text;
-            }
-          }
-        }
-      }
-    } catch (error) {
-      console.warn("Date parsing error:", error);
-    }
-    flow.direction = "idle";
-  });
-  const { isPressed: handlerPressed, pressMoveProps } = usePressMove.usePressMove({
-    disabled: disabled || readOnly,
-    onPressStart: (e) => {
-      onPressStart == null ? void 0 : onPressStart(e);
-    },
-    onPressEnd: (e) => {
-      onPressEnd == null ? void 0 : onPressEnd(e);
-    },
-    onPressMoveLeft: (delta) => {
-      updateValue((currentDate) => dateFns.addDays(currentDate, -delta * getCurrentStep()));
-    },
-    onPressMoveRight: (delta) => {
-      updateValue((currentDate) => dateFns.addDays(currentDate, delta * getCurrentStep()));
-    }
-  });
-  const handleKeyDown = usehooksTs.useEventCallback((event) => {
-    if (event.key === "Enter") {
-      event.preventDefault();
-      dataFlowRef.current.handledByEnter = true;
-      handleSubmit();
-      onEnterKeyDown == null ? void 0 : onEnterKeyDown();
-      setTimeout(() => {
-        const target = event.target;
-        target.blur();
-      }, 0);
-    } else if (enableKeyboardNavigation && (event.key === "ArrowUp" || event.key === "ArrowDown")) {
-      event.preventDefault();
-      const flow = dataFlowRef.current;
-      let baseDate;
-      if (innerValue && dateFns.isValid(innerValue)) {
-        baseDate = innerValue;
-      } else if (inputValue.trim()) {
-        const parsed = parseWithOptimization(inputValue.trim());
-        if (parsed && dateFns.isValid(parsed)) {
-          baseDate = parsed;
-        } else {
-          if (minDate && maxDate) {
-            const minTime = minDate.getTime();
-            const maxTime = maxDate.getTime();
-            const midTime = Math.floor((minTime + maxTime) / 2);
-            baseDate = new Date(midTime);
-          } else if (minDate) {
-            baseDate = minDate;
-          } else if (maxDate) {
-            baseDate = dateFns.addDays(maxDate, -1);
-          } else {
-            baseDate = /* @__PURE__ */ new Date();
-          }
-        }
-      } else {
-        if (minDate && maxDate) {
-          const minTime = minDate.getTime();
-          const maxTime = maxDate.getTime();
-          const midTime = Math.floor((minTime + maxTime) / 2);
-          baseDate = new Date(midTime);
-        } else if (minDate) {
-          baseDate = minDate;
-        } else if (maxDate) {
-          baseDate = dateFns.addDays(maxDate, -1);
-        } else {
-          baseDate = /* @__PURE__ */ new Date();
-        }
-      }
-      const isUp = event.key === "ArrowUp";
-      const increment = isUp ? -1 : 1;
-      let newDate;
-      if (event.altKey) {
-        newDate = dateFns.addMonths(baseDate, increment);
-      } else if (event.shiftKey) {
-        newDate = dateFns.addWeeks(baseDate, increment);
-      } else {
-        newDate = dateFns.addDays(baseDate, increment);
-      }
-      if (!isDateInRange(newDate)) {
-        const clampedDate = clampDateToRange(newDate);
-        if (!clampedDate || clampedDate.getTime() === baseDate.getTime()) {
-          return;
-        }
-        newDate = clampedDate;
-      }
-      try {
-        const formatted = dateFns.format(newDate, dateFormat || "yyyy-MM-dd", { locale: locale2 });
-        flow.direction = "internal";
-        flow.lastInternalInput = formatted;
-        setInputValue(formatted);
-        setTimeout(() => {
-          if (flow.direction === "internal") {
-            flow.lastExternalValue = newDate;
-            setValue(newDate);
-            flow.direction = "idle";
-          }
-        }, 10);
-      } catch (error) {
-        console.warn("Date formatting error during keyboard navigation:", error);
-        flow.direction = "internal";
-        setValue(newDate);
-        flow.lastExternalValue = newDate;
-        flow.direction = "idle";
-      }
-    }
-  });
-  const handleBlur = usehooksTs.useEventCallback(() => {
-    const flow = dataFlowRef.current;
-    if (flow.handledByEnter) {
-      flow.handledByEnter = false;
-      return;
-    }
-    if (flow.direction === "external") {
-      return;
-    }
-    setTimeout(() => {
-      if (dataFlowRef.current.direction !== "external") {
-        handleSubmit();
-      }
-    }, 100);
-  });
-  const inputProps = {
-    ref: mergeRefs.mergeRefs(innerRef, ref),
-    disabled,
-    readOnly,
-    value: inputValue,
-    onChange: handleInputChange,
-    onKeyDown: handleKeyDown,
-    onBlur: handleBlur
-  };
-  const handlerProps = {
-    ...pressMoveProps,
-    ref: pressMoveProps.ref
-  };
-  return {
-    handlerPressed,
-    inputProps,
-    handlerProps,
-    updateValue,
-    currentValue: innerValue
-  };
-}
-var DateInput = React.forwardRef((props, ref) => {
-  const {
-    enableCache = true,
-    enableKeyboardNavigation = true,
-    enableProfiling = false,
-    enablePrediction = false,
-    format: propFormat,
-    locale: propLocale = locale.enUS,
-    maxDate,
-    minDate,
-    onChange,
-    onEnterKeyDown,
-    placeholder = "Enter date...",
-    prefixElement = /* @__PURE__ */ require$$0.jsx(iconsReact.FieldTypeDate, {}),
-    suffixElement,
-    value,
-    ...rest
-  } = props;
-  const [prediction, setPrediction] = React.useState(null);
-  const locale$1 = resolveLocale(propLocale);
-  const dateFormat = React.useMemo(() => {
-    if (propFormat) {
-      return propFormat;
-    }
-    const localeKey = typeof propLocale === "string" ? propLocale : locale$1.code || "en-US";
-    const isCurrentYear = value && dateFns.isThisYear(value);
-    if (localeKey.startsWith("zh")) {
-      return isCurrentYear ? "MMM do eee" : "yy年 MMM do eee";
-    }
-    if (localeKey.startsWith("ja")) {
-      return isCurrentYear ? "MMM do（eee）" : "yy年 MMM do（eee）";
-    }
-    if (localeKey.startsWith("ko")) {
-      return isCurrentYear ? "MMM do（eee）" : "yy년 MMM do（eee）";
-    }
-    if (localeKey.startsWith("de")) {
-      return isCurrentYear ? "EE dd.MM" : "EE dd.MM ''yy";
-    }
-    if (localeKey.startsWith("fr")) {
-      return isCurrentYear ? "EE dd MM" : "EE dd MM yy";
-    }
-    if (localeKey.startsWith("es")) {
-      return isCurrentYear ? "EE dd MM" : "EE dd MM ''yy";
-    }
-    return isCurrentYear ? "EE MM dd" : "EE MM dd ''yy";
-  }, [propFormat, value, propLocale, locale$1]);
-  const { inputProps, handlerProps } = useDateInput({
-    value,
-    onChange,
-    disabled: rest.disabled,
-    readOnly: rest.readOnly,
-    minDate,
-    maxDate,
-    step: 1,
-    shiftStep: 7,
-    format: dateFormat,
-    locale: locale$1,
-    enableCache,
-    enableProfiling,
-    onEnterKeyDown,
-    ref
-  });
-  React.useEffect(() => {
-    if (!enablePrediction || !inputProps.value) {
-      setPrediction(null);
-      return;
-    }
-    const inputValue = inputProps.value;
-    if (inputValue.trim()) {
-      const predictionResult = getEnhancedPrediction(inputValue, dateFormat);
-      setPrediction(predictionResult);
-    } else {
-      setPrediction(null);
-    }
-  }, [inputProps.value, dateFormat, enablePrediction]);
-  const renderPrediction = () => {
-    if (!prediction) return null;
-    const { description, confidence } = prediction;
-    const confidenceColor = confidence >= 0.9 ? "text-green-600" : confidence >= 0.7 ? "text-blue-600" : "text-gray-600";
-    return /* @__PURE__ */ require$$0.jsx("span", { className: `text-body-small ${confidenceColor}`, children: description });
-  };
-  return /* @__PURE__ */ require$$0.jsxs(
-    index.TextField,
-    {
-      ...inputProps,
-      placeholder,
-      ...rest,
-      children: [
-        rest.children,
-        prefixElement && /* @__PURE__ */ require$$0.jsx(index.TextField.Prefix, { children: /* @__PURE__ */ require$$0.jsx(
-          "div",
-          {
-            ...handlerProps,
-            className: tcx.tcx(
-              "cursor-ew-resize",
-              rest.disabled ? "text-disabled-foreground" : "text-secondary-foreground",
-              rest.variant === "dark" ? "text-white/50" : void 0
-            ),
-            children: prefixElement
-          }
-        ) }),
-        suffixElement && /* @__PURE__ */ require$$0.jsx(index.TextField.Suffix, { className: "text-secondary-foreground w-full min-w-0 px-2", children: suffixElement }),
-        enablePrediction && /* @__PURE__ */ require$$0.jsx(index.TextField.Description, { children: renderPrediction() })
-      ]
-    }
-  );
-});
-DateInput.displayName = "DateInput";
-var TimeCalendar = React.memo(function TimeCalendar2(props) {
-  const {
-    value,
-    defaultValue,
-    onChange,
-    format: timeFormat = "HH:mm",
-    step = 15,
-    className,
-    children,
-    readOnly = false,
-    ...rest
-  } = props;
-  const scrollRef = React.useRef(null);
-  const elementsRef = React.useRef([]);
-  const customElementRef = React.useRef(null);
-  const hasInitialScrolled = React.useRef(false);
-  const lastSelectedIndexRef = React.useRef(null);
-  const isInternalOperationRef = React.useRef(false);
-  const [activeIndex, setActiveIndex] = React.useState(null);
-  const [isScrolling, setIsScrolling] = React.useState(false);
-  const [innerValue, setValue] = useMergedValue.useMergedValue({
-    value,
-    defaultValue,
-    onChange,
-    allowEmpty: true
-  });
-  const timeOptions = React.useMemo(() => {
-    return generateTimeOptions(timeFormat, step);
-  }, [timeFormat, step]);
-  const normalizedTimeString = React.useMemo(() => {
-    return normalizeTimeValue(innerValue);
-  }, [innerValue]);
-  const formatTo12Hour = React.useCallback((timeStr) => {
-    const [hour, minute] = timeStr.split(":").map(Number);
-    const displayHour = hour === 0 ? 12 : hour > 12 ? hour - 12 : hour;
-    const ampm = hour < 12 ? "AM" : "PM";
-    return `${displayHour}:${minute.toString().padStart(2, "0")} ${ampm}`;
-  }, []);
-  const customTimeOption = React.useMemo(() => {
-    if (!normalizedTimeString) return null;
-    const hasStandardOption = timeOptions.some((option) => option.value === normalizedTimeString);
-    if (hasStandardOption) return null;
-    const is12Hour = timeFormat.toLowerCase().includes("a") || timeFormat === "12h";
-    return {
-      value: normalizedTimeString,
-      label: is12Hour ? formatTo12Hour(normalizedTimeString) : normalizedTimeString
-    };
-  }, [normalizedTimeString, timeOptions, timeFormat, formatTo12Hour]);
-  const renderTimeLabel = React.useCallback(
-    (label) => {
-      const is12Hour = timeFormat.toLowerCase().includes("a") || timeFormat === "12h";
-      if (is12Hour && label.includes(" ")) {
-        const [timePart, ampmPart] = label.split(" ");
-        return /* @__PURE__ */ require$$0.jsxs(require$$0.Fragment, { children: [
-          /* @__PURE__ */ require$$0.jsx("span", { children: timePart }),
-          /* @__PURE__ */ require$$0.jsx("span", { className: "flex-1 text-right text-white/40", children: ampmPart })
-        ] });
-      }
-      return label;
-    },
-    [timeFormat]
-  );
-  const selectedIndex = React.useMemo(() => {
-    if (!normalizedTimeString) return null;
-    const index2 = timeOptions.findIndex((option) => option.value === normalizedTimeString);
-    return index2 === -1 ? -1 : index2;
-  }, [normalizedTimeString, timeOptions]);
-  const needsDivider = React.useMemo(() => {
-    const is12Hour = timeFormat.toLowerCase().includes("a") || timeFormat === "12h";
-    if (!is12Hour) return () => false;
-    return (index2) => {
-      return index2 > 0 && timeOptions[index2].label.includes("PM") && timeOptions[index2 - 1].label.includes("AM");
-    };
-  }, [timeFormat, timeOptions]);
-  const createPrefixElement = React.useCallback((isSelected) => {
-    return isSelected ? /* @__PURE__ */ require$$0.jsx(iconsReact.Check, {}) : /* @__PURE__ */ require$$0.jsx(require$$0.Fragment, {});
-  }, []);
-  const scrollTimeoutRef = React.useRef(null);
-  const mousePositionRef = React.useRef(null);
-  const handleScroll = usehooksTs.useEventCallback(() => {
-    if (!isScrolling) {
-      setIsScrolling(true);
-      setActiveIndex(null);
-    }
-    if (scrollTimeoutRef.current) {
-      clearTimeout(scrollTimeoutRef.current);
-    }
-    scrollTimeoutRef.current = setTimeout(() => {
-      var _a;
-      setIsScrolling(false);
-      if (mousePositionRef.current) {
-        const elementUnderMouse = document.elementFromPoint(
-          mousePositionRef.current.x,
-          mousePositionRef.current.y
-        );
-        if (customElementRef.current && (customElementRef.current === elementUnderMouse || customElementRef.current.contains(elementUnderMouse))) {
-          setActiveIndex(-1);
-          return;
-        }
-        const elements = elementsRef.current;
-        for (let i = 0; i < elements.length; i++) {
-          if (elements[i] && (elements[i] === elementUnderMouse || ((_a = elements[i]) == null ? void 0 : _a.contains(elementUnderMouse)))) {
-            setActiveIndex(i);
-            break;
-          }
-        }
-      }
-    }, 200);
-  });
-  const handleMouseMove = usehooksTs.useEventCallback((event) => {
-    mousePositionRef.current = { x: event.clientX, y: event.clientY };
-  });
-  React.useEffect(() => {
-    return () => {
-      if (scrollTimeoutRef.current) {
-        clearTimeout(scrollTimeoutRef.current);
-      }
-    };
-  }, []);
-  React.useEffect(() => {
-    var _a;
-    if (selectedIndex === -1) {
-      const customElement = customElementRef.current;
-      if (!customElement || !scrollRef.current) {
-        return;
-      }
-      const previousSelectedIndex2 = lastSelectedIndexRef.current;
-      const isSelectedIndexChanged2 = previousSelectedIndex2 !== selectedIndex;
-      lastSelectedIndexRef.current = selectedIndex;
-      const shouldScroll2 = !hasInitialScrolled.current || // 初始化滚动
-      isSelectedIndexChanged2 && !isInternalOperationRef.current;
-      if (shouldScroll2) {
-        const isInitialScroll = !hasInitialScrolled.current;
-        if (isInitialScroll) {
-          scrollRef.current.scrollTo({
-            top: 0,
-            behavior: "auto"
-          });
-        } else {
-          customElement.scrollIntoView({
-            block: "nearest",
-            behavior: "smooth"
-          });
-        }
-        if (!hasInitialScrolled.current) {
-          hasInitialScrolled.current = true;
-        }
-      }
-      if (isInternalOperationRef.current) {
-        isInternalOperationRef.current = false;
-      }
-      return;
-    }
-    if (selectedIndex === null || !scrollRef.current || !elementsRef.current[selectedIndex]) {
-      return;
-    }
-    const previousSelectedIndex = lastSelectedIndexRef.current;
-    const isSelectedIndexChanged = previousSelectedIndex !== selectedIndex;
-    lastSelectedIndexRef.current = selectedIndex;
-    const shouldScroll = !hasInitialScrolled.current || // 初始化滚动
-    isSelectedIndexChanged && !isInternalOperationRef.current;
-    if (shouldScroll) {
-      const isInitialScroll = !hasInitialScrolled.current;
-      if (isInitialScroll) {
-        (_a = elementsRef.current[selectedIndex]) == null ? void 0 : _a.scrollIntoView({
-          block: "center",
-          behavior: "auto"
-        });
-      } else {
-        const container = scrollRef.current;
-        const element = elementsRef.current[selectedIndex];
-        if (container && element) {
-          const containerRect = container.getBoundingClientRect();
-          const elementRect = element.getBoundingClientRect();
-          const margin = 8;
-          const elementTop = elementRect.top - containerRect.top + container.scrollTop;
-          const elementBottom = elementTop + elementRect.height;
-          const visibleTop = container.scrollTop + margin;
-          const visibleBottom = container.scrollTop + container.clientHeight - margin;
-          let targetScrollTop = container.scrollTop;
-          if (elementTop < visibleTop) {
-            targetScrollTop = elementTop - margin;
-          } else if (elementBottom > visibleBottom) {
-            targetScrollTop = elementBottom - container.clientHeight + margin;
-          }
-          if (targetScrollTop !== container.scrollTop) {
-            container.scrollTo({
-              top: targetScrollTop
-            });
-          }
-        }
-      }
-      if (!hasInitialScrolled.current) {
-        hasInitialScrolled.current = true;
-      }
-    }
-    if (isInternalOperationRef.current) {
-      isInternalOperationRef.current = false;
-    }
-  }, [selectedIndex]);
-  const handleTimeSelect = usehooksTs.useEventCallback((timeValue) => {
-    if (readOnly) return;
-    isInternalOperationRef.current = true;
-    const dateValue = timeStringToDate(timeValue);
-    setValue(dateValue);
-  });
-  const handleMouseEnter = usehooksTs.useEventCallback((index2) => {
-    if (isScrolling) {
-      return;
-    }
-    setActiveIndex(index2);
-  });
-  const handleMouseLeave = usehooksTs.useEventCallback(() => {
-    setActiveIndex(null);
-  });
-  const handleClick = usehooksTs.useEventCallback((timeValue) => {
-    handleTimeSelect(timeValue);
-  });
-  return /* @__PURE__ */ require$$0.jsxs(
-    index$2.Menus,
-    {
-      ref: scrollRef,
-      onScroll: handleScroll,
-      onMouseLeave: handleMouseLeave,
-      onMouseMove: handleMouseMove,
-      className,
-      "data-testid": "time-calendar-menu",
-      ...rest,
-      children: [
-        customTimeOption && /* @__PURE__ */ require$$0.jsxs(require$$0.Fragment, { children: [
-          /* @__PURE__ */ require$$0.jsx(
-            index$2.Menus.Item,
-            {
-              ref: (node) => {
-                customElementRef.current = node;
-              },
-              selected: selectedIndex === -1,
-              active: !isScrolling && activeIndex === -1,
-              onClick: () => handleClick(customTimeOption.value),
-              onMouseEnter: () => handleMouseEnter(-1),
-              prefixElement: createPrefixElement(selectedIndex === -1),
-              variant: "highlight",
-              "data-testid": "custom-time-item",
-              children: renderTimeLabel(customTimeOption.label)
-            }
-          ),
-          /* @__PURE__ */ require$$0.jsx(index$2.Menus.Divider, { "data-testid": "custom-time-divider" })
-        ] }),
-        timeOptions.map((option, index2) => {
-          const isAmToPmTransition = needsDivider(index2);
-          const isItemSelected = selectedIndex === index2;
-          const isItemActive = !isScrolling && activeIndex === index2;
-          return /* @__PURE__ */ require$$0.jsxs(React.Fragment, { children: [
-            isAmToPmTransition && /* @__PURE__ */ require$$0.jsx(index$2.Menus.Divider, { "data-testid": "ampm-divider" }),
-            /* @__PURE__ */ require$$0.jsx(
-              index$2.Menus.Item,
-              {
-                ref: (node) => {
-                  elementsRef.current[index2] = node;
-                },
-                selected: isItemSelected,
-                active: isItemActive,
-                onClick: () => handleClick(option.value),
-                onMouseEnter: () => handleMouseEnter(index2),
-                prefixElement: createPrefixElement(isItemSelected),
-                variant: "highlight",
-                "data-testid": option.value,
-                children: renderTimeLabel(option.label)
-              }
-            )
-          ] }, option.value);
-        }),
-        children
-      ]
-    }
-  );
-});
-TimeCalendar.displayName = "TimeCalendar";
-function useTimeInput(props) {
-  const {
-    value,
-    defaultValue,
-    onChange,
-    disabled = false,
-    readOnly = false,
-    minTime,
-    maxTime,
-    step = 1,
-    shiftStep = 15,
-    metaStep = 60,
-    onPressStart,
-    onPressEnd,
-    format: timeFormat = "HH:mm",
-    locale: propLocale,
-    enableKeyboardNavigation = true,
-    enableProfiling = false,
-    onEnterKeyDown,
-    ref
-  } = props;
-  const locale2 = resolveLocale(propLocale);
-  const innerRef = React.useRef(null);
-  const [inputValue, setInputValue] = React.useState("");
-  const dataFlowRef = React.useRef({
-    direction: "idle",
-    lastExternalValue: null,
-    lastInternalInput: "",
-    handledByEnter: false
-  });
-  const { shiftPressed, metaPressed } = useModifierKeys.useModifierKeys(disabled);
-  const getCurrentStep = React.useCallback(() => {
-    if (metaPressed) {
-      return metaStep;
-    }
-    if (shiftPressed) {
-      return shiftStep;
-    }
-    return step;
-  }, [metaPressed, shiftPressed, step, metaStep, shiftStep]);
-  const [innerValue, setValue] = useMergedValue.useMergedValue({
-    value,
-    defaultValue,
-    onChange,
-    allowEmpty: true
-  });
-  const isTimeInRange = React.useCallback(
-    (time) => {
-      if (!time) return false;
-      if (minTime && time < minTime) return false;
-      if (maxTime && time > maxTime) return false;
-      return true;
-    },
-    [minTime, maxTime]
-  );
-  const clampTimeToRange = React.useCallback(
-    (time) => {
-      if (!time) return null;
-      if (minTime && time < minTime) return minTime;
-      if (maxTime && time > maxTime) return maxTime;
-      return time;
-    },
-    [minTime, maxTime]
-  );
-  React.useEffect(() => {
-    const flow = dataFlowRef.current;
-    const normalizedValue = innerValue ?? null;
-    const isExternalChange = normalizedValue !== flow.lastExternalValue;
-    if (isExternalChange) {
-      flow.direction = "external";
-      flow.lastExternalValue = normalizedValue;
-      if (normalizedValue) {
-        const formatted = dateFns.format(normalizedValue, timeFormat, { locale: locale2 });
-        setInputValue(formatted);
-        flow.lastInternalInput = formatted;
-      } else {
-        setInputValue("");
-        flow.lastInternalInput = "";
-      }
-      setTimeout(() => {
-        flow.direction = "idle";
-      }, 50);
-    }
-  }, [innerValue, timeFormat, locale2]);
-  React.useEffect(() => {
-    if (innerValue && dataFlowRef.current.direction !== "external") {
-      const formatted = dateFns.format(innerValue, timeFormat, { locale: locale2 });
-      setInputValue(formatted);
-      dataFlowRef.current.lastInternalInput = formatted;
-    }
-  }, [timeFormat, locale2, innerValue]);
-  const updateValue = React.useCallback(
-    (updateFn) => {
-      if (disabled || readOnly) return;
-      setValue((prev) => {
-        let baseTime = prev;
-        if (!baseTime) {
-          if (minTime && maxTime) {
-            const minTotalMinutes = minTime.getHours() * 60 + minTime.getMinutes();
-            let maxTotalMinutes = maxTime.getHours() * 60 + maxTime.getMinutes();
-            if (maxTotalMinutes < minTotalMinutes) {
-              maxTotalMinutes += 24 * 60;
-            }
-            const midTotalMinutes = Math.floor((minTotalMinutes + maxTotalMinutes) / 2);
-            const hours = Math.floor(midTotalMinutes / 60) % 24;
-            const minutes = midTotalMinutes % 60;
-            baseTime = dateFns.setMinutes(dateFns.setHours(dateFns.startOfDay(/* @__PURE__ */ new Date()), hours), minutes);
-          } else if (minTime) {
-            baseTime = minTime;
-          } else if (maxTime) {
-            baseTime = dateFns.addMinutes(maxTime, -60);
-          } else {
-            baseTime = /* @__PURE__ */ new Date();
-          }
-        }
-        const newTime = updateFn ? updateFn(baseTime) : baseTime;
-        if (!isTimeInRange(newTime)) {
-          return prev;
-        }
-        return newTime;
-      });
-    },
-    [disabled, readOnly, setValue, isTimeInRange, minTime, maxTime]
-  );
-  const parseWithOptimization = usehooksTs.useEventCallback((text) => {
-    const startTime = enableProfiling ? Date.now() : 0;
-    const result = smartParseTimeValue(text, {
-      format: timeFormat,
-      locale: propLocale,
-      strict: false
-    });
-    if (enableProfiling) {
-      const parseTime = Date.now() - startTime;
-      if (parseTime > 100) {
-        console.warn(`Slow time parse detected: ${parseTime}ms for "${text}"`);
-      }
-    }
-    return result.isValid && result.time ? result.time : null;
-  });
-  const handleInputChange = usehooksTs.useEventCallback((newValue) => {
-    const flow = dataFlowRef.current;
-    if (flow.direction === "external") {
-      return;
-    }
-    flow.direction = "internal";
-    flow.lastInternalInput = newValue;
-    setInputValue(newValue);
-  });
-  const handleSubmit = usehooksTs.useEventCallback(() => {
-    const flow = dataFlowRef.current;
-    if (flow.direction === "external") {
-      return;
-    }
-    const text = inputValue.trim();
-    if (!text) {
-      setValue(null);
-      return;
-    }
-    const isRepeatInput = text === flow.lastInternalInput && flow.direction !== "internal";
-    try {
-      const parsedTime = parseWithOptimization(text);
-      if (parsedTime) {
-        let finalTime = parsedTime;
-        if (!isTimeInRange(parsedTime)) {
-          const clampedTime = clampTimeToRange(parsedTime);
-          if (!clampedTime) {
-            return;
-          }
-          finalTime = clampedTime;
-        }
-        const currentValue = flow.lastExternalValue;
-        const isSameTime = currentValue && finalTime.getTime() === currentValue.getTime();
-        if (!isRepeatInput && !isSameTime) {
-          setValue(finalTime);
-        }
-        const formatted = dateFns.format(finalTime, timeFormat, { locale: locale2 });
-        if (formatted !== text) {
-          setInputValue(formatted);
-          flow.lastInternalInput = formatted;
-        } else if (!isRepeatInput) {
-          flow.lastInternalInput = text;
-        }
-      }
-    } catch (error) {
-      console.warn("Time parsing error:", error);
-    }
-    flow.direction = "idle";
-  });
-  const { isPressed: handlerPressed, pressMoveProps } = usePressMove.usePressMove({
-    disabled: disabled || readOnly,
-    onPressStart: (e) => {
-      onPressStart == null ? void 0 : onPressStart(e);
-    },
-    onPressEnd: (e) => {
-      onPressEnd == null ? void 0 : onPressEnd(e);
-    },
-    onPressMoveLeft: (delta) => {
-      updateValue((currentTime) => {
-        return dateFns.addMinutes(currentTime, -delta * getCurrentStep());
-      });
-    },
-    onPressMoveRight: (delta) => {
-      updateValue((currentTime) => {
-        return dateFns.addMinutes(currentTime, delta * getCurrentStep());
-      });
-    }
-  });
-  const handleKeyDown = usehooksTs.useEventCallback((event) => {
-    if (event.key === "Enter") {
-      event.preventDefault();
-      dataFlowRef.current.handledByEnter = true;
-      handleSubmit();
-      onEnterKeyDown == null ? void 0 : onEnterKeyDown();
-      setTimeout(() => {
-        const target = event.target;
-        target.blur();
-      }, 0);
-    } else if (enableKeyboardNavigation && (event.key === "ArrowUp" || event.key === "ArrowDown")) {
-      event.preventDefault();
-      const flow = dataFlowRef.current;
-      let baseTime;
-      if (innerValue) {
-        baseTime = innerValue;
-      } else if (inputValue.trim()) {
-        const parsed = parseWithOptimization(inputValue.trim());
-        baseTime = parsed || /* @__PURE__ */ new Date();
-      } else {
-        baseTime = /* @__PURE__ */ new Date();
-      }
-      const isUp = event.key === "ArrowUp";
-      const increment = isUp ? -1 : 1;
-      let newDate;
-      if (event.altKey || event.metaKey) {
-        newDate = dateFns.addMinutes(baseTime, increment * metaStep);
-      } else if (event.shiftKey) {
-        newDate = dateFns.addMinutes(baseTime, increment * shiftStep);
-      } else {
-        newDate = dateFns.addMinutes(baseTime, increment * step);
-      }
-      if (!isTimeInRange(newDate)) {
-        const clampedTime = clampTimeToRange(newDate);
-        if (!clampedTime || clampedTime.getTime() === baseTime.getTime()) {
-          return;
-        }
-        newDate = clampedTime;
-      }
-      const formatted = dateFns.format(newDate, timeFormat, { locale: locale2 });
-      flow.direction = "internal";
-      flow.lastInternalInput = formatted;
-      setInputValue(formatted);
-      setValue(newDate);
-      setTimeout(() => {
-        flow.direction = "idle";
-      }, 0);
-    }
-  });
-  const handleBlur = usehooksTs.useEventCallback(() => {
-    const flow = dataFlowRef.current;
-    if (flow.handledByEnter) {
-      flow.handledByEnter = false;
-      return;
-    }
-    if (flow.direction === "external") {
-      return;
-    }
-    setTimeout(() => {
-      if (dataFlowRef.current.direction !== "external") {
-        handleSubmit();
-      }
-    }, 100);
-  });
-  const inputProps = {
-    ref: mergeRefs.mergeRefs(innerRef, ref),
-    disabled,
-    readOnly,
-    value: inputValue,
-    onChange: handleInputChange,
-    onKeyDown: handleKeyDown,
-    onBlur: handleBlur
-  };
-  const handlerProps = {
-    ...pressMoveProps,
-    ref: pressMoveProps.ref
-  };
-  return {
-    handlerPressed,
-    inputProps,
-    handlerProps,
-    updateValue,
-    currentValue: innerValue
-  };
-}
-var TimeInput = React.forwardRef((props, ref) => {
-  const {
-    // 时间相关属性
-    defaultValue,
-    value,
-    onChange,
-    format: propFormat = "HH:mm",
-    locale: propLocale = locale.enUS,
-    minTime,
-    maxTime,
-    step = 1,
-    shiftStep = 15,
-    metaStep = 60,
-    // 交互相关属性
-    enableCache = true,
-    enableKeyboardNavigation = true,
-    enableProfiling = false,
-    onEnterKeyDown,
-    // UI 相关属性
-    placeholder = "Enter time...",
-    prefixElement = /* @__PURE__ */ require$$0.jsx(iconsReact.Clock, {}),
-    suffixElement,
-    // TextField 属性
-    ...rest
-  } = props;
-  const locale$1 = resolveLocale(propLocale);
-  const { inputProps, handlerProps } = useTimeInput({
-    value,
-    defaultValue,
-    onChange,
-    disabled: rest.disabled,
-    readOnly: rest.readOnly,
-    minTime,
-    maxTime,
-    step,
-    shiftStep,
-    metaStep,
-    format: propFormat,
-    locale: locale$1,
-    enableKeyboardNavigation,
-    enableProfiling,
-    onEnterKeyDown,
-    ref
-  });
-  return /* @__PURE__ */ require$$0.jsxs(
-    index.TextField,
-    {
-      ...inputProps,
-      placeholder,
-      ...rest,
-      children: [
-        prefixElement && /* @__PURE__ */ require$$0.jsx(index.TextField.Prefix, { children: /* @__PURE__ */ require$$0.jsx(
-          "div",
-          {
-            ...handlerProps,
-            className: tcx.tcx(
-              "cursor-ew-resize",
-              rest.disabled ? "text-disabled-foreground" : "text-secondary-foreground",
-              rest.variant === "dark" ? "text-white/50" : void 0
-            ),
-            children: prefixElement
-          }
-        ) }),
-        suffixElement && /* @__PURE__ */ require$$0.jsx(index.TextField.Suffix, { className: "text-secondary-foreground w-full min-w-0 px-2", children: suffixElement })
-      ]
-    }
-  );
-});
-TimeInput.displayName = "TimeInput";
-var QuarterCalendarTv = tcx.tcv({
-  slots: {
-    // 容器
-    container: "select-none",
-    // 头部
-    header: "flex items-center pt-2 pr-1 pl-3",
-    title: "flex-1 truncate font-strong",
-    navigation: "flex h-6 items-center",
-    // 季度网格
-    quartersGrid: "grid grid-cols-4 gap-0 px-2 pb-2",
-    // 季度单元格
-    quarterCell: [
-      "relative w-full rounded-md py-2",
-      "flex flex-col items-center justify-center",
-      "cursor-default select-none",
-      "border border-transparent",
-      "before:absolute before:z-0 before:content-['']",
-      "after:absolute after:z-1 after:content-['']"
-    ],
-    // 季度标题
-    quarterTitle: "relative z-2 font-strong",
-    // 月份列表
-    monthsList: "relative z-2 mt-2",
-    monthItem: ""
-  },
-  variants: {
-    variant: {
-      default: {
-        container: "bg-default-background"
-      },
-      dark: {
-        container: "bg-menu-background text-white"
-      }
-    },
-    // 是否选中
-    selected: {
-      true: {}
-    },
-    // 是否为当前季度
-    current: {
-      true: {
-        quarterCell: "text-on-accent-foreground after:bg-danger-background after:inset-0.5 after:rounded-md"
-      }
-    },
-    // 是否在范围内
-    inRange: {
-      true: {},
-      false: {}
-    },
-    // 是否禁用
-    disabled: {
-      true: {},
-      false: {}
-    }
-  },
-  compoundVariants: [
-    {
-      inRange: false,
-      current: false,
-      variant: "default",
-      className: { quarterCell: "text-disabled-foreground" }
-    },
-    {
-      inRange: false,
-      current: false,
-      variant: "dark",
-      className: { quarterCell: "text-white/40" }
-    },
-    // Selected
-    {
-      selected: true,
-      current: false,
-      className: {
-        quarterCell: "after:inset-0.25 after:rounded-md"
-      }
-    },
-    {
-      selected: true,
-      current: false,
-      variant: "default",
-      className: {
-        quarterCell: "after:bg-selected-background"
-      }
-    },
-    {
-      selected: true,
-      current: false,
-      variant: "dark",
-      className: {
-        quarterCell: "after:bg-gray-600"
-      }
-    },
-    {
-      selected: true,
-      current: true,
-      className: {
-        quarterCell: "after:ring-accent-background"
-      }
-    },
-    {
-      selected: true,
-      current: true,
-      variant: "default",
-      className: {
-        quarterCell: "after:ring-offset-default-background after:ring-1 after:ring-offset-1"
-      }
-    },
-    {
-      selected: true,
-      current: true,
-      variant: "dark",
-      className: {
-        quarterCell: "after:ring-2 after:ring-gray-600"
-      }
-    },
-    // Hover
-    {
-      disabled: false,
-      className: {
-        quarterCell: "before:inset-0.25 before:rounded-md"
-      }
-    },
-    {
-      disabled: false,
-      variant: "default",
-      className: {
-        quarterCell: "hover:before:bg-secondary-background"
-      }
-    },
-    {
-      disabled: false,
-      variant: "dark",
-      className: {
-        quarterCell: "hover:before:bg-gray-700"
-      }
-    },
-    // Disabled
-    {
-      disabled: true,
-      variant: "default",
-      className: { quarterCell: "text-disabled-foreground" }
-    },
-    {
-      disabled: true,
-      variant: "dark",
-      className: { quarterCell: "text-white/20" }
-    }
-  ],
-  defaultVariants: {
-    variant: "default"
-  }
-});
-var QuarterCalendarCell = React.forwardRef(
-  (props, ref) => {
-    const { className, onClick, quarterItem, variant = "default" } = props;
-    const tv = QuarterCalendarTv({ variant });
-    const handleClick = usehooksTs.useEventCallback(() => {
-      if (quarterItem.isDisabled) return;
-      onClick(quarterItem.quarter);
-    });
-    return /* @__PURE__ */ require$$0.jsxs(
-      "button",
-      {
-        ref,
-        type: "button",
-        className: tcx.tcx(className),
-        disabled: quarterItem.isDisabled,
-        onClick: handleClick,
-        "aria-label": formatQuarter(quarterItem.quarter),
-        "aria-pressed": quarterItem.isSelected,
-        "data-testid": `${quarterItem.quarter.year}-Q${quarterItem.quarter.quarter}`,
-        "data-selected": quarterItem.isSelected,
-        "data-current": quarterItem.isCurrent,
-        "data-disabled": quarterItem.isDisabled,
-        "data-in-range": quarterItem.isInRange,
-        children: [
-          /* @__PURE__ */ require$$0.jsx("div", { className: tv.quarterTitle(), children: quarterItem.quarter.label }),
-          /* @__PURE__ */ require$$0.jsx("div", { className: tv.monthsList(), children: quarterItem.quarter.months.map((month, index2) => /* @__PURE__ */ require$$0.jsx(
-            "div",
-            {
-              className: tv.monthItem(),
-              children: month
-            },
-            index2
-          )) })
-        ]
-      }
-    );
-  }
-);
-QuarterCalendarCell.displayName = "QuarterCalendarCell";
-var QuarterCalendarHeader = React.forwardRef(
-  (props, ref) => {
-    const {
-      className,
-      currentYear,
-      currentYearContainsToday,
-      handleNext,
-      handlePrevious,
-      handleToday,
-      isNextDisabled,
-      isPrevDisabled,
-      variant = "default"
-    } = props;
-    const tv = QuarterCalendarTv({ variant });
-    const handleTodayClick = usehooksTs.useEventCallback(() => {
-      handleToday();
-    });
-    return /* @__PURE__ */ require$$0.jsxs(
-      "div",
-      {
-        ref,
-        className: tcx.tcx(tv.header(), className),
-        "data-testid": "quarter-calendar-header",
-        children: [
-          /* @__PURE__ */ require$$0.jsx(
-            "h3",
-            {
-              className: tv.title(),
-              "data-testid": "year-title",
-              children: dateFns.format(currentYear, "yyyy")
-            }
-          ),
-          /* @__PURE__ */ require$$0.jsxs(
-            "div",
-            {
-              className: tv.navigation(),
-              "data-testid": "quarter-navigation",
-              children: [
-                currentYearContainsToday ? null : /* @__PURE__ */ require$$0.jsx(
-                  index$1.IconButton,
-                  {
-                    variant,
-                    onClick: handleTodayClick,
-                    "aria-label": "Back to current year",
-                    "data-testid": "today-button",
-                    children: /* @__PURE__ */ require$$0.jsx(iconsReact.Undo, {})
-                  }
-                ),
-                /* @__PURE__ */ require$$0.jsx(
-                  index$1.IconButton,
-                  {
-                    variant,
-                    onClick: handlePrevious,
-                    disabled: isPrevDisabled,
-                    "aria-label": "Previous year",
-                    "data-testid": "prev-button",
-                    children: /* @__PURE__ */ require$$0.jsx(iconsReact.ChevronLeftSmall, {})
-                  }
-                ),
-                /* @__PURE__ */ require$$0.jsx(
-                  index$1.IconButton,
-                  {
-                    variant,
-                    onClick: handleNext,
-                    disabled: isNextDisabled,
-                    "aria-label": "Next year",
-                    "data-testid": "next-button",
-                    children: /* @__PURE__ */ require$$0.jsx(iconsReact.ChevronRightSmall, {})
-                  }
-                )
-              ]
-            }
-          )
-        ]
-      }
-    );
-  }
-);
-QuarterCalendarHeader.displayName = "QuarterCalendarHeader";
-var QuarterCalendar = React.forwardRef((props, ref) => {
-  const {
-    value,
-    currentYear: propCurrentYear,
-    onChange,
-    onNavigate,
-    className,
-    children,
-    minYear,
-    maxYear,
-    disabledQuarters = [],
-    disabled = false,
-    readOnly = false,
-    startYear: propStartYear,
-    locale: locale$1 = locale.enUS,
-    variant = "default",
-    defaultValue
-  } = props;
-  const handleQuarterChange = React.useCallback(
-    (quarter) => {
-      onChange == null ? void 0 : onChange(quarter ?? null);
-    },
-    [onChange]
-  );
-  const [selectedQuarter, setSelectedQuarter] = useMergedValue.useMergedValue({
-    value,
-    defaultValue,
-    onChange: handleQuarterChange
-  });
-  const safeLocale = resolveLocale(locale$1);
-  const currentYearNum = React.useMemo(() => {
-    const extracted = quarterUtils.extractYear(propCurrentYear);
-    return extracted ?? quarterUtils.getCurrentYear();
-  }, [propCurrentYear]);
-  const yearConstraints = React.useMemo(
-    () => ({
-      min: quarterUtils.extractYear(minYear),
-      max: quarterUtils.extractYear(maxYear),
-      disabled: disabledQuarters
-    }),
-    [minYear, maxYear, disabledQuarters]
-  );
-  const [internalYear, setInternalYear] = React.useState(() => {
-    const propStart = quarterUtils.extractYear(propStartYear);
-    return propStart ?? currentYearNum;
-  });
-  const displayYear = quarterUtils.extractYear(propStartYear) ?? internalYear;
-  const actualCurrentQuarter = React.useMemo(() => {
-    return getCurrentQuarter(void 0, safeLocale);
-  }, [safeLocale]);
-  const quarters = React.useMemo(() => {
-    const yearQuarters = getYearQuarters(displayYear, safeLocale);
-    return yearQuarters.map((quarter) => {
-      const isSelected = selectedQuarter ? isQuarterEqual(selectedQuarter, quarter) : false;
-      const isCurrent = isQuarterEqual(actualCurrentQuarter, quarter);
-      const isInRange = quarterUtils.isYearInRange(
-        quarter.year,
-        yearConstraints.min,
-        yearConstraints.max
-      );
-      const isDisabled = disabled || yearConstraints.disabled.some(
-        (dq) => dq.quarter === quarter.quarter && dq.year === quarter.year
-      ) || !isInRange;
-      return {
-        quarter,
-        isSelected,
-        isCurrent,
-        isDisabled,
-        isInRange
-      };
-    });
-  }, [displayYear, safeLocale, selectedQuarter, actualCurrentQuarter, disabled, yearConstraints]);
-  const handleQuarterSelect = usehooksTs.useEventCallback((quarter) => {
-    if (disabled || readOnly) return;
-    const quarterItem = quarters.find((q) => isQuarterEqual(q.quarter, quarter));
-    if (quarterItem == null ? void 0 : quarterItem.isDisabled) return;
-    setSelectedQuarter(quarter);
-  });
-  const navigateYear = React.useCallback(
-    (direction) => {
-      if (disabled) return;
-      const offset = direction === "prev" ? -1 : 1;
-      const newYear = displayYear + offset;
-      if (direction === "prev" && yearConstraints.min !== void 0) {
-        if (newYear < yearConstraints.min) return;
-      }
-      if (direction === "next" && yearConstraints.max !== void 0) {
-        if (newYear > yearConstraints.max) return;
-      }
-      onNavigate == null ? void 0 : onNavigate(direction, newYear);
-      if (propStartYear === void 0) {
-        setInternalYear(newYear);
-      }
-    },
-    [disabled, displayYear, yearConstraints, onNavigate, propStartYear]
-  );
-  const handlePrevious = usehooksTs.useEventCallback(() => navigateYear("prev"));
-  const handleNext = usehooksTs.useEventCallback(() => navigateYear("next"));
-  const handleToday = usehooksTs.useEventCallback(() => {
-    const todayYear = quarterUtils.getCurrentYear();
-    const todayQuarter = getCurrentQuarter(void 0, safeLocale);
-    setInternalYear(todayYear);
-    setSelectedQuarter(todayQuarter);
-  });
-  const navigationState = React.useMemo(() => {
-    if (disabled) return { isPrevDisabled: true, isNextDisabled: true };
-    const isPrevDisabled = yearConstraints.min !== void 0 && displayYear <= yearConstraints.min;
-    const isNextDisabled = yearConstraints.max !== void 0 && displayYear >= yearConstraints.max;
-    return { isPrevDisabled, isNextDisabled };
-  }, [disabled, yearConstraints, displayYear]);
-  const displayInfo = React.useMemo(() => {
-    const todayYear = quarterUtils.getCurrentYear();
-    const currentYearContainsToday = displayYear === todayYear;
-    return {
-      currentYearContainsToday
-    };
-  }, [displayYear]);
-  const tv = QuarterCalendarTv({ variant });
-  return /* @__PURE__ */ require$$0.jsxs(
-    "div",
-    {
-      ref,
-      className: tcx.tcx(tv.container(), className),
-      "data-testid": "quarter-calendar",
-      children: [
-        /* @__PURE__ */ require$$0.jsx(
-          QuarterCalendarHeader,
-          {
-            currentYear: displayYear,
-            currentYearContainsToday: displayInfo.currentYearContainsToday,
-            handleNext,
-            handlePrevious,
-            handleToday,
-            isNextDisabled: navigationState.isNextDisabled,
-            isPrevDisabled: navigationState.isPrevDisabled,
-            variant
-          }
-        ),
-        /* @__PURE__ */ require$$0.jsx(
-          "div",
-          {
-            className: tv.quartersGrid(),
-            "data-testid": "quarters-grid",
-            children: quarters.map((quarterItem) => /* @__PURE__ */ require$$0.jsx(
-              QuarterCalendarCell,
-              {
-                className: tv.quarterCell({
-                  selected: quarterItem.isSelected,
-                  current: quarterItem.isCurrent,
-                  disabled: quarterItem.isDisabled,
-                  inRange: quarterItem.isInRange
-                }),
-                quarterItem,
-                onClick: handleQuarterSelect,
-                variant
-              },
-              `${quarterItem.quarter.year}-${quarterItem.quarter.quarter}`
-            ))
-          }
-        ),
-        children
-      ]
-    }
-  );
-});
-QuarterCalendar.displayName = "QuarterCalendar";
-var YearCalendarTv = tcx.tcv({
-  slots: {
-    // 容器
-    container: "select-none",
-    // 头部
-    header: "flex items-center pt-2 pr-1 pl-3",
-    title: "flex-1 truncate font-strong",
-    navigation: "flex h-6 items-center",
-    // 年份网格
-    yearsGrid: "grid grid-cols-3 gap-0 px-2 pb-2",
-    // 年份单元格
-    yearCell: [
-      "relative h-6 w-full rounded-md",
-      "flex items-center justify-center",
-      "cursor-default select-none",
-      "border border-transparent",
-      "before:absolute before:z-0 before:content-['']",
-      "after:absolute after:z-1 after:content-['']"
-    ],
-    // 年份数字
-    yearText: "relative z-2"
-  },
-  variants: {
-    // 是否选中
-    selected: {
-      true: {}
-    },
-    // 是否为当前年份
-    current: {
-      true: {
-        yearCell: "text-on-accent-foreground after:bg-danger-background after:inset-0.5 after:rounded-md"
-      }
-    },
-    // 是否禁用
-    disabled: {
-      true: {}
-    },
-    // 是否在范围内
-    inRange: {
-      true: {},
-      false: {}
-    },
-    variant: {
-      default: {
-        container: "bg-default-background"
-      },
-      dark: {
-        container: "bg-menu-background text-white"
-      }
-    }
-  },
-  compoundVariants: [
-    {
-      inRange: false,
-      current: false,
-      variant: "default",
-      className: { yearCell: "text-disabled-foreground" }
-    },
-    {
-      inRange: false,
-      current: false,
-      variant: "dark",
-      className: { yearCell: "text-white/40" }
-    },
-    // Selected
-    {
-      selected: true,
-      current: false,
-      className: {
-        yearCell: "after:inset-0 after:rounded-md"
-      }
-    },
-    {
-      selected: true,
-      current: false,
-      variant: "default",
-      className: {
-        yearCell: "after:bg-selected-background"
-      }
-    },
-    {
-      selected: true,
-      current: false,
-      variant: "dark",
-      className: {
-        yearCell: "after:bg-gray-600"
-      }
-    },
-    {
-      selected: true,
-      current: true,
-      className: {
-        yearCell: "after:ring-accent-background"
-      }
-    },
-    {
-      selected: true,
-      current: true,
-      variant: "default",
-      className: {
-        yearCell: "after:ring-offset-default-background after:ring-1 after:ring-offset-1"
-      }
-    },
-    {
-      selected: true,
-      current: true,
-      variant: "dark",
-      className: {
-        yearCell: "after:ring-2 after:ring-gray-600"
-      }
-    },
-    // Hover
-    {
-      disabled: false,
-      className: {
-        yearCell: "before:inset-0 before:rounded-md"
-      }
-    },
-    {
-      disabled: false,
-      variant: "default",
-      className: {
-        yearCell: "hover:before:bg-secondary-background"
-      }
-    },
-    {
-      disabled: false,
-      variant: "dark",
-      className: {
-        yearCell: "hover:before:bg-gray-700"
-      }
-    },
-    // Disabled
-    {
-      disabled: true,
-      variant: "default",
-      className: { yearCell: "text-disabled-foreground" }
-    },
-    {
-      disabled: true,
-      variant: "dark",
-      className: { yearCell: "text-white/20" }
-    }
-  ],
-  defaultVariants: {
-    variant: "default"
-  }
-});
-var YearCalendarCell = React.memo(function YearCalendarCell2(props) {
-  const tv = YearCalendarTv();
-  const { className, yearItem, onClick } = props;
-  const handleClick = usehooksTs.useEventCallback(() => {
-    if (!yearItem.isDisabled && onClick) {
-      onClick(yearItem.year);
-    }
-  });
-  const yearNumber = yearItem.year.getFullYear();
-  return /* @__PURE__ */ require$$0.jsx(
-    "div",
-    {
-      className,
-      onClick: handleClick,
-      "data-testid": yearNumber,
-      "data-selected": yearItem.isSelected,
-      "data-current": yearItem.isCurrent,
-      "data-disabled": yearItem.isDisabled,
-      "data-in-range": yearItem.isInRange,
-      children: /* @__PURE__ */ require$$0.jsx("span", { className: tv.yearText(), children: yearNumber })
-    }
-  );
-});
-YearCalendarCell.displayName = "YearCalendarCell";
-var YearCalendarHeader = React.memo(function YearCalendarHeader2(props) {
-  const {
-    endDisplayYear,
-    handleNext,
-    handlePrevious,
-    handleToday,
-    isNextDisabled,
-    isPrevDisabled,
-    startDisplayYear,
-    currentYearContainsToday,
-    variant
-  } = props;
-  const tv = YearCalendarTv();
-  return /* @__PURE__ */ require$$0.jsxs("div", { className: tv.header(), children: [
-    /* @__PURE__ */ require$$0.jsxs(
-      "h3",
-      {
-        className: tv.title(),
-        "data-testid": "year-range-title",
-        children: [
-          startDisplayYear,
-          " - ",
-          endDisplayYear
-        ]
-      }
-    ),
-    currentYearContainsToday ? null : /* @__PURE__ */ require$$0.jsx(
-      index$1.IconButton,
-      {
-        variant,
-        onClick: handleToday,
-        "aria-label": "Back to current year",
-        "data-testid": "today-button",
-        children: /* @__PURE__ */ require$$0.jsx(iconsReact.Undo, {})
-      }
-    ),
-    /* @__PURE__ */ require$$0.jsxs(
-      "div",
-      {
-        className: tv.navigation(),
-        "data-testid": "year-navigation",
-        children: [
-          /* @__PURE__ */ require$$0.jsx(
-            index$1.IconButton,
-            {
-              variant,
-              onClick: handlePrevious,
-              disabled: isPrevDisabled,
-              "aria-label": "Previous year",
-              "data-testid": "prev-button",
-              children: /* @__PURE__ */ require$$0.jsx(iconsReact.ChevronLeftSmall, {})
-            }
-          ),
-          /* @__PURE__ */ require$$0.jsx(
-            index$1.IconButton,
-            {
-              variant,
-              onClick: handleNext,
-              disabled: isNextDisabled,
-              "aria-label": "Next year",
-              "data-testid": "next-button",
-              children: /* @__PURE__ */ require$$0.jsx(iconsReact.ChevronRightSmall, {})
-            }
-          )
-        ]
-      }
-    )
-  ] });
-});
-YearCalendarHeader.displayName = "YearCalendarHeader";
-var YearCalendar = React.forwardRef((props, ref) => {
-  const {
-    value,
-    currentYear: propCurrentYear,
-    onChange,
-    onNavigate,
-    className,
-    children,
-    minYear,
-    maxYear,
-    disabledYears = [],
-    disabled = false,
-    readOnly = false,
-    startYear: propStartYear,
-    yearCount = 12,
-    locale: locale$1 = locale.enUS,
-    variant = "default",
-    defaultValue
-  } = props;
-  const handleYearChange = React.useCallback(
-    (year) => {
-      onChange == null ? void 0 : onChange(year ?? null);
-    },
-    [onChange]
-  );
-  const [selectedYear, setSelectedYear] = useMergedValue.useMergedValue({
-    value,
-    defaultValue,
-    onChange: handleYearChange
-  });
-  resolveLocale(locale$1);
-  const currentYearNum = React.useMemo(() => {
-    const extracted = yearUtils.extractYear(propCurrentYear);
-    return extracted ?? yearUtils.getCurrentYear();
-  }, [propCurrentYear]);
-  const yearConstraints = React.useMemo(
-    () => ({
-      min: yearUtils.extractYear(minYear),
-      max: yearUtils.extractYear(maxYear),
-      disabled: disabledYears.map(yearUtils.extractYear).filter((year) => year !== void 0)
-    }),
-    [minYear, maxYear, disabledYears]
-  );
-  const [internalStartYear, setInternalStartYear] = React.useState(() => {
-    const propStart = yearUtils.extractYear(propStartYear);
-    return propStart ?? currentYearNum - Math.floor(yearCount / 2);
-  });
-  const startYear = yearUtils.extractYear(propStartYear) ?? internalStartYear;
-  const years = React.useMemo(() => {
-    const yearsList = [];
-    const selectedYearNum = selectedYear && dateFns.isDate(selectedYear) && dateFns.isValid(selectedYear) ? selectedYear.getFullYear() : void 0;
-    for (let i = 0; i < yearCount; i++) {
-      const yearNum = startYear + i;
-      const yearDate = yearUtils.createYearDate(yearNum);
-      const isSelected = selectedYearNum === yearNum;
-      const isCurrent = currentYearNum === yearNum;
-      const isInRange = yearUtils.isYearInRange(yearNum, yearConstraints.min, yearConstraints.max);
-      const isDisabled = disabled || yearConstraints.disabled.includes(yearNum) || !isInRange;
-      yearsList.push({
-        year: yearDate,
-        isSelected,
-        isCurrent,
-        isDisabled,
-        isInRange
-      });
-    }
-    return yearsList;
-  }, [startYear, yearCount, selectedYear, currentYearNum, disabled, yearConstraints]);
-  const handleYearSelect = usehooksTs.useEventCallback((year) => {
-    if (disabled || readOnly) return;
-    const yearNum = year.getFullYear();
-    const yearItem = years.find((y) => y.year.getFullYear() === yearNum);
-    if (yearItem == null ? void 0 : yearItem.isDisabled) return;
-    setSelectedYear(year);
-  });
-  const navigateYears = React.useCallback(
-    (direction) => {
-      if (disabled) return;
-      const offset = direction === "prev" ? -yearCount : yearCount;
-      const newStartYear = startYear + offset;
-      if (direction === "prev" && yearConstraints.min !== void 0) {
-        if (newStartYear + yearCount - 1 < yearConstraints.min) return;
-      }
-      if (direction === "next" && yearConstraints.max !== void 0) {
-        if (newStartYear > yearConstraints.max) return;
-      }
-      const newStartDate = yearUtils.createYearDate(newStartYear);
-      onNavigate == null ? void 0 : onNavigate(direction, newStartDate);
-      if (propStartYear === void 0) {
-        setInternalStartYear(newStartYear);
-      }
-    },
-    [disabled, startYear, yearCount, yearConstraints, onNavigate, propStartYear]
-  );
-  const handlePrevious = usehooksTs.useEventCallback(() => navigateYears("prev"));
-  const handleNext = usehooksTs.useEventCallback(() => navigateYears("next"));
-  const handleToday = usehooksTs.useEventCallback(() => {
-    const todayYear = yearUtils.getCurrentYear();
-    const todayYearDate = yearUtils.createYearDate(todayYear);
-    setInternalStartYear(todayYear - Math.floor(yearCount / 2));
-    setSelectedYear(todayYearDate);
-  });
-  const navigationState = React.useMemo(() => {
-    if (disabled) return { isPrevDisabled: true, isNextDisabled: true };
-    const isPrevDisabled = yearConstraints.min !== void 0 && startYear - yearCount + yearCount - 1 < yearConstraints.min;
-    const isNextDisabled = yearConstraints.max !== void 0 && startYear + yearCount > yearConstraints.max;
-    return { isPrevDisabled, isNextDisabled };
-  }, [disabled, yearConstraints, startYear, yearCount]);
-  const displayInfo = React.useMemo(() => {
-    var _a, _b;
-    const startDisplayYear = ((_a = years[0]) == null ? void 0 : _a.year.getFullYear()) ?? yearUtils.getCurrentYear();
-    const endDisplayYear = ((_b = years[years.length - 1]) == null ? void 0 : _b.year.getFullYear()) ?? yearUtils.getCurrentYear();
-    const todayYear = yearUtils.getCurrentYear();
-    const currentYearContainsToday = startYear <= todayYear && todayYear <= startYear + yearCount - 1;
-    return {
-      startDisplayYear,
-      endDisplayYear,
-      currentYearContainsToday
-    };
-  }, [years, startYear, yearCount]);
-  const tv = YearCalendarTv({ variant });
-  return /* @__PURE__ */ require$$0.jsxs(
-    "div",
-    {
-      ref,
-      className: tcx.tcx(tv.container(), className),
-      "data-testid": "year-calendar",
-      children: [
-        /* @__PURE__ */ require$$0.jsx(
-          YearCalendarHeader,
-          {
-            currentYearContainsToday: displayInfo.currentYearContainsToday,
-            endDisplayYear: displayInfo.endDisplayYear,
-            handleNext,
-            handlePrevious,
-            handleToday,
-            isNextDisabled: navigationState.isNextDisabled,
-            isPrevDisabled: navigationState.isPrevDisabled,
-            startDisplayYear: displayInfo.startDisplayYear,
-            variant
-          }
-        ),
-        /* @__PURE__ */ require$$0.jsx(
-          "div",
-          {
-            className: tv.yearsGrid(),
-            "data-testid": "years-grid",
-            children: years.map((yearItem) => {
-              const yearNumber = yearItem.year.getFullYear();
-              return /* @__PURE__ */ require$$0.jsx(
-                YearCalendarCell,
-                {
-                  className: tv.yearCell({
-                    selected: yearItem.isSelected,
-                    current: yearItem.isCurrent,
-                    disabled: yearItem.isDisabled,
-                    inRange: yearItem.isInRange
-                  }),
-                  yearItem,
-                  onClick: handleYearSelect
-                },
-                yearNumber
-              );
-            })
-          }
-        ),
-        children
-      ]
-    }
-  );
-});
-YearCalendar.displayName = "YearCalendar";
-exports.DateInput = DateInput;
-exports.DigitExtractor = DigitExtractor;
-exports.LOCALE_MAP = LOCALE_MAP;
-exports.MonthCalendar = MonthCalendar;
-exports.QuarterCalendar = QuarterCalendar;
-exports.TimeCalendar = TimeCalendar;
-exports.TimeInput = TimeInput;
-exports.YearCalendar = YearCalendar;
-exports.calculateWeekNumbers = calculateWeekNumbers;
-exports.canBeMonthDay = canBeMonthDay;
-exports.commonDateFormats = commonDateFormats;
-exports.commonTimeFormats = commonTimeFormats;
-exports.convertTwoDigitYear = convertTwoDigitYear;
-exports.createQuarter = createQuarter;
-exports.createTimeZoneContext = createTimeZoneContext;
-exports.dateToTimeString = dateToTimeString;
-exports.dateUtils = dateUtils;
-exports.defaultLocaleMap = defaultLocaleMap;
-exports.formatMonthTitle = formatMonthTitle;
-exports.formatQuarter = formatQuarter;
-exports.generateCalendarDays = generateCalendarDays;
-exports.generateTimeOptions = generateTimeOptions;
-exports.generateWeekdayNames = generateWeekdayNames;
-exports.getCurrentQuarter = getCurrentQuarter;
-exports.getDateKey = getDateKey;
-exports.getDateParts = getDateParts;
-exports.getEnhancedPrediction = getEnhancedPrediction;
-exports.getLastDayOfMonth = getLastDayOfMonth;
-exports.getLocaleKey = getLocaleKey;
-exports.getQuarterMonths = getQuarterMonths;
-exports.getYearQuarters = getYearQuarters;
-exports.handleShortcuts = handleShortcuts;
-exports.inferMonthFromValue = inferMonthFromValue;
-exports.inferSelectionMode = inferSelectionMode;
-exports.isCalendarValueEqual = isCalendarValueEqual;
-exports.isChineseLocale = isChineseLocale;
-exports.isQuarterEqual = isQuarterEqual;
-exports.isReasonableYear = isReasonableYear;
-exports.isSameDayInTimeZone = isSameDayInTimeZone;
-exports.isValidMonthDay = isValidMonthDay;
-exports.isWithinRange = isWithinRange;
-exports.naturalLanguageMap = naturalLanguageMap;
-exports.normalizeTimeValue = normalizeTimeValue;
-exports.parse3Digits = parse3Digits;
-exports.parseCache = parseCache;
-exports.parseDate = parseDate;
-exports.parseEnglishDate = parseEnglishDate;
-exports.parseExtendedRelativeDate = parseExtendedRelativeDate;
-exports.parseMonthName = parseMonthName;
-exports.parseNaturalLanguage = parseNaturalLanguage;
-exports.parseRelativeDate = parseRelativeDate;
-exports.parseYYMMDD = parseYYMMDD;
-exports.parseYYYYMMDD = parseYYYYMMDD;
-exports.parserConfig = parserConfig;
-exports.quarterUtils = quarterUtils;
-exports.relativeDatePatterns = relativeDatePatterns;
-exports.resolveLocale = resolveLocale;
-exports.smartCorrectDate = smartCorrectDate;
-exports.smartCorrectYear = smartCorrectYear;
-exports.smartParseTimeValue = smartParseTimeValue;
-exports.timeStringToDate = timeStringToDate;
-exports.tryRelaxedTimeParsing = tryRelaxedTimeParsing;
-exports.useDateInput = useDateInput;
-exports.useTimeInput = useTimeInput;
-exports.yearUtils = yearUtils;