@choice-ui/react 1.3.10

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

@@ -0,0 +1,4591 @@
+"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;