@kalyx/react 1.0.0-rc.9 → 1.0.1

package/dist/headless.cjs

@@ -0,0 +1,3052 @@
+"use client";
+'use strict';
+
+var react = require('react');
+var core = require('@kalyx/core');
+var jsxRuntime = require('react/jsx-runtime');
+var react$1 = require('@floating-ui/react');
+
+// src/components/DatePicker/Root.tsx
+var DatePickerContext = react.createContext(null);
+function useDatePickerContext(componentName) {
+  const context = react.useContext(DatePickerContext);
+  if (!context) {
+    throw new Error(
+      `[${componentName}] DatePicker.Root \uB0B4\uBD80\uC5D0\uC11C \uC0AC\uC6A9\uD574\uC57C \uD569\uB2C8\uB2E4.
+
+\uC62C\uBC14\uB978 \uC0AC\uC6A9\uBC95:
+  <DatePicker>
+    <DatePicker.${componentName.replace("DatePicker.", "")} />
+  </DatePicker>`
+    );
+  }
+  return context;
+}
+function useChangeEffect(value, callback) {
+  const callbackRef = react.useRef(callback);
+  callbackRef.current = callback;
+  const prevRef = react.useRef(value);
+  react.useEffect(() => {
+    if (prevRef.current !== value) {
+      prevRef.current = value;
+      callbackRef.current?.(value);
+    }
+  }, [value]);
+}
+
+// src/internal/defaultAdapter.ts
+var __defaultAdapter = null;
+function getDefaultAdapter() {
+  return __defaultAdapter;
+}
+function resolveAdapter(passed, fallback, componentName) {
+  if (passed) return passed;
+  throw new Error(
+    `[@kalyx/react/headless] ${componentName} requires an adapter. Pass one via <${componentName} adapter={...}>. If you don't need a custom adapter, import from '@kalyx/react' instead.`
+  );
+}
+function DatePickerRoot({
+  value: controlledValue,
+  defaultValue,
+  onChange,
+  onOpenChange,
+  onCalendarNavigate,
+  disabled = false,
+  readOnly = false,
+  weekStartsOn = 0,
+  displayFormat = "yyyy-MM-dd",
+  locale = "en-US",
+  displayTimezone,
+  adapter: adapterProp,
+  labels: labelsProp,
+  children
+}) {
+  const adapter = resolveAdapter(adapterProp, getDefaultAdapter(), "DatePicker");
+  const pickerId = react.useId();
+  const isControlled = react.useRef(controlledValue !== void 0).current;
+  const referenceRef = react.useRef(null);
+  const [uncontrolledValue, setUncontrolledValue] = react.useState(
+    defaultValue ?? null
+  );
+  const currentValue = isControlled ? controlledValue ?? null : uncontrolledValue;
+  const [isOpen, setIsOpen] = react.useState(false);
+  const [viewMonth, setViewMonth] = react.useState(
+    () => currentValue ?? adapter.today(displayTimezone)
+  );
+  const [focusedDate, setFocusedDate] = react.useState(
+    () => currentValue ?? adapter.today(displayTimezone)
+  );
+  useChangeEffect(isOpen, onOpenChange);
+  const viewMonthStart = react.useMemo(() => adapter.startOfMonth(viewMonth), [viewMonth, adapter]);
+  useChangeEffect(viewMonthStart, onCalendarNavigate);
+  const mergedLabels = react.useMemo(
+    () => ({ ...core.DEFAULT_DATEPICKER_LABELS, ...labelsProp }),
+    [labelsProp]
+  );
+  const isDisabled = typeof disabled === "boolean" ? disabled : false;
+  const disabledRules = react.useMemo(
+    () => Array.isArray(disabled) ? disabled : [],
+    [disabled]
+  );
+  const selectDate = react.useCallback(
+    (iso) => {
+      if (isDisabled || readOnly) return;
+      const normalized = iso && displayTimezone ? core.civilMidnightFromUtcDay(iso, displayTimezone) : iso;
+      if (!isControlled) {
+        setUncontrolledValue(normalized);
+      }
+      onChange?.(normalized);
+      setIsOpen(false);
+    },
+    [isControlled, isDisabled, readOnly, onChange, displayTimezone]
+  );
+  const open = react.useCallback(() => {
+    if (isDisabled || readOnly) return;
+    setIsOpen(true);
+    const target = currentValue ?? adapter.today(displayTimezone);
+    setViewMonth(target);
+    setFocusedDate(target);
+  }, [isDisabled, readOnly, currentValue, adapter, displayTimezone]);
+  const close = react.useCallback(() => {
+    setIsOpen(false);
+  }, []);
+  const toggle = react.useCallback(() => {
+    if (isOpen) {
+      close();
+    } else {
+      open();
+    }
+  }, [isOpen, open, close]);
+  const contextValue = react.useMemo(
+    () => ({
+      referenceRef,
+      value: currentValue,
+      selectDate,
+      isOpen,
+      open,
+      close,
+      toggle,
+      viewMonth,
+      setViewMonth,
+      focusedDate,
+      setFocusedDate,
+      adapter,
+      disabled: disabledRules,
+      weekStartsOn,
+      displayFormat,
+      locale,
+      displayTimezone,
+      isDisabled,
+      isReadOnly: readOnly,
+      pickerId,
+      labels: mergedLabels
+    }),
+    [
+      currentValue,
+      selectDate,
+      isOpen,
+      open,
+      close,
+      toggle,
+      viewMonth,
+      focusedDate,
+      adapter,
+      disabledRules,
+      weekStartsOn,
+      displayFormat,
+      locale,
+      displayTimezone,
+      isDisabled,
+      readOnly,
+      pickerId,
+      mergedLabels
+    ]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(DatePickerContext.Provider, { value: contextValue, children });
+}
+var DatePickerInput = react.forwardRef(
+  function DatePickerInput2({ format: formatProp, name, onClick, onBlur, onKeyDown, ...props }, ref) {
+    const ctx = useDatePickerContext("DatePicker.Input");
+    const displayFormat = formatProp ?? ctx.displayFormat;
+    const [inputText, setInputText] = react.useState(null);
+    const isComposingRef = react.useRef(false);
+    react.useEffect(() => {
+      if (isComposingRef.current) return;
+      setInputText(null);
+    }, [ctx.value]);
+    let formattedValue = "";
+    if (ctx.value) {
+      try {
+        formattedValue = ctx.adapter.format(ctx.value, displayFormat, ctx.displayTimezone);
+      } catch {
+        formattedValue = ctx.value;
+      }
+    }
+    const displayValue = inputText !== null ? inputText : formattedValue;
+    const handleClick = react.useCallback(
+      (e) => {
+        if (!ctx.isOpen) ctx.open();
+        onClick?.(e);
+      },
+      [ctx, onClick]
+    );
+    const commitText = react.useCallback(
+      (text) => {
+        if (!text) {
+          ctx.selectDate(null);
+          setInputText(null);
+          return true;
+        }
+        const parsed = core.parseInputValue(text, ctx.adapter);
+        if (parsed) {
+          ctx.selectDate(parsed);
+          setInputText(null);
+          return true;
+        }
+        return false;
+      },
+      [ctx]
+    );
+    const handleBlur = react.useCallback(
+      (e) => {
+        if (inputText !== null) {
+          commitText(inputText);
+          setInputText(null);
+        }
+        onBlur?.(e);
+      },
+      [inputText, commitText, onBlur]
+    );
+    const handleChange = react.useCallback(
+      (e) => {
+        const text = e.target.value;
+        setInputText(text);
+        if (isComposingRef.current) return;
+        commitText(text);
+      },
+      [commitText]
+    );
+    const handleCompositionStart = react.useCallback(() => {
+      isComposingRef.current = true;
+    }, []);
+    const handleCompositionEnd = react.useCallback(
+      (e) => {
+        isComposingRef.current = false;
+        commitText(e.target.value);
+      },
+      [commitText]
+    );
+    const handleKeyDown = react.useCallback(
+      (e) => {
+        if (e.key === "Escape") {
+          ctx.close();
+        } else if (e.key === "Enter") {
+          if (ctx.isOpen) e.preventDefault();
+          if (inputText !== null) {
+            commitText(inputText);
+          } else if (ctx.isOpen) {
+            ctx.selectDate(ctx.focusedDate);
+          }
+        } else if (e.key === "ArrowDown" && !ctx.isOpen) {
+          e.preventDefault();
+          ctx.open();
+        }
+        onKeyDown?.(e);
+      },
+      [ctx, inputText, commitText, onKeyDown]
+    );
+    const calendarId = `${ctx.pickerId}-calendar`;
+    return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          ref: (node) => {
+            ctx.referenceRef.current = node;
+            if (typeof ref === "function") ref(node);
+            else if (ref) ref.current = node;
+          },
+          type: "text",
+          role: "combobox",
+          "aria-expanded": ctx.isOpen,
+          "aria-haspopup": "dialog",
+          "aria-controls": ctx.isOpen ? calendarId : void 0,
+          "aria-autocomplete": "none",
+          autoComplete: "off",
+          value: displayValue,
+          disabled: ctx.isDisabled || props.disabled,
+          readOnly: ctx.isReadOnly,
+          onChange: handleChange,
+          onClick: handleClick,
+          onBlur: handleBlur,
+          onKeyDown: handleKeyDown,
+          onCompositionStart: handleCompositionStart,
+          onCompositionEnd: handleCompositionEnd,
+          ...props
+        }
+      ),
+      name ? /* @__PURE__ */ jsxRuntime.jsx("input", { type: "hidden", name, value: ctx.value ?? "" }) : null
+    ] });
+  }
+);
+DatePickerInput.displayName = "DatePicker.Input";
+var DatePickerTrigger = react.forwardRef(
+  function DatePickerTrigger2({ onClick, children, ...props }, ref) {
+    const ctx = useDatePickerContext("DatePicker.Trigger");
+    const handleClick = react.useCallback(
+      (e) => {
+        ctx.toggle();
+        onClick?.(e);
+      },
+      [ctx, onClick]
+    );
+    const calendarId = `${ctx.pickerId}-calendar`;
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        ref: (node) => {
+          if (!ctx.referenceRef.current) ctx.referenceRef.current = node;
+          if (typeof ref === "function") ref(node);
+          else if (ref) ref.current = node;
+        },
+        type: "button",
+        tabIndex: 0,
+        "aria-label": ctx.isOpen ? ctx.labels.triggerClose : ctx.labels.triggerOpen,
+        "aria-expanded": ctx.isOpen,
+        "aria-haspopup": "dialog",
+        "aria-controls": ctx.isOpen ? calendarId : void 0,
+        disabled: ctx.isDisabled || props.disabled,
+        onClick: handleClick,
+        ...props,
+        children: children ?? /* @__PURE__ */ jsxRuntime.jsx(
+          "svg",
+          {
+            "aria-hidden": "true",
+            focusable: "false",
+            width: "16",
+            height: "16",
+            viewBox: "0 0 16 16",
+            fill: "none",
+            xmlns: "http://www.w3.org/2000/svg",
+            children: /* @__PURE__ */ jsxRuntime.jsx(
+              "path",
+              {
+                d: "M5 1v2M11 1v2M1 6h14M3 3h10a2 2 0 012 2v8a2 2 0 01-2 2H3a2 2 0 01-2-2V5a2 2 0 012-2z",
+                stroke: "currentColor",
+                strokeWidth: "1.5",
+                strokeLinecap: "round",
+                strokeLinejoin: "round"
+              }
+            )
+          }
+        )
+      }
+    );
+  }
+);
+DatePickerTrigger.displayName = "DatePicker.Trigger";
+var POPOVER_MIDDLEWARE = [react$1.offset(4), react$1.flip(), react$1.shift({ padding: 8 })];
+function usePopover({
+  isOpen,
+  close,
+  referenceRef,
+  placement = "bottom-start"
+}) {
+  const floatingRef = react.useRef(null);
+  const previousFocusRef = react.useRef(null);
+  const { refs, floatingStyles, isPositioned } = react$1.useFloating({
+    open: isOpen,
+    placement,
+    middleware: POPOVER_MIDDLEWARE,
+    whileElementsMounted: react$1.autoUpdate
+  });
+  react.useEffect(() => {
+    if (referenceRef.current) {
+      refs.setReference(referenceRef.current);
+    }
+  }, [referenceRef, refs, isOpen]);
+  react.useEffect(() => {
+    if (isOpen) {
+      previousFocusRef.current = document.activeElement;
+    } else if (previousFocusRef.current) {
+      const el = previousFocusRef.current;
+      previousFocusRef.current = null;
+      if (el !== referenceRef.current && typeof el.focus === "function") {
+        el.focus({ preventScroll: true });
+      }
+    }
+  }, [isOpen, referenceRef]);
+  react.useEffect(() => {
+    if (!isOpen) return;
+    function handleClickOutside(e) {
+      const floating = floatingRef.current;
+      const reference = referenceRef.current;
+      const target = e.target;
+      if (floating && !floating.contains(target) && (!reference || !reference.contains(target))) {
+        close();
+      }
+    }
+    const timer = setTimeout(() => {
+      document.addEventListener("mousedown", handleClickOutside);
+    }, 0);
+    return () => {
+      clearTimeout(timer);
+      document.removeEventListener("mousedown", handleClickOutside);
+    };
+  }, [isOpen, close, referenceRef]);
+  react.useEffect(() => {
+    if (!isOpen) return;
+    function handleKeyDown(e) {
+      if (e.key === "Escape") {
+        close();
+      }
+    }
+    document.addEventListener("keydown", handleKeyDown);
+    return () => document.removeEventListener("keydown", handleKeyDown);
+  }, [isOpen, close]);
+  react.useEffect(() => {
+    if (!isOpen) return;
+    function handleFocusOut(e) {
+      const next = e.relatedTarget;
+      const floating = floatingRef.current;
+      const reference = referenceRef.current;
+      if (!next) return;
+      const insideFloating = floating?.contains(next) ?? false;
+      const insideReference = reference?.contains(next) ?? false;
+      if (!insideFloating && !insideReference) {
+        close();
+      }
+    }
+    const node = floatingRef.current;
+    if (!node) return;
+    node.addEventListener("focusout", handleFocusOut);
+    return () => node.removeEventListener("focusout", handleFocusOut);
+  }, [isOpen, close, referenceRef]);
+  const setFloatingRef = react.useCallback(
+    (node) => {
+      floatingRef.current = node;
+      refs.setFloating(node);
+      if (node && referenceRef.current) {
+        refs.setReference(referenceRef.current);
+      }
+    },
+    [refs, referenceRef]
+  );
+  return { floatingStyles, setFloatingRef, isPositioned };
+}
+function DatePickerPopover({ children, ...props }) {
+  const ctx = useDatePickerContext("DatePicker.Popover");
+  const calendarId = `${ctx.pickerId}-calendar`;
+  const { floatingStyles, setFloatingRef, isPositioned } = usePopover({
+    isOpen: ctx.isOpen,
+    close: ctx.close,
+    referenceRef: ctx.referenceRef
+  });
+  if (!ctx.isOpen) return null;
+  const { style: userStyle, ...rest } = props;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      ref: setFloatingRef,
+      id: calendarId,
+      role: "dialog",
+      "aria-label": ctx.labels.popoverLabel,
+      "aria-modal": "false",
+      ...rest,
+      style: {
+        ...userStyle,
+        ...floatingStyles,
+        visibility: isPositioned ? void 0 : "hidden"
+      },
+      children
+    }
+  );
+}
+function safeFormatFullDate(iso, locale) {
+  try {
+    return core.formatFullDate(iso, locale);
+  } catch {
+    return iso;
+  }
+}
+var srOnly = {
+  position: "absolute",
+  width: "1px",
+  height: "1px",
+  padding: 0,
+  margin: "-1px",
+  overflow: "hidden",
+  clip: "rect(0, 0, 0, 0)",
+  whiteSpace: "nowrap",
+  border: 0
+};
+function DatePickerCalendar({
+  classNames,
+  onTitleClick,
+  showWeekNumber = false,
+  fixedWeeks = false,
+  ...props
+}) {
+  const ctx = useDatePickerContext("DatePicker.Calendar");
+  const gridRef = react.useRef(null);
+  const [announcement, setAnnouncement] = react.useState("");
+  const { adapter, viewMonth, focusedDate, weekStartsOn, disabled, locale, displayTimezone } = ctx;
+  const weekdays = react.useMemo(() => core.getWeekdayNames(locale, weekStartsOn), [locale, weekStartsOn]);
+  const weeks = react.useMemo(
+    () => core.getCalendarDays(viewMonth, adapter, {
+      weekStartsOn,
+      selected: ctx.value,
+      focusedDate,
+      disabled,
+      timezone: displayTimezone,
+      fixedWeeks
+    }),
+    [
+      viewMonth,
+      adapter,
+      weekStartsOn,
+      ctx.value,
+      focusedDate,
+      disabled,
+      displayTimezone,
+      fixedWeeks
+    ]
+  );
+  const thursdayIndex = weekStartsOn === 0 ? 4 : 3;
+  const year = adapter.getYear(viewMonth);
+  const month = adapter.getMonth(viewMonth);
+  const title = core.formatMonthYear(year, month, locale);
+  react.useEffect(() => {
+    if (!ctx.isOpen || !gridRef.current) return;
+    const focusedButton = gridRef.current.querySelector('[data-focused="true"]');
+    focusedButton?.focus({ preventScroll: true });
+  }, [focusedDate, ctx.isOpen]);
+  const navigateMonth = react.useCallback(
+    (direction) => {
+      const newMonth = adapter.addMonths(viewMonth, direction);
+      ctx.setViewMonth(newMonth);
+      ctx.setFocusedDate(adapter.startOfMonth(newMonth));
+      const y = adapter.getYear(newMonth);
+      const m = adapter.getMonth(newMonth);
+      setAnnouncement(core.formatMonthYear(y, m, locale));
+    },
+    [adapter, viewMonth, ctx, locale]
+  );
+  const handleDayClick = react.useCallback(
+    (day) => {
+      if (day.isDisabled) return;
+      ctx.selectDate(day.isoString);
+      setAnnouncement(safeFormatFullDate(day.isoString, locale));
+    },
+    [ctx, locale]
+  );
+  const handleKeyDown = react.useCallback(
+    (e) => {
+      let newFocused = null;
+      switch (e.key) {
+        case "ArrowLeft":
+          newFocused = adapter.addDays(focusedDate, -1);
+          break;
+        case "ArrowRight":
+          newFocused = adapter.addDays(focusedDate, 1);
+          break;
+        case "ArrowUp":
+          newFocused = adapter.addDays(focusedDate, -7);
+          break;
+        case "ArrowDown":
+          newFocused = adapter.addDays(focusedDate, 7);
+          break;
+        case "PageUp":
+          if (e.shiftKey) {
+            newFocused = adapter.addYears(focusedDate, -1);
+          } else {
+            newFocused = adapter.addMonths(focusedDate, -1);
+          }
+          break;
+        case "PageDown":
+          if (e.shiftKey) {
+            newFocused = adapter.addYears(focusedDate, 1);
+          } else {
+            newFocused = adapter.addMonths(focusedDate, 1);
+          }
+          break;
+        case "Home":
+          newFocused = adapter.startOfWeek(focusedDate, weekStartsOn);
+          break;
+        case "End":
+          newFocused = adapter.endOfWeek(focusedDate, weekStartsOn);
+          newFocused = adapter.startOfDay(newFocused);
+          break;
+        case "Enter":
+        case " ":
+          e.preventDefault();
+          if (!core.isDateDisabled(focusedDate, disabled, adapter)) {
+            ctx.selectDate(focusedDate);
+          }
+          return;
+        case "Escape":
+          ctx.close();
+          return;
+        default:
+          return;
+      }
+      if (newFocused) {
+        e.preventDefault();
+        const skipStep = e.key === "ArrowLeft" || e.key === "ArrowUp" || e.key === "PageUp" || e.key === "Home" ? -1 : 1;
+        let attempts = 0;
+        while (core.isDateDisabled(newFocused, disabled, adapter) && attempts < 42) {
+          newFocused = adapter.addDays(newFocused, skipStep);
+          attempts++;
+        }
+        if (attempts >= 42) {
+          return;
+        }
+        ctx.setFocusedDate(newFocused);
+        if (!adapter.isSameMonth(newFocused, viewMonth)) {
+          ctx.setViewMonth(newFocused);
+        }
+      }
+    },
+    [adapter, focusedDate, viewMonth, weekStartsOn, disabled, ctx]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: classNames?.root, ...props, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: classNames?.header, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          className: classNames?.navButton,
+          onClick: () => navigateMonth(-1),
+          "aria-label": ctx.labels.prevMonth,
+          children: "<"
+        }
+      ),
+      onTitleClick ? /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          className: classNames?.title,
+          onClick: onTitleClick,
+          "aria-live": "polite",
+          children: title
+        }
+      ) : /* @__PURE__ */ jsxRuntime.jsx("span", { className: classNames?.title, "aria-live": "polite", children: title }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          className: classNames?.navButton,
+          onClick: () => navigateMonth(1),
+          "aria-label": ctx.labels.nextMonth,
+          children: ">"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      "table",
+      {
+        ref: gridRef,
+        role: "grid",
+        "aria-label": title,
+        "aria-rowcount": weeks.length + 1,
+        "aria-colcount": 7,
+        className: classNames?.grid,
+        onKeyDown: handleKeyDown,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("thead", { children: /* @__PURE__ */ jsxRuntime.jsxs("tr", { role: "row", "aria-rowindex": 1, children: [
+            showWeekNumber ? /* @__PURE__ */ jsxRuntime.jsx("th", { scope: "col", "aria-hidden": "true", className: classNames?.weekNumberHeader, children: "#" }) : null,
+            weekdays.map((day, colIndex) => /* @__PURE__ */ jsxRuntime.jsx(
+              "th",
+              {
+                role: "columnheader",
+                abbr: day.full,
+                scope: "col",
+                "aria-colindex": colIndex + 1,
+                className: classNames?.weekdayHeader,
+                children: day.short
+              },
+              day.short
+            ))
+          ] }) }),
+          /* @__PURE__ */ jsxRuntime.jsx("tbody", { children: weeks.map((week, weekIndex) => /* @__PURE__ */ jsxRuntime.jsxs(
+            "tr",
+            {
+              role: "row",
+              "aria-rowindex": weekIndex + 2,
+              className: classNames?.gridRow,
+              children: [
+                showWeekNumber ? /* @__PURE__ */ jsxRuntime.jsx(
+                  "th",
+                  {
+                    scope: "row",
+                    "aria-hidden": "true",
+                    className: classNames?.weekNumber,
+                    "data-week-number": true,
+                    children: core.getISOWeekNumber(week[thursdayIndex].isoString)
+                  }
+                ) : null,
+                week.map((day, colIndex) => {
+                  const dayClasses = [
+                    classNames?.day,
+                    day.isSelected && classNames?.daySelected,
+                    day.isToday && classNames?.dayToday,
+                    day.isDisabled && classNames?.dayDisabled,
+                    !day.isCurrentMonth && classNames?.dayOutsideMonth
+                  ].filter(Boolean).join(" ") || void 0;
+                  return /* @__PURE__ */ jsxRuntime.jsx(
+                    "td",
+                    {
+                      role: "gridcell",
+                      "aria-colindex": colIndex + 1,
+                      "aria-selected": day.isSelected || void 0,
+                      "aria-disabled": day.isDisabled || void 0,
+                      "aria-current": day.isToday ? "date" : void 0,
+                      className: classNames?.gridCell,
+                      children: /* @__PURE__ */ jsxRuntime.jsx(
+                        "button",
+                        {
+                          type: "button",
+                          tabIndex: day.isFocused ? 0 : -1,
+                          disabled: day.isDisabled,
+                          "data-focused": day.isFocused || void 0,
+                          "data-selected": day.isSelected || void 0,
+                          "data-today": day.isToday || void 0,
+                          "data-outside-month": !day.isCurrentMonth || void 0,
+                          className: dayClasses,
+                          onClick: () => handleDayClick(day),
+                          "aria-label": safeFormatFullDate(day.isoString, locale),
+                          children: day.dayNumber
+                        }
+                      )
+                    },
+                    day.isoString
+                  );
+                })
+              ]
+            },
+            weekIndex
+          )) })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { role: "status", "aria-live": "polite", "aria-atomic": "true", style: srOnly, children: announcement })
+  ] });
+}
+function isRangeFullyDisabled(start, end, rules, adapter) {
+  for (const rule of rules) {
+    if ("before" in rule && adapter.isBefore(end, rule.before)) return true;
+    if ("after" in rule && adapter.isAfter(start, rule.after)) return true;
+  }
+  return false;
+}
+function useGridState(opts) {
+  const { initialIndex, disabledFlags, onSelect, onPageUp, onPageDown, onEscape } = opts;
+  const gridRef = react.useRef(null);
+  const [focusedIndex, setFocusedIndex] = react.useState(initialIndex);
+  const handleKeyDown = (e) => {
+    let next = null;
+    let step = 1;
+    switch (e.key) {
+      case "ArrowLeft":
+        next = Math.max(0, focusedIndex - 1);
+        step = -1;
+        break;
+      case "ArrowRight":
+        next = Math.min(11, focusedIndex + 1);
+        break;
+      case "ArrowUp":
+        next = Math.max(0, focusedIndex - 3);
+        step = -1;
+        break;
+      case "ArrowDown":
+        next = Math.min(11, focusedIndex + 3);
+        break;
+      case "Home":
+        next = focusedIndex - focusedIndex % 3;
+        step = -1;
+        break;
+      case "End":
+        next = focusedIndex - focusedIndex % 3 + 2;
+        break;
+      case "PageUp":
+        e.preventDefault();
+        onPageUp();
+        return;
+      case "PageDown":
+        e.preventDefault();
+        onPageDown();
+        return;
+      case "Enter":
+      case " ":
+        e.preventDefault();
+        onSelect(focusedIndex);
+        return;
+      case "Escape":
+        onEscape();
+        return;
+      default:
+        return;
+    }
+    if (next === null) return;
+    e.preventDefault();
+    if (disabledFlags) {
+      let attempts = 0;
+      while (next >= 0 && next < 12 && disabledFlags[next] && attempts < 12) {
+        next += step;
+        attempts++;
+      }
+      if (next < 0 || next >= 12 || disabledFlags[next]) return;
+    }
+    if (next !== focusedIndex) setFocusedIndex(next);
+  };
+  react.useEffect(() => {
+    if (!disabledFlags || !disabledFlags[focusedIndex]) return;
+    const firstEnabled = disabledFlags.findIndex((d) => !d);
+    if (firstEnabled !== -1 && firstEnabled !== focusedIndex) {
+      setFocusedIndex(firstEnabled);
+    }
+  }, [disabledFlags, focusedIndex]);
+  react.useEffect(() => {
+    const btn = gridRef.current?.querySelector('[data-focused="true"]');
+    btn?.focus({ preventScroll: true });
+  }, [focusedIndex]);
+  return { gridRef, focusedIndex, handleKeyDown };
+}
+function DatePickerMonthGrid({
+  classNames,
+  onSelect,
+  onTitleClick,
+  ...props
+}) {
+  const ctx = useDatePickerContext("DatePicker.MonthGrid");
+  const { adapter, viewMonth, locale, displayTimezone } = ctx;
+  const currentYear = adapter.getYear(viewMonth);
+  const currentMonth = adapter.getMonth(viewMonth);
+  const [today, setToday] = react.useState(null);
+  react.useEffect(() => {
+    setToday(adapter.today(displayTimezone));
+  }, [adapter, displayTimezone]);
+  const todayMonth = today !== null ? adapter.getMonth(today) : -1;
+  const todayYear = today !== null ? adapter.getYear(today) : -1;
+  const navigateYear = react.useCallback(
+    (direction) => {
+      ctx.setViewMonth(adapter.addYears(viewMonth, direction));
+    },
+    [adapter, viewMonth, ctx]
+  );
+  const handleMonthSelect = react.useCallback(
+    (monthIndex) => {
+      const target = new Date(Date.UTC(currentYear, monthIndex, 1)).toISOString();
+      ctx.setViewMonth(target);
+      ctx.setFocusedDate(target);
+      onSelect?.();
+    },
+    [currentYear, ctx, onSelect]
+  );
+  const { gridRef, focusedIndex, handleKeyDown } = useGridState({
+    initialIndex: currentMonth,
+    onSelect: handleMonthSelect,
+    onPageUp: () => navigateYear(-1),
+    onPageDown: () => navigateYear(1),
+    onEscape: ctx.close
+  });
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: classNames?.root, ...props, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: classNames?.header, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          className: classNames?.navButton,
+          onClick: () => navigateYear(-1),
+          "aria-label": ctx.labels.prevYear,
+          children: "<"
+        }
+      ),
+      onTitleClick ? /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", className: classNames?.title, onClick: onTitleClick, children: currentYear }) : /* @__PURE__ */ jsxRuntime.jsx("span", { className: classNames?.title, children: currentYear }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          className: classNames?.navButton,
+          onClick: () => navigateYear(1),
+          "aria-label": ctx.labels.nextYear,
+          children: ">"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        ref: gridRef,
+        role: "grid",
+        "aria-label": `${currentYear} months`,
+        className: classNames?.grid,
+        style: { display: "grid", gridTemplateColumns: "repeat(3, 1fr)" },
+        onKeyDown: handleKeyDown,
+        children: Array.from({ length: 12 }, (_, i) => {
+          const isSelected = i === currentMonth;
+          const isCurrent = i === todayMonth && currentYear === todayYear;
+          const isFocused = i === focusedIndex;
+          const cls = [
+            classNames?.month,
+            isSelected && classNames?.monthSelected,
+            isCurrent && classNames?.monthCurrent
+          ].filter(Boolean).join(" ") || void 0;
+          return /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              type: "button",
+              role: "gridcell",
+              tabIndex: isFocused ? 0 : -1,
+              "aria-selected": isSelected || void 0,
+              "aria-current": isCurrent ? "date" : void 0,
+              "data-selected": isSelected || void 0,
+              "data-current": isCurrent || void 0,
+              "data-focused": isFocused || void 0,
+              className: cls,
+              onClick: () => handleMonthSelect(i),
+              children: core.getMonthName(i, locale)
+            },
+            i
+          );
+        })
+      }
+    )
+  ] });
+}
+function DatePickerYearGrid({ classNames, onSelect, ...props }) {
+  const ctx = useDatePickerContext("DatePicker.YearGrid");
+  const { adapter, viewMonth, displayTimezone } = ctx;
+  const currentYear = adapter.getYear(viewMonth);
+  const [today, setToday] = react.useState(null);
+  react.useEffect(() => {
+    setToday(adapter.today(displayTimezone));
+  }, [adapter, displayTimezone]);
+  const todayYear = today !== null ? adapter.getYear(today) : -1;
+  const decadeStart = currentYear - currentYear % 12;
+  const navigateDecade = react.useCallback(
+    (direction) => {
+      ctx.setViewMonth(adapter.addYears(viewMonth, direction * 12));
+    },
+    [adapter, viewMonth, ctx]
+  );
+  const handleYearSelect = react.useCallback(
+    (indexInDecade) => {
+      const year = decadeStart + indexInDecade;
+      const currentMonth = adapter.getMonth(viewMonth);
+      const target = new Date(Date.UTC(year, currentMonth, 1)).toISOString();
+      ctx.setViewMonth(target);
+      ctx.setFocusedDate(target);
+      onSelect?.();
+    },
+    [adapter, viewMonth, ctx, onSelect, decadeStart]
+  );
+  const { gridRef, focusedIndex, handleKeyDown } = useGridState({
+    initialIndex: currentYear - decadeStart,
+    onSelect: handleYearSelect,
+    onPageUp: () => navigateDecade(-1),
+    onPageDown: () => navigateDecade(1),
+    onEscape: ctx.close
+  });
+  const rangeLabel = `${decadeStart}\u2013${decadeStart + 11}`;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: classNames?.root, ...props, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: classNames?.header, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          className: classNames?.navButton,
+          onClick: () => navigateDecade(-1),
+          "aria-label": ctx.labels.prevDecade,
+          children: "<"
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: classNames?.title, children: rangeLabel }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          className: classNames?.navButton,
+          onClick: () => navigateDecade(1),
+          "aria-label": ctx.labels.nextDecade,
+          children: ">"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        ref: gridRef,
+        role: "grid",
+        "aria-label": rangeLabel,
+        className: classNames?.grid,
+        style: { display: "grid", gridTemplateColumns: "repeat(3, 1fr)" },
+        onKeyDown: handleKeyDown,
+        children: Array.from({ length: 12 }, (_, i) => {
+          const year = decadeStart + i;
+          const isSelected = year === currentYear;
+          const isCurrent = year === todayYear;
+          const isFocused = i === focusedIndex;
+          const cls = [
+            classNames?.year,
+            isSelected && classNames?.yearSelected,
+            isCurrent && classNames?.yearCurrent
+          ].filter(Boolean).join(" ") || void 0;
+          return /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              type: "button",
+              role: "gridcell",
+              tabIndex: isFocused ? 0 : -1,
+              "aria-selected": isSelected || void 0,
+              "aria-current": isCurrent ? "date" : void 0,
+              "data-selected": isSelected || void 0,
+              "data-current": isCurrent || void 0,
+              "data-focused": isFocused || void 0,
+              className: cls,
+              onClick: () => handleYearSelect(i),
+              children: year
+            },
+            i
+          );
+        })
+      }
+    )
+  ] });
+}
+function DatePickerPresets({ classNames, children, ...props }) {
+  const ctx = useDatePickerContext("DatePicker.Presets");
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { role: "group", "aria-label": ctx.labels.popoverLabel, className: classNames?.root, ...props, children });
+}
+function resolveDatePreset(key, today, adapter) {
+  switch (key) {
+    case "today":
+      return today;
+    case "tomorrow":
+      return adapter.addDays(today, 1);
+    case "yesterday":
+      return adapter.addDays(today, -1);
+    case "startOfMonth":
+      return adapter.startOfMonth(today);
+    case "endOfMonth":
+      return adapter.startOfDay(adapter.endOfMonth(today));
+    case "startOfYear": {
+      const currentMonth = adapter.getMonth(today);
+      return adapter.startOfMonth(adapter.addMonths(today, -currentMonth));
+    }
+  }
+}
+function DatePickerPreset({
+  value: presetKey,
+  date: directDate,
+  children,
+  onClick,
+  ...props
+}) {
+  const ctx = useDatePickerContext("DatePicker.Preset");
+  const handleClick = react.useCallback(
+    (e) => {
+      if (ctx.isDisabled || ctx.isReadOnly) return;
+      let resolved;
+      if (directDate) {
+        resolved = directDate;
+      } else if (presetKey) {
+        resolved = resolveDatePreset(
+          presetKey,
+          ctx.adapter.today(ctx.displayTimezone),
+          ctx.adapter
+        );
+      } else {
+        return;
+      }
+      ctx.selectDate(resolved);
+      onClick?.(e);
+    },
+    [ctx, presetKey, directDate, onClick]
+  );
+  const isActive = (() => {
+    if (!ctx.value) return false;
+    let target;
+    if (directDate) {
+      target = directDate;
+    } else if (presetKey) {
+      target = resolveDatePreset(presetKey, ctx.adapter.today(ctx.displayTimezone), ctx.adapter);
+    } else {
+      return false;
+    }
+    return ctx.adapter.isSameDay(ctx.value, target, ctx.displayTimezone);
+  })();
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "button",
+    {
+      type: "button",
+      "aria-pressed": isActive,
+      "data-active": isActive || void 0,
+      disabled: ctx.isDisabled,
+      onClick: handleClick,
+      ...props,
+      children
+    }
+  );
+}
+
+// src/components/DatePicker/index.ts
+var DatePicker = Object.assign(DatePickerRoot, {
+  Input: DatePickerInput,
+  Trigger: DatePickerTrigger,
+  Popover: DatePickerPopover,
+  Calendar: DatePickerCalendar,
+  MonthGrid: DatePickerMonthGrid,
+  YearGrid: DatePickerYearGrid,
+  Presets: DatePickerPresets,
+  Preset: DatePickerPreset
+});
+var RangePickerContext = react.createContext(null);
+function useRangePickerContext(componentName) {
+  const context = react.useContext(RangePickerContext);
+  if (!context) {
+    throw new Error(
+      `[${componentName}] RangePicker.Root \uB0B4\uBD80\uC5D0\uC11C \uC0AC\uC6A9\uD574\uC57C \uD569\uB2C8\uB2E4.
+
+\uC62C\uBC14\uB978 \uC0AC\uC6A9\uBC95:
+  <RangePicker>
+    <RangePicker.${componentName.replace("RangePicker.", "")} />
+  </RangePicker>`
+    );
+  }
+  return context;
+}
+var EMPTY_RANGE = { start: null, end: null };
+var SR_ONLY = {
+  position: "absolute",
+  width: 1,
+  height: 1,
+  padding: 0,
+  margin: -1,
+  overflow: "hidden",
+  clip: "rect(0, 0, 0, 0)",
+  whiteSpace: "nowrap",
+  border: 0
+};
+function RangePickerRoot({
+  value: controlledValue,
+  defaultValue,
+  onChange,
+  onOpenChange,
+  onCalendarNavigate,
+  disabled = false,
+  readOnly = false,
+  weekStartsOn = 0,
+  displayFormat = "yyyy-MM-dd",
+  locale = "en-US",
+  displayTimezone,
+  adapter: adapterProp,
+  labels: labelsProp,
+  children
+}) {
+  const adapter = resolveAdapter(adapterProp, getDefaultAdapter(), "RangePicker");
+  const pickerId = react.useId();
+  const isControlled = react.useRef(controlledValue !== void 0).current;
+  const referenceRef = react.useRef(null);
+  const [uncontrolledValue, setUncontrolledValue] = react.useState(
+    defaultValue ?? EMPTY_RANGE
+  );
+  const currentValue = isControlled ? controlledValue ?? EMPTY_RANGE : uncontrolledValue;
+  const [isOpen, setIsOpen] = react.useState(false);
+  const [selectingTarget, setSelectingTarget] = react.useState("start");
+  const [hoverDate, setHoverDate] = react.useState(null);
+  const [announcement, setAnnouncement] = react.useState("");
+  const announce = react.useCallback((message) => setAnnouncement(message), []);
+  const [viewMonth, setViewMonth] = react.useState(
+    () => currentValue.start ?? adapter.today(displayTimezone)
+  );
+  const [focusedDate, setFocusedDate] = react.useState(
+    () => currentValue.start ?? adapter.today(displayTimezone)
+  );
+  useChangeEffect(isOpen, onOpenChange);
+  const viewMonthStart = react.useMemo(() => adapter.startOfMonth(viewMonth), [viewMonth, adapter]);
+  useChangeEffect(viewMonthStart, onCalendarNavigate);
+  const mergedLabels = react.useMemo(
+    () => ({ ...core.DEFAULT_RANGEPICKER_LABELS, ...labelsProp }),
+    [labelsProp]
+  );
+  const isDisabled = typeof disabled === "boolean" ? disabled : false;
+  const disabledRules = react.useMemo(
+    () => Array.isArray(disabled) ? disabled : [],
+    [disabled]
+  );
+  const setRange = react.useCallback(
+    (range) => {
+      if (isDisabled || readOnly) return;
+      if (!isControlled) {
+        setUncontrolledValue(range);
+      }
+      onChange?.(range);
+    },
+    [isControlled, isDisabled, readOnly, onChange]
+  );
+  const selectDate = react.useCallback(
+    (iso) => {
+      if (isDisabled || readOnly) return;
+      const normalized = displayTimezone ? core.civilMidnightFromUtcDay(iso, displayTimezone) : iso;
+      if (selectingTarget === "start") {
+        const newRange = { start: normalized, end: null };
+        setRange(newRange);
+        setSelectingTarget("end");
+        setHoverDate(null);
+      } else {
+        const start = currentValue.start;
+        if (!start) {
+          setRange({ start: normalized, end: null });
+          setSelectingTarget("end");
+          return;
+        }
+        let newRange;
+        if (adapter.isBefore(normalized, start)) {
+          newRange = { start: normalized, end: start };
+        } else {
+          newRange = { start, end: normalized };
+        }
+        setRange(newRange);
+        setSelectingTarget("start");
+        setHoverDate(null);
+        setIsOpen(false);
+      }
+    },
+    [isDisabled, readOnly, selectingTarget, currentValue.start, adapter, setRange, displayTimezone]
+  );
+  const open = react.useCallback(() => {
+    if (isDisabled || readOnly) return;
+    setIsOpen(true);
+    const target = currentValue.start ?? adapter.today(displayTimezone);
+    setViewMonth(target);
+    setFocusedDate(target);
+    if (currentValue.start && currentValue.end) {
+      setSelectingTarget("start");
+    }
+  }, [isDisabled, readOnly, currentValue, adapter, displayTimezone]);
+  const close = react.useCallback(() => {
+    setIsOpen(false);
+    setHoverDate(null);
+  }, []);
+  const toggle = react.useCallback(() => {
+    if (isOpen) close();
+    else open();
+  }, [isOpen, open, close]);
+  const contextValue = react.useMemo(
+    () => ({
+      referenceRef,
+      value: currentValue,
+      setRange,
+      selectDate,
+      selectingTarget,
+      hoverDate,
+      setHoverDate,
+      isOpen,
+      open,
+      close,
+      toggle,
+      viewMonth,
+      setViewMonth,
+      focusedDate,
+      setFocusedDate,
+      adapter,
+      disabled: disabledRules,
+      weekStartsOn,
+      displayFormat,
+      locale,
+      displayTimezone,
+      isDisabled,
+      isReadOnly: readOnly,
+      pickerId,
+      labels: mergedLabels,
+      announce
+    }),
+    [
+      currentValue,
+      setRange,
+      selectDate,
+      selectingTarget,
+      hoverDate,
+      isOpen,
+      open,
+      close,
+      toggle,
+      viewMonth,
+      focusedDate,
+      adapter,
+      disabledRules,
+      weekStartsOn,
+      displayFormat,
+      locale,
+      displayTimezone,
+      isDisabled,
+      readOnly,
+      pickerId,
+      mergedLabels,
+      announce
+    ]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs(RangePickerContext.Provider, { value: contextValue, children: [
+    children,
+    /* @__PURE__ */ jsxRuntime.jsx("div", { role: "status", "aria-live": "polite", "aria-atomic": "true", style: SR_ONLY, children: announcement })
+  ] });
+}
+var RangePickerInput = react.forwardRef(
+  function RangePickerInput2({ part, format: formatProp, onClick, onKeyDown, ...props }, ref) {
+    const ctx = useRangePickerContext("RangePicker.Input");
+    const displayFormat = formatProp ?? ctx.displayFormat;
+    const value = ctx.value[part];
+    let displayValue = "";
+    if (value) {
+      try {
+        displayValue = ctx.adapter.format(value, displayFormat, ctx.displayTimezone);
+      } catch {
+        displayValue = value;
+      }
+    }
+    const handleClick = react.useCallback(
+      (e) => {
+        if (!ctx.isOpen) ctx.open();
+        onClick?.(e);
+      },
+      [ctx, onClick]
+    );
+    const handleKeyDown = react.useCallback(
+      (e) => {
+        if (e.key === "Escape") {
+          ctx.close();
+        } else if (e.key === "Enter" && ctx.isOpen) {
+          e.preventDefault();
+        } else if (e.key === "ArrowDown" && !ctx.isOpen) {
+          e.preventDefault();
+          ctx.open();
+        }
+        onKeyDown?.(e);
+      },
+      [ctx, onKeyDown]
+    );
+    const calendarId = `${ctx.pickerId}-calendar`;
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "input",
+      {
+        ref: (node) => {
+          if (part === "start" && node) ctx.referenceRef.current = node;
+          if (typeof ref === "function") ref(node);
+          else if (ref) ref.current = node;
+        },
+        type: "text",
+        role: "combobox",
+        readOnly: true,
+        "aria-expanded": ctx.isOpen,
+        "aria-haspopup": "dialog",
+        "aria-controls": ctx.isOpen ? calendarId : void 0,
+        "aria-autocomplete": "none",
+        "aria-label": part === "start" ? ctx.labels.startInput : ctx.labels.endInput,
+        autoComplete: "off",
+        value: displayValue,
+        disabled: ctx.isDisabled || props.disabled,
+        onClick: handleClick,
+        onKeyDown: handleKeyDown,
+        "data-part": part,
+        ...props
+      }
+    );
+  }
+);
+RangePickerInput.displayName = "RangePicker.Input";
+function RangePickerPopover({ children, ...props }) {
+  const ctx = useRangePickerContext("RangePicker.Popover");
+  const calendarId = `${ctx.pickerId}-calendar`;
+  const { floatingStyles, setFloatingRef, isPositioned } = usePopover({
+    isOpen: ctx.isOpen,
+    close: ctx.close,
+    referenceRef: ctx.referenceRef
+  });
+  if (!ctx.isOpen) return null;
+  const { style: userStyle, ...rest } = props;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      ref: setFloatingRef,
+      id: calendarId,
+      role: "dialog",
+      "aria-label": ctx.labels.popoverLabel,
+      "aria-modal": "false",
+      ...rest,
+      style: {
+        ...userStyle,
+        ...floatingStyles,
+        visibility: isPositioned ? void 0 : "hidden"
+      },
+      children
+    }
+  );
+}
+function safeFormatFullDate2(iso, locale) {
+  try {
+    return core.formatFullDate(iso, locale);
+  } catch {
+    return iso;
+  }
+}
+function RangePickerCalendar({
+  classNames,
+  selectionMode = "range",
+  showWeekNumber = false,
+  fixedWeeks = false,
+  ...props
+}) {
+  const ctx = useRangePickerContext("RangePicker.Calendar");
+  const gridRef = react.useRef(null);
+  const {
+    adapter,
+    viewMonth,
+    focusedDate,
+    weekStartsOn,
+    disabled,
+    value,
+    hoverDate,
+    selectingTarget,
+    displayTimezone
+  } = ctx;
+  const { locale } = ctx;
+  const weekdays = react.useMemo(() => core.getWeekdayNames(locale, weekStartsOn), [locale, weekStartsOn]);
+  const weeks = react.useMemo(
+    () => core.getCalendarDays(viewMonth, adapter, {
+      weekStartsOn,
+      focusedDate,
+      disabled,
+      range: value,
+      rangeHover: hoverDate,
+      timezone: displayTimezone,
+      fixedWeeks
+    }),
+    [
+      viewMonth,
+      adapter,
+      weekStartsOn,
+      focusedDate,
+      disabled,
+      value,
+      hoverDate,
+      displayTimezone,
+      fixedWeeks
+    ]
+  );
+  const thursdayIndex = weekStartsOn === 0 ? 4 : 3;
+  const year = adapter.getYear(viewMonth);
+  const month = adapter.getMonth(viewMonth);
+  const title = core.formatMonthYear(year, month, locale);
+  react.useEffect(() => {
+    if (!ctx.isOpen || !gridRef.current) return;
+    const focusedButton = gridRef.current.querySelector('[data-focused="true"]');
+    focusedButton?.focus({ preventScroll: true });
+  }, [focusedDate, ctx.isOpen]);
+  const navigateMonth = react.useCallback(
+    (direction) => {
+      const newMonth = adapter.addMonths(viewMonth, direction);
+      ctx.setViewMonth(newMonth);
+      ctx.setFocusedDate(adapter.startOfMonth(newMonth));
+      const y = adapter.getYear(newMonth);
+      const m = adapter.getMonth(newMonth);
+      ctx.announce(core.formatMonthYear(y, m, locale));
+    },
+    [adapter, viewMonth, ctx, locale]
+  );
+  const commitDay = react.useCallback(
+    (iso) => {
+      if (selectionMode === "week") {
+        const weekStart = adapter.startOfWeek(iso, weekStartsOn);
+        const weekEnd = adapter.startOfDay(adapter.endOfWeek(iso, weekStartsOn));
+        const range = { start: weekStart, end: weekEnd };
+        ctx.setRange(range);
+        ctx.close();
+        ctx.announce(
+          `${ctx.labels.rangeSelected}: ${safeFormatFullDate2(weekStart, locale)} \u2013 ${safeFormatFullDate2(weekEnd, locale)}`
+        );
+      } else {
+        const wasPickingStart = selectingTarget === "start";
+        const previousStart = value.start;
+        ctx.selectDate(iso);
+        const formatted = safeFormatFullDate2(iso, locale);
+        if (wasPickingStart) {
+          ctx.announce(`${formatted}. ${ctx.labels.selectingEnd}`);
+        } else if (previousStart) {
+          const [start, end] = adapter.isBefore(iso, previousStart) ? [iso, previousStart] : [previousStart, iso];
+          ctx.announce(
+            `${ctx.labels.rangeSelected}: ${safeFormatFullDate2(start, locale)} \u2013 ${safeFormatFullDate2(end, locale)}`
+          );
+        } else {
+          ctx.announce(formatted);
+        }
+      }
+    },
+    [selectionMode, adapter, weekStartsOn, ctx, locale, selectingTarget, value.start]
+  );
+  const handleDayClick = react.useCallback(
+    (day) => {
+      if (day.isDisabled) return;
+      commitDay(day.isoString);
+    },
+    [commitDay]
+  );
+  const handleDayMouseEnter = react.useCallback(
+    (day) => {
+      if (selectionMode === "week") return;
+      if (selectingTarget === "end" && value.start && !day.isDisabled) {
+        ctx.setHoverDate(day.isoString);
+      }
+    },
+    [selectionMode, selectingTarget, value.start, ctx]
+  );
+  const handleMouseLeave = react.useCallback(() => {
+    ctx.setHoverDate(null);
+  }, [ctx]);
+  const handleKeyDown = react.useCallback(
+    (e) => {
+      let newFocused = null;
+      switch (e.key) {
+        case "ArrowLeft":
+          newFocused = adapter.addDays(focusedDate, -1);
+          break;
+        case "ArrowRight":
+          newFocused = adapter.addDays(focusedDate, 1);
+          break;
+        case "ArrowUp":
+          newFocused = adapter.addDays(focusedDate, -7);
+          break;
+        case "ArrowDown":
+          newFocused = adapter.addDays(focusedDate, 7);
+          break;
+        case "PageUp":
+          newFocused = e.shiftKey ? adapter.addYears(focusedDate, -1) : adapter.addMonths(focusedDate, -1);
+          break;
+        case "PageDown":
+          newFocused = e.shiftKey ? adapter.addYears(focusedDate, 1) : adapter.addMonths(focusedDate, 1);
+          break;
+        case "Home":
+          newFocused = adapter.startOfWeek(focusedDate, weekStartsOn);
+          break;
+        case "End":
+          newFocused = adapter.startOfDay(adapter.endOfWeek(focusedDate, weekStartsOn));
+          break;
+        case "Enter":
+        case " ":
+          e.preventDefault();
+          if (!core.isDateDisabled(focusedDate, disabled, adapter)) {
+            commitDay(focusedDate);
+          }
+          return;
+        case "Escape":
+          ctx.close();
+          return;
+        default:
+          return;
+      }
+      if (newFocused) {
+        e.preventDefault();
+        const skipStep = e.key === "ArrowLeft" || e.key === "ArrowUp" || e.key === "PageUp" || e.key === "Home" ? -1 : 1;
+        let attempts = 0;
+        while (core.isDateDisabled(newFocused, disabled, adapter) && attempts < 42) {
+          newFocused = adapter.addDays(newFocused, skipStep);
+          attempts++;
+        }
+        if (attempts >= 42) return;
+        ctx.setFocusedDate(newFocused);
+        if (!adapter.isSameMonth(newFocused, viewMonth)) {
+          ctx.setViewMonth(newFocused);
+        }
+        if (selectionMode === "range" && selectingTarget === "end" && value.start) {
+          ctx.setHoverDate(newFocused);
+        }
+      }
+    },
+    [
+      adapter,
+      focusedDate,
+      viewMonth,
+      weekStartsOn,
+      disabled,
+      ctx,
+      selectionMode,
+      selectingTarget,
+      value.start,
+      commitDay
+    ]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: classNames?.root, ...props, onMouseLeave: handleMouseLeave, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: classNames?.header, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          className: classNames?.navButton,
+          onClick: () => navigateMonth(-1),
+          "aria-label": ctx.labels.prevMonth,
+          children: "<"
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: classNames?.title, "aria-live": "polite", children: title }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          className: classNames?.navButton,
+          onClick: () => navigateMonth(1),
+          "aria-label": ctx.labels.nextMonth,
+          children: ">"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      "table",
+      {
+        ref: gridRef,
+        role: "grid",
+        "aria-label": title,
+        "aria-rowcount": weeks.length + 1,
+        "aria-colcount": 7,
+        className: classNames?.grid,
+        onKeyDown: handleKeyDown,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("thead", { children: /* @__PURE__ */ jsxRuntime.jsxs("tr", { role: "row", "aria-rowindex": 1, children: [
+            showWeekNumber ? /* @__PURE__ */ jsxRuntime.jsx("th", { scope: "col", "aria-hidden": "true", className: classNames?.weekNumberHeader, children: "#" }) : null,
+            weekdays.map((day, colIndex) => /* @__PURE__ */ jsxRuntime.jsx(
+              "th",
+              {
+                role: "columnheader",
+                abbr: day.full,
+                scope: "col",
+                "aria-colindex": colIndex + 1,
+                className: classNames?.weekdayHeader,
+                children: day.short
+              },
+              day.short
+            ))
+          ] }) }),
+          /* @__PURE__ */ jsxRuntime.jsx("tbody", { children: weeks.map((week, weekIndex) => /* @__PURE__ */ jsxRuntime.jsxs(
+            "tr",
+            {
+              role: "row",
+              "aria-rowindex": weekIndex + 2,
+              className: classNames?.gridRow,
+              children: [
+                showWeekNumber ? /* @__PURE__ */ jsxRuntime.jsx(
+                  "th",
+                  {
+                    scope: "row",
+                    "aria-hidden": "true",
+                    className: classNames?.weekNumber,
+                    "data-week-number": true,
+                    children: core.getISOWeekNumber(week[thursdayIndex].isoString)
+                  }
+                ) : null,
+                week.map((day, colIndex) => {
+                  const dayClasses = [
+                    classNames?.day,
+                    day.isRangeStart && classNames?.dayRangeStart,
+                    day.isRangeEnd && classNames?.dayRangeEnd,
+                    day.isInRange && classNames?.dayInRange,
+                    day.isToday && classNames?.dayToday,
+                    day.isDisabled && classNames?.dayDisabled,
+                    !day.isCurrentMonth && classNames?.dayOutsideMonth
+                  ].filter(Boolean).join(" ") || void 0;
+                  const isSelected = selectionMode === "week" ? day.isRangeStart || day.isRangeEnd || day.isInRange : day.isRangeStart || day.isRangeEnd;
+                  return /* @__PURE__ */ jsxRuntime.jsx(
+                    "td",
+                    {
+                      role: "gridcell",
+                      "aria-colindex": colIndex + 1,
+                      "aria-selected": isSelected || void 0,
+                      "aria-disabled": day.isDisabled || void 0,
+                      "aria-current": day.isToday ? "date" : void 0,
+                      className: classNames?.gridCell,
+                      children: /* @__PURE__ */ jsxRuntime.jsx(
+                        "button",
+                        {
+                          type: "button",
+                          tabIndex: day.isFocused ? 0 : -1,
+                          disabled: day.isDisabled,
+                          "data-focused": day.isFocused || void 0,
+                          "data-range-start": day.isRangeStart || void 0,
+                          "data-range-end": day.isRangeEnd || void 0,
+                          "data-in-range": day.isInRange || void 0,
+                          "data-today": day.isToday || void 0,
+                          "data-outside-month": !day.isCurrentMonth || void 0,
+                          className: dayClasses,
+                          onClick: () => handleDayClick(day),
+                          onMouseEnter: () => handleDayMouseEnter(day),
+                          "aria-label": safeFormatFullDate2(day.isoString, locale),
+                          children: day.dayNumber
+                        }
+                      )
+                    },
+                    day.isoString
+                  );
+                })
+              ]
+            },
+            weekIndex
+          )) })
+        ]
+      }
+    )
+  ] });
+}
+function RangePickerPresets({ classNames, children, ...props }) {
+  const ctx = useRangePickerContext("RangePicker.Presets");
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { role: "group", "aria-label": ctx.labels.presetsGroup, className: classNames?.root, ...props, children });
+}
+function resolvePreset(key, today, adapter) {
+  switch (key) {
+    case "today":
+      return { start: today, end: today };
+    case "yesterday": {
+      const yesterday = adapter.addDays(today, -1);
+      return { start: yesterday, end: yesterday };
+    }
+    case "last7days":
+      return { start: adapter.addDays(today, -6), end: today };
+    case "last30days":
+      return { start: adapter.addDays(today, -29), end: today };
+    case "thisWeek":
+      return {
+        start: adapter.startOfDay(adapter.startOfWeek(today)),
+        end: adapter.startOfDay(adapter.endOfWeek(today))
+      };
+    case "lastWeek": {
+      const prevWeek = adapter.addDays(today, -7);
+      return {
+        start: adapter.startOfDay(adapter.startOfWeek(prevWeek)),
+        end: adapter.startOfDay(adapter.endOfWeek(prevWeek))
+      };
+    }
+    case "thisMonth":
+      return {
+        start: adapter.startOfMonth(today),
+        end: adapter.startOfDay(adapter.endOfMonth(today))
+      };
+    case "lastMonth": {
+      const prevMonth = adapter.addMonths(today, -1);
+      return {
+        start: adapter.startOfMonth(prevMonth),
+        end: adapter.startOfDay(adapter.endOfMonth(prevMonth))
+      };
+    }
+    case "thisYear": {
+      const currentMonth = new Date(today).getUTCMonth();
+      const yearStart = adapter.startOfMonth(adapter.addMonths(today, -currentMonth));
+      return { start: yearStart, end: today };
+    }
+  }
+}
+function RangePickerPreset({
+  value: presetKey,
+  range: directRange,
+  children,
+  onClick,
+  ...props
+}) {
+  const ctx = useRangePickerContext("RangePicker.Preset");
+  const resolved = react.useMemo(() => {
+    if (directRange) return directRange;
+    if (presetKey)
+      return resolvePreset(presetKey, ctx.adapter.today(ctx.displayTimezone), ctx.adapter);
+    return null;
+  }, [directRange, presetKey, ctx.adapter, ctx.displayTimezone]);
+  const handleClick = react.useCallback(
+    (e) => {
+      if (ctx.isDisabled || ctx.isReadOnly) return;
+      if (!resolved) return;
+      ctx.setRange(resolved);
+      ctx.close();
+      onClick?.(e);
+    },
+    [ctx, resolved, onClick]
+  );
+  const isActive = react.useMemo(() => {
+    if (!ctx.value.start || !ctx.value.end || !resolved || !resolved.start || !resolved.end) {
+      return false;
+    }
+    return ctx.adapter.isSameDay(ctx.value.start, resolved.start) && ctx.adapter.isSameDay(ctx.value.end, resolved.end);
+  }, [ctx.value.start, ctx.value.end, ctx.adapter, resolved]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "button",
+    {
+      type: "button",
+      "aria-pressed": isActive,
+      "data-active": isActive || void 0,
+      disabled: ctx.isDisabled,
+      onClick: handleClick,
+      ...props,
+      children
+    }
+  );
+}
+
+// src/components/RangePicker/index.ts
+var RangePicker = Object.assign(RangePickerRoot, {
+  Input: RangePickerInput,
+  Popover: RangePickerPopover,
+  Calendar: RangePickerCalendar,
+  Presets: RangePickerPresets,
+  Preset: RangePickerPreset
+});
+var TimePickerContext = react.createContext(null);
+function useTimePickerContext(componentName) {
+  const context = react.useContext(TimePickerContext);
+  if (!context) {
+    throw new Error(
+      `[${componentName}] TimePicker.Root \uB0B4\uBD80\uC5D0\uC11C \uC0AC\uC6A9\uD574\uC57C \uD569\uB2C8\uB2E4.
+
+\uC62C\uBC14\uB978 \uC0AC\uC6A9\uBC95:
+  <TimePicker>
+    <TimePicker.${componentName.replace("TimePicker.", "")} />
+  </TimePicker>`
+    );
+  }
+  return context;
+}
+function TimePickerRoot({
+  value: controlledValue,
+  defaultValue,
+  onChange,
+  format = "24h",
+  step = 1,
+  withSeconds = false,
+  displayTimezone,
+  disabled = false,
+  readOnly = false,
+  filterTime,
+  adapter: adapterProp,
+  labels: labelsProp,
+  children
+}) {
+  const adapter = resolveAdapter(adapterProp, getDefaultAdapter(), "TimePicker");
+  const pickerId = react.useId();
+  const mergedLabels = react.useMemo(
+    () => ({ ...core.DEFAULT_TIMEPICKER_LABELS, ...labelsProp }),
+    [labelsProp]
+  );
+  const isControlled = react.useRef(controlledValue !== void 0).current;
+  const [uncontrolledValue, setUncontrolledValue] = react.useState(
+    defaultValue ?? null
+  );
+  const currentValue = isControlled ? controlledValue ?? null : uncontrolledValue;
+  const currentTime = react.useMemo(() => {
+    if (!currentValue) return { hours: 0, minutes: 0, seconds: 0 };
+    return displayTimezone ? core.getTimeInTimezone(currentValue, displayTimezone) : core.getTime(currentValue);
+  }, [currentValue, displayTimezone]);
+  const setTime = react.useCallback(
+    (partial) => {
+      if (disabled || readOnly) return;
+      const base = currentValue ?? adapter.today(displayTimezone);
+      const newIso = displayTimezone ? core.setTimeInTimezone(base, partial, displayTimezone) : core.setTime(base, partial);
+      if (!isControlled) {
+        setUncontrolledValue(newIso);
+      }
+      onChange?.(newIso);
+    },
+    [disabled, readOnly, currentValue, displayTimezone, isControlled, onChange, adapter]
+  );
+  const contextValue = react.useMemo(
+    () => ({
+      value: currentValue,
+      setTime,
+      format,
+      step,
+      withSeconds,
+      displayTimezone,
+      isDisabled: disabled,
+      isReadOnly: readOnly,
+      currentTime,
+      pickerId,
+      labels: mergedLabels,
+      filterTime
+    }),
+    [
+      currentValue,
+      setTime,
+      format,
+      step,
+      withSeconds,
+      displayTimezone,
+      disabled,
+      readOnly,
+      currentTime,
+      pickerId,
+      mergedLabels,
+      filterTime
+    ]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(TimePickerContext.Provider, { value: contextValue, children });
+}
+var TimePickerInput = react.forwardRef(
+  function TimePickerInput2({ onBlur, onKeyDown, ...props }, ref) {
+    const ctx = useTimePickerContext("TimePicker.Input");
+    const [inputText, setInputText] = react.useState(null);
+    react.useEffect(() => {
+      setInputText(null);
+    }, [ctx.value]);
+    const displayValue = inputText !== null ? inputText : core.formatTimeString(ctx.currentTime, ctx.withSeconds);
+    const commitInput = react.useCallback(() => {
+      if (inputText === null) return;
+      const parsed = core.parseTimeString(inputText);
+      if (parsed) {
+        ctx.setTime(parsed);
+      }
+      setInputText(null);
+    }, [inputText, ctx]);
+    const handleChange = react.useCallback((e) => {
+      setInputText(e.target.value);
+    }, []);
+    const handleBlur = react.useCallback(
+      (e) => {
+        commitInput();
+        onBlur?.(e);
+      },
+      [commitInput, onBlur]
+    );
+    const handleKeyDown = react.useCallback(
+      (e) => {
+        if (e.key === "Enter") {
+          commitInput();
+        }
+        onKeyDown?.(e);
+      },
+      [commitInput, onKeyDown]
+    );
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "input",
+      {
+        ref,
+        type: "text",
+        inputMode: "numeric",
+        autoComplete: "off",
+        "aria-label": ctx.labels.timeInput,
+        placeholder: ctx.withSeconds ? "HH:MM:SS" : "HH:MM",
+        value: displayValue,
+        disabled: ctx.isDisabled || props.disabled,
+        readOnly: ctx.isReadOnly,
+        onChange: handleChange,
+        onBlur: handleBlur,
+        onKeyDown: handleKeyDown,
+        ...props
+      }
+    );
+  }
+);
+TimePickerInput.displayName = "TimePicker.Input";
+function useListboxNavigation({
+  items,
+  onSelect,
+  disabled = false
+}) {
+  const listRef = react.useRef(null);
+  const rafIdRef = react.useRef(0);
+  react.useEffect(() => {
+    return () => cancelAnimationFrame(rafIdRef.current);
+  }, []);
+  const handleKeyDown = react.useCallback(
+    (e, item) => {
+      if (disabled) return;
+      const currentIndex = items.indexOf(item);
+      let newIndex = -1;
+      if (e.key === "ArrowDown") {
+        newIndex = Math.min(currentIndex + 1, items.length - 1);
+      } else if (e.key === "ArrowUp") {
+        newIndex = Math.max(currentIndex - 1, 0);
+      } else if (e.key === "Home") {
+        newIndex = 0;
+      } else if (e.key === "End") {
+        newIndex = items.length - 1;
+      } else if (e.key === "Enter" || e.key === " ") {
+        e.preventDefault();
+        onSelect(item);
+        return;
+      } else {
+        return;
+      }
+      e.preventDefault();
+      const target = items[newIndex];
+      if (target !== void 0) {
+        onSelect(target);
+        cancelAnimationFrame(rafIdRef.current);
+        rafIdRef.current = requestAnimationFrame(() => {
+          const next = listRef.current?.querySelector('[data-selected="true"]');
+          next?.focus();
+        });
+      }
+    },
+    [items, onSelect, disabled]
+  );
+  return { listRef, handleKeyDown };
+}
+function TimePickerHourList({ classNames, ...props }) {
+  const ctx = useTimePickerContext("TimePicker.HourList");
+  const { format, step, currentTime, isDisabled, isReadOnly, filterTime } = ctx;
+  const hours = react.useMemo(() => core.generateHours(format), [format]);
+  const selectedHourDisplay = format === "12h" ? core.to12Hour(currentTime.hours).hours12 : currentTime.hours;
+  const currentPeriod = format === "12h" ? core.to12Hour(currentTime.hours).period : null;
+  const fullyDisabledHours24 = react.useMemo(() => {
+    if (!filterTime) return null;
+    const disabled = /* @__PURE__ */ new Set();
+    for (let h = 0; h < 24; h++) {
+      let allRejected = true;
+      for (let m = 0; m < 60; m += step) {
+        if (!filterTime(h, m)) {
+          allRejected = false;
+          break;
+        }
+      }
+      if (allRejected) disabled.add(h);
+    }
+    return disabled;
+  }, [filterTime, step]);
+  const isHourDisabled = react.useCallback(
+    (hourDisplay) => {
+      if (!fullyDisabledHours24) return false;
+      const hours24 = format === "12h" && currentPeriod ? core.to24Hour(hourDisplay, currentPeriod) : hourDisplay;
+      return fullyDisabledHours24.has(hours24);
+    },
+    [fullyDisabledHours24, format, currentPeriod]
+  );
+  const handleSelect = react.useCallback(
+    (hourDisplay) => {
+      if (isDisabled || isReadOnly) return;
+      if (isHourDisabled(hourDisplay)) return;
+      const hours24 = format === "12h" && currentPeriod ? core.to24Hour(hourDisplay, currentPeriod) : hourDisplay;
+      ctx.setTime({ hours: hours24 });
+    },
+    [format, currentPeriod, ctx, isDisabled, isReadOnly, isHourDisabled]
+  );
+  const { listRef, handleKeyDown } = useListboxNavigation({
+    items: hours,
+    onSelect: handleSelect,
+    disabled: isDisabled || isReadOnly
+  });
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "ul",
+    {
+      ref: listRef,
+      role: "listbox",
+      "aria-label": ctx.labels.hourList,
+      "aria-disabled": isDisabled || void 0,
+      className: classNames?.root,
+      ...props,
+      children: hours.map((hour) => {
+        const isSelected = hour === selectedHourDisplay;
+        const isHourFullyDisabled = isHourDisabled(hour);
+        const optionClass = [classNames?.option, isSelected && classNames?.optionSelected].filter(Boolean).join(" ") || void 0;
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          "li",
+          {
+            role: "option",
+            "aria-selected": isSelected,
+            "aria-disabled": isDisabled || isHourFullyDisabled || void 0,
+            "aria-label": ctx.labels.hourOption(hour),
+            "data-selected": isSelected || void 0,
+            tabIndex: isSelected ? 0 : -1,
+            className: optionClass,
+            onClick: () => handleSelect(hour),
+            onKeyDown: (e) => handleKeyDown(e, hour),
+            children: String(hour).padStart(2, "0")
+          },
+          hour
+        );
+      })
+    }
+  );
+}
+function TimePickerMinuteList({ classNames, ...props }) {
+  const ctx = useTimePickerContext("TimePicker.MinuteList");
+  const { step, currentTime, isDisabled, isReadOnly, filterTime } = ctx;
+  const minutes = react.useMemo(() => core.generateMinutes(step), [step]);
+  const isMinuteDisabled = react.useCallback(
+    (minute) => {
+      if (!filterTime) return false;
+      return filterTime(currentTime.hours, minute);
+    },
+    [filterTime, currentTime.hours]
+  );
+  const handleSelect = react.useCallback(
+    (minute) => {
+      if (isDisabled || isReadOnly) return;
+      if (isMinuteDisabled(minute)) return;
+      ctx.setTime({ minutes: minute });
+    },
+    [ctx, isDisabled, isReadOnly, isMinuteDisabled]
+  );
+  const { listRef, handleKeyDown } = useListboxNavigation({
+    items: minutes,
+    onSelect: handleSelect,
+    disabled: isDisabled || isReadOnly
+  });
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "ul",
+    {
+      ref: listRef,
+      role: "listbox",
+      "aria-label": ctx.labels.minuteList,
+      "aria-disabled": isDisabled || void 0,
+      className: classNames?.root,
+      ...props,
+      children: minutes.map((minute) => {
+        const isSelected = minute === currentTime.minutes;
+        const isMinuteFullyDisabled = isMinuteDisabled(minute);
+        const optionClass = [classNames?.option, isSelected && classNames?.optionSelected].filter(Boolean).join(" ") || void 0;
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          "li",
+          {
+            role: "option",
+            "aria-selected": isSelected,
+            "aria-disabled": isDisabled || isMinuteFullyDisabled || void 0,
+            "aria-label": ctx.labels.minuteOption(minute),
+            "data-selected": isSelected || void 0,
+            tabIndex: isSelected ? 0 : -1,
+            className: optionClass,
+            onClick: () => handleSelect(minute),
+            onKeyDown: (e) => handleKeyDown(e, minute),
+            children: String(minute).padStart(2, "0")
+          },
+          minute
+        );
+      })
+    }
+  );
+}
+function TimePickerAmPmToggle({ classNames, ...props }) {
+  const ctx = useTimePickerContext("TimePicker.AmPmToggle");
+  const amRef = react.useRef(null);
+  const pmRef = react.useRef(null);
+  const setPeriod = react.useCallback(
+    (newPeriod) => {
+      if (ctx.isDisabled || ctx.isReadOnly) return;
+      const { hours12 } = core.to12Hour(ctx.currentTime.hours);
+      const newHours24 = core.to24Hour(hours12, newPeriod);
+      ctx.setTime({ hours: newHours24 });
+    },
+    [ctx]
+  );
+  if (ctx.format !== "12h") return null;
+  const { period } = core.to12Hour(ctx.currentTime.hours);
+  const focusOther = (target) => {
+    (target === "AM" ? amRef : pmRef).current?.focus();
+  };
+  const handleKeyDown = (e, target) => {
+    switch (e.key) {
+      case "ArrowRight":
+      case "ArrowDown":
+      case "ArrowLeft":
+      case "ArrowUp": {
+        e.preventDefault();
+        const next = target === "AM" ? "PM" : "AM";
+        setPeriod(next);
+        focusOther(next);
+        break;
+      }
+      case "Home": {
+        e.preventDefault();
+        setPeriod("AM");
+        focusOther("AM");
+        break;
+      }
+      case "End": {
+        e.preventDefault();
+        setPeriod("PM");
+        focusOther("PM");
+        break;
+      }
+      case " ":
+      case "Enter": {
+        e.preventDefault();
+        setPeriod(target);
+        break;
+      }
+    }
+  };
+  const renderButton = (target) => {
+    const isSelected = period === target;
+    const optionClass = [classNames?.option, isSelected && classNames?.optionSelected].filter(Boolean).join(" ") || void 0;
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        ref: target === "AM" ? amRef : pmRef,
+        type: "button",
+        role: "radio",
+        "aria-checked": isSelected,
+        tabIndex: isSelected ? 0 : -1,
+        "data-selected": isSelected || void 0,
+        disabled: ctx.isDisabled,
+        className: optionClass,
+        onClick: () => setPeriod(target),
+        onKeyDown: (e) => handleKeyDown(e, target),
+        children: target
+      }
+    );
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      role: "radiogroup",
+      "aria-label": ctx.labels.amPmToggle,
+      className: classNames?.root,
+      ...props,
+      children: [
+        renderButton("AM"),
+        renderButton("PM")
+      ]
+    }
+  );
+}
+
+// src/components/TimePicker/index.ts
+var TimePicker = Object.assign(TimePickerRoot, {
+  Input: TimePickerInput,
+  HourList: TimePickerHourList,
+  MinuteList: TimePickerMinuteList,
+  AmPmToggle: TimePickerAmPmToggle
+});
+function DateTimePickerRoot({
+  value: controlledValue,
+  defaultValue,
+  onChange,
+  onOpenChange,
+  onCalendarNavigate,
+  format = "24h",
+  step = 1,
+  withSeconds = false,
+  filterTime,
+  disabled = false,
+  readOnly = false,
+  weekStartsOn = 0,
+  displayFormat = "yyyy-MM-dd HH:mm",
+  locale = "en-US",
+  displayTimezone,
+  adapter: adapterProp,
+  labels: labelsProp,
+  children
+}) {
+  const adapter = resolveAdapter(adapterProp, getDefaultAdapter(), "DateTimePicker");
+  const pickerId = react.useId();
+  const mergedDateLabels = react.useMemo(
+    () => ({ ...core.DEFAULT_DATEPICKER_LABELS, ...labelsProp }),
+    [labelsProp]
+  );
+  const mergedTimeLabels = react.useMemo(
+    () => ({ ...core.DEFAULT_TIMEPICKER_LABELS, ...labelsProp }),
+    [labelsProp]
+  );
+  const isControlled = react.useRef(controlledValue !== void 0).current;
+  const referenceRef = react.useRef(null);
+  const [uncontrolledValue, setUncontrolledValue] = react.useState(
+    defaultValue ?? null
+  );
+  const currentValue = isControlled ? controlledValue ?? null : uncontrolledValue;
+  const [isOpen, setIsOpen] = react.useState(false);
+  const [viewMonth, setViewMonth] = react.useState(
+    () => currentValue ?? adapter.today(displayTimezone)
+  );
+  const [focusedDate, setFocusedDate] = react.useState(
+    () => currentValue ?? adapter.today(displayTimezone)
+  );
+  useChangeEffect(isOpen, onOpenChange);
+  const viewMonthStart = react.useMemo(() => adapter.startOfMonth(viewMonth), [viewMonth, adapter]);
+  useChangeEffect(viewMonthStart, onCalendarNavigate);
+  const isDisabled = typeof disabled === "boolean" ? disabled : false;
+  const disabledRules = react.useMemo(
+    () => Array.isArray(disabled) ? disabled : [],
+    [disabled]
+  );
+  const currentTime = react.useMemo(() => {
+    if (!currentValue) return { hours: 0, minutes: 0, seconds: 0 };
+    return displayTimezone ? core.getTimeInTimezone(currentValue, displayTimezone) : core.getTime(currentValue);
+  }, [currentValue, displayTimezone]);
+  const updateValue = react.useCallback(
+    (next) => {
+      if (isDisabled || readOnly) return;
+      if (!isControlled) {
+        setUncontrolledValue(next);
+      }
+      onChange?.(next);
+    },
+    [isControlled, isDisabled, readOnly, onChange]
+  );
+  const selectDate = react.useCallback(
+    (newDateIso) => {
+      if (newDateIso === null) {
+        updateValue(null);
+        return;
+      }
+      const normalizedDate = displayTimezone ? core.civilMidnightFromUtcDay(newDateIso, displayTimezone) : newDateIso;
+      const time = currentValue ? displayTimezone ? core.getTimeInTimezone(currentValue, displayTimezone) : core.getTime(currentValue) : currentTime;
+      const merged = displayTimezone ? core.setTimeInTimezone(normalizedDate, time, displayTimezone) : core.setTime(normalizedDate, time);
+      updateValue(merged);
+    },
+    [currentValue, currentTime, updateValue, displayTimezone]
+  );
+  const setTime = react.useCallback(
+    (partial) => {
+      const base = currentValue ?? adapter.today(displayTimezone);
+      const merged = displayTimezone ? core.setTimeInTimezone(base, partial, displayTimezone) : core.setTime(base, partial);
+      updateValue(merged);
+    },
+    [currentValue, updateValue, displayTimezone, adapter]
+  );
+  const open = react.useCallback(() => {
+    if (isDisabled || readOnly) return;
+    setIsOpen(true);
+    const target = currentValue ?? adapter.today(displayTimezone);
+    setViewMonth(target);
+    setFocusedDate(target);
+  }, [isDisabled, readOnly, currentValue, adapter, displayTimezone]);
+  const close = react.useCallback(() => {
+    setIsOpen(false);
+  }, []);
+  const toggle = react.useCallback(() => {
+    if (isOpen) close();
+    else open();
+  }, [isOpen, open, close]);
+  const dateContext = react.useMemo(
+    () => ({
+      referenceRef,
+      value: currentValue,
+      selectDate,
+      isOpen,
+      open,
+      close,
+      toggle,
+      viewMonth,
+      setViewMonth,
+      focusedDate,
+      setFocusedDate,
+      adapter,
+      disabled: disabledRules,
+      weekStartsOn,
+      displayFormat,
+      locale,
+      displayTimezone,
+      isDisabled,
+      isReadOnly: readOnly,
+      pickerId,
+      labels: mergedDateLabels
+    }),
+    [
+      currentValue,
+      selectDate,
+      isOpen,
+      open,
+      close,
+      toggle,
+      viewMonth,
+      focusedDate,
+      adapter,
+      disabledRules,
+      weekStartsOn,
+      displayFormat,
+      locale,
+      displayTimezone,
+      isDisabled,
+      readOnly,
+      pickerId,
+      mergedDateLabels
+    ]
+  );
+  const timeContext = react.useMemo(
+    () => ({
+      value: currentValue,
+      setTime,
+      format,
+      step,
+      withSeconds,
+      displayTimezone,
+      isDisabled,
+      isReadOnly: readOnly,
+      currentTime,
+      pickerId,
+      labels: mergedTimeLabels,
+      filterTime
+    }),
+    [
+      currentValue,
+      setTime,
+      format,
+      step,
+      withSeconds,
+      displayTimezone,
+      isDisabled,
+      readOnly,
+      currentTime,
+      pickerId,
+      mergedTimeLabels,
+      filterTime
+    ]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(DatePickerContext.Provider, { value: dateContext, children: /* @__PURE__ */ jsxRuntime.jsx(TimePickerContext.Provider, { value: timeContext, children }) });
+}
+var DateTimePickerInput = react.forwardRef(
+  function DateTimePickerInput2({ onClick, onKeyDown, ...props }, ref) {
+    const ctx = useDatePickerContext("DateTimePicker.Input");
+    let displayValue = "";
+    if (ctx.value) {
+      try {
+        const datePart = ctx.adapter.format(ctx.value, "yyyy-MM-dd", ctx.displayTimezone);
+        const time = ctx.displayTimezone ? core.getTimeInTimezone(ctx.value, ctx.displayTimezone) : core.getTime(ctx.value);
+        displayValue = `${datePart} ${core.formatTimeString(time)}`;
+      } catch {
+        displayValue = ctx.value;
+      }
+    }
+    const handleClick = react.useCallback(
+      (e) => {
+        if (!ctx.isOpen) ctx.open();
+        onClick?.(e);
+      },
+      [ctx, onClick]
+    );
+    const handleKeyDown = react.useCallback(
+      (e) => {
+        if (e.key === "Escape") {
+          ctx.close();
+        } else if (e.key === "Enter" && ctx.isOpen) {
+          e.preventDefault();
+        } else if (e.key === "ArrowDown" && !ctx.isOpen) {
+          e.preventDefault();
+          ctx.open();
+        }
+        onKeyDown?.(e);
+      },
+      [ctx, onKeyDown]
+    );
+    const calendarId = `${ctx.pickerId}-calendar`;
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "input",
+      {
+        ref: (node) => {
+          ctx.referenceRef.current = node;
+          if (typeof ref === "function") ref(node);
+          else if (ref) ref.current = node;
+        },
+        type: "text",
+        role: "combobox",
+        readOnly: true,
+        "aria-label": ctx.labels.dateTimeInput ?? "Date and time",
+        "aria-expanded": ctx.isOpen,
+        "aria-haspopup": "dialog",
+        "aria-controls": ctx.isOpen ? calendarId : void 0,
+        "aria-autocomplete": "none",
+        autoComplete: "off",
+        value: displayValue,
+        disabled: ctx.isDisabled || props.disabled,
+        onClick: handleClick,
+        onKeyDown: handleKeyDown,
+        ...props
+      }
+    );
+  }
+);
+DateTimePickerInput.displayName = "DateTimePicker.Input";
+
+// src/components/DateTimePicker/index.ts
+var DateTimePicker = Object.assign(DateTimePickerRoot, {
+  Input: DateTimePickerInput,
+  Popover: DatePickerPopover,
+  Calendar: DatePickerCalendar,
+  MonthGrid: DatePickerMonthGrid,
+  YearGrid: DatePickerYearGrid,
+  HourList: TimePickerHourList,
+  MinuteList: TimePickerMinuteList,
+  AmPmToggle: TimePickerAmPmToggle
+});
+function MonthPickerRoot(props) {
+  const displayFormat = props.displayFormat ?? "yyyy-MM";
+  return /* @__PURE__ */ jsxRuntime.jsx(DatePickerRoot, { ...props, displayFormat });
+}
+function MonthPickerGrid({ classNames, ...props }) {
+  const ctx = useDatePickerContext("MonthPicker.Grid");
+  const { adapter, viewMonth, locale, value, displayTimezone, labels, disabled } = ctx;
+  const currentYear = adapter.getYear(viewMonth);
+  const [valueYear, valueMonthZeroBased] = react.useMemo(() => {
+    if (!value) return [null, null];
+    try {
+      const [y, m] = adapter.format(value, "yyyy-MM", displayTimezone).split("-").map(Number);
+      return [y, m - 1];
+    } catch {
+      return [null, null];
+    }
+  }, [value, adapter, displayTimezone]);
+  const [today, setToday] = react.useState(null);
+  react.useEffect(() => {
+    setToday(adapter.today(displayTimezone));
+  }, [adapter, displayTimezone]);
+  const todayYear = today !== null ? adapter.getYear(today) : -1;
+  const todayMonth = today !== null ? adapter.getMonth(today) : -1;
+  const monthDisabledFlags = react.useMemo(
+    () => Array.from({ length: 12 }, (_, i) => {
+      const monthStart = new Date(Date.UTC(currentYear, i, 1)).toISOString();
+      return isRangeFullyDisabled(monthStart, adapter.endOfMonth(monthStart), disabled, adapter);
+    }),
+    [currentYear, disabled, adapter]
+  );
+  const navigateYear = react.useCallback(
+    (direction) => {
+      ctx.setViewMonth(adapter.addYears(viewMonth, direction));
+    },
+    [adapter, viewMonth, ctx]
+  );
+  const handleMonthSelect = react.useCallback(
+    (monthIndex) => {
+      if (monthDisabledFlags[monthIndex]) return;
+      const target = new Date(Date.UTC(currentYear, monthIndex, 1)).toISOString();
+      ctx.selectDate(target);
+    },
+    [currentYear, ctx, monthDisabledFlags]
+  );
+  const naturalIndex = valueYear === currentYear && valueMonthZeroBased !== null ? valueMonthZeroBased : adapter.getMonth(viewMonth);
+  const firstEnabled = monthDisabledFlags.findIndex((d) => !d);
+  const initialIndex = monthDisabledFlags[naturalIndex] ? firstEnabled === -1 ? naturalIndex : firstEnabled : naturalIndex;
+  const { gridRef, focusedIndex, handleKeyDown } = useGridState({
+    initialIndex,
+    disabledFlags: monthDisabledFlags,
+    onSelect: handleMonthSelect,
+    onPageUp: () => navigateYear(-1),
+    onPageDown: () => navigateYear(1),
+    onEscape: ctx.close
+  });
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: classNames?.root, ...props, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: classNames?.header, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          className: classNames?.navButton,
+          onClick: () => navigateYear(-1),
+          "aria-label": labels.prevYear,
+          children: "<"
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: classNames?.title, children: currentYear }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          className: classNames?.navButton,
+          onClick: () => navigateYear(1),
+          "aria-label": labels.nextYear,
+          children: ">"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        ref: gridRef,
+        role: "grid",
+        "aria-label": `${currentYear} months`,
+        className: classNames?.grid,
+        onKeyDown: handleKeyDown,
+        children: Array.from({ length: 4 }, (_, rowIndex) => /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            role: "row",
+            className: classNames?.gridRow,
+            style: { display: "grid", gridTemplateColumns: "repeat(3, 1fr)" },
+            children: Array.from({ length: 3 }, (_2, col) => {
+              const i = rowIndex * 3 + col;
+              const isSelected = valueYear === currentYear && valueMonthZeroBased === i;
+              const isCurrent = todayYear === currentYear && todayMonth === i;
+              const isFocused = i === focusedIndex;
+              const isDisabled = monthDisabledFlags[i] ?? false;
+              const cls = [
+                classNames?.month,
+                isSelected && classNames?.monthSelected,
+                isCurrent && classNames?.monthCurrent,
+                isDisabled && classNames?.monthDisabled
+              ].filter(Boolean).join(" ") || void 0;
+              return /* @__PURE__ */ jsxRuntime.jsx(
+                "button",
+                {
+                  type: "button",
+                  role: "gridcell",
+                  tabIndex: isFocused ? 0 : -1,
+                  disabled: isDisabled,
+                  "aria-selected": isSelected || void 0,
+                  "aria-disabled": isDisabled || void 0,
+                  "aria-current": isCurrent ? "date" : void 0,
+                  "data-selected": isSelected || void 0,
+                  "data-current": isCurrent || void 0,
+                  "data-focused": isFocused || void 0,
+                  className: cls,
+                  onClick: () => handleMonthSelect(i),
+                  children: core.getMonthName(i, locale)
+                },
+                i
+              );
+            })
+          },
+          rowIndex
+        ))
+      }
+    )
+  ] });
+}
+
+// src/components/MonthPicker/index.ts
+var MonthPicker = Object.assign(MonthPickerRoot, {
+  Input: DatePickerInput,
+  Trigger: DatePickerTrigger,
+  Popover: DatePickerPopover,
+  Grid: MonthPickerGrid
+});
+function YearPickerRoot(props) {
+  const displayFormat = props.displayFormat ?? "yyyy";
+  return /* @__PURE__ */ jsxRuntime.jsx(DatePickerRoot, { ...props, displayFormat });
+}
+function YearPickerGrid({ classNames, ...props }) {
+  const ctx = useDatePickerContext("YearPicker.Grid");
+  const { adapter, viewMonth, value, displayTimezone, labels, disabled } = ctx;
+  const currentYear = adapter.getYear(viewMonth);
+  const decadeStart = currentYear - currentYear % 12;
+  const valueYear = react.useMemo(() => {
+    if (!value) return null;
+    try {
+      return Number(adapter.format(value, "yyyy", displayTimezone));
+    } catch {
+      return null;
+    }
+  }, [value, adapter, displayTimezone]);
+  const [today, setToday] = react.useState(null);
+  react.useEffect(() => {
+    setToday(adapter.today(displayTimezone));
+  }, [adapter, displayTimezone]);
+  const todayYear = today !== null ? adapter.getYear(today) : -1;
+  const yearDisabledFlags = react.useMemo(
+    () => Array.from({ length: 12 }, (_, i) => {
+      const year = decadeStart + i;
+      const yearStart = new Date(Date.UTC(year, 0, 1)).toISOString();
+      const yearEnd = new Date(Date.UTC(year, 11, 31, 23, 59, 59, 999)).toISOString();
+      return isRangeFullyDisabled(yearStart, yearEnd, disabled, adapter);
+    }),
+    [decadeStart, disabled, adapter]
+  );
+  const navigateDecade = react.useCallback(
+    (direction) => {
+      ctx.setViewMonth(adapter.addYears(viewMonth, direction * 12));
+    },
+    [adapter, viewMonth, ctx]
+  );
+  const handleYearSelect = react.useCallback(
+    (indexInDecade) => {
+      if (yearDisabledFlags[indexInDecade]) return;
+      const year = decadeStart + indexInDecade;
+      const target = new Date(Date.UTC(year, 0, 1)).toISOString();
+      ctx.selectDate(target);
+    },
+    [ctx, decadeStart, yearDisabledFlags]
+  );
+  const naturalIndex = valueYear !== null && valueYear >= decadeStart && valueYear <= decadeStart + 11 ? valueYear - decadeStart : currentYear - decadeStart;
+  const firstEnabled = yearDisabledFlags.findIndex((d) => !d);
+  const initialIndex = yearDisabledFlags[naturalIndex] ? firstEnabled === -1 ? naturalIndex : firstEnabled : naturalIndex;
+  const { gridRef, focusedIndex, handleKeyDown } = useGridState({
+    initialIndex,
+    disabledFlags: yearDisabledFlags,
+    onSelect: handleYearSelect,
+    onPageUp: () => navigateDecade(-1),
+    onPageDown: () => navigateDecade(1),
+    onEscape: ctx.close
+  });
+  const rangeLabel = `${decadeStart}\u2013${decadeStart + 11}`;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: classNames?.root, ...props, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: classNames?.header, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          className: classNames?.navButton,
+          onClick: () => navigateDecade(-1),
+          "aria-label": labels.prevDecade,
+          children: "<"
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: classNames?.title, children: rangeLabel }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          className: classNames?.navButton,
+          onClick: () => navigateDecade(1),
+          "aria-label": labels.nextDecade,
+          children: ">"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        ref: gridRef,
+        role: "grid",
+        "aria-label": rangeLabel,
+        className: classNames?.grid,
+        onKeyDown: handleKeyDown,
+        children: Array.from({ length: 4 }, (_, rowIndex) => /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            role: "row",
+            className: classNames?.gridRow,
+            style: { display: "grid", gridTemplateColumns: "repeat(3, 1fr)" },
+            children: Array.from({ length: 3 }, (_2, col) => {
+              const i = rowIndex * 3 + col;
+              const year = decadeStart + i;
+              const isSelected = year === valueYear;
+              const isCurrent = year === todayYear;
+              const isFocused = i === focusedIndex;
+              const isDisabled = yearDisabledFlags[i] ?? false;
+              const cls = [
+                classNames?.year,
+                isSelected && classNames?.yearSelected,
+                isCurrent && classNames?.yearCurrent,
+                isDisabled && classNames?.yearDisabled
+              ].filter(Boolean).join(" ") || void 0;
+              return /* @__PURE__ */ jsxRuntime.jsx(
+                "button",
+                {
+                  type: "button",
+                  role: "gridcell",
+                  tabIndex: isFocused ? 0 : -1,
+                  disabled: isDisabled,
+                  "aria-selected": isSelected || void 0,
+                  "aria-disabled": isDisabled || void 0,
+                  "aria-current": isCurrent ? "date" : void 0,
+                  "data-selected": isSelected || void 0,
+                  "data-current": isCurrent || void 0,
+                  "data-focused": isFocused || void 0,
+                  className: cls,
+                  onClick: () => handleYearSelect(i),
+                  children: year
+                },
+                i
+              );
+            })
+          },
+          rowIndex
+        ))
+      }
+    )
+  ] });
+}
+
+// src/components/YearPicker/index.ts
+var YearPicker = Object.assign(YearPickerRoot, {
+  Input: DatePickerInput,
+  Trigger: DatePickerTrigger,
+  Popover: DatePickerPopover,
+  Grid: YearPickerGrid
+});
+function WeekPickerRoot(props) {
+  return /* @__PURE__ */ jsxRuntime.jsx(RangePickerRoot, { ...props });
+}
+function WeekPickerCalendar(props) {
+  return /* @__PURE__ */ jsxRuntime.jsx(RangePickerCalendar, { ...props, selectionMode: "week" });
+}
+
+// src/components/WeekPicker/index.ts
+var WeekPicker = Object.assign(WeekPickerRoot, {
+  Input: RangePickerInput,
+  Popover: RangePickerPopover,
+  Calendar: WeekPickerCalendar
+});
+function useDatePicker(options = {}) {
+  const {
+    value: controlledValue,
+    defaultValue,
+    onChange,
+    disabled = [],
+    weekStartsOn = 0,
+    adapter: adapterProp,
+    displayTimezone
+  } = options;
+  const adapter = resolveAdapter(adapterProp, getDefaultAdapter(), "useDatePicker");
+  const pickerId = react.useId();
+  const isControlled = react.useRef(controlledValue !== void 0).current;
+  const [uncontrolledValue, setUncontrolledValue] = react.useState(
+    defaultValue ?? null
+  );
+  const currentValue = isControlled ? controlledValue ?? null : uncontrolledValue;
+  const [isOpen, setIsOpen] = react.useState(false);
+  const [viewMonth, setViewMonth] = react.useState(
+    currentValue ?? adapter.today(displayTimezone)
+  );
+  const [focusedDate, setFocusedDate] = react.useState(
+    currentValue ?? adapter.today(displayTimezone)
+  );
+  const selectDate = react.useCallback(
+    (iso) => {
+      const normalized = iso && displayTimezone ? core.civilMidnightFromUtcDay(iso, displayTimezone) : iso;
+      if (!isControlled) {
+        setUncontrolledValue(normalized);
+      }
+      onChange?.(normalized);
+      setIsOpen(false);
+    },
+    [isControlled, onChange, displayTimezone]
+  );
+  const open = react.useCallback(() => {
+    setIsOpen(true);
+    const target = currentValue ?? adapter.today(displayTimezone);
+    setViewMonth(target);
+    setFocusedDate(target);
+  }, [currentValue, adapter, displayTimezone]);
+  const close = react.useCallback(() => {
+    setIsOpen(false);
+  }, []);
+  const toggle = react.useCallback(() => {
+    if (isOpen) close();
+    else open();
+  }, [isOpen, open, close]);
+  const previousMonth = react.useCallback(() => {
+    const newMonth = adapter.addMonths(viewMonth, -1);
+    setViewMonth(newMonth);
+    setFocusedDate(adapter.startOfMonth(newMonth));
+  }, [adapter, viewMonth]);
+  const nextMonth = react.useCallback(() => {
+    const newMonth = adapter.addMonths(viewMonth, 1);
+    setViewMonth(newMonth);
+    setFocusedDate(adapter.startOfMonth(newMonth));
+  }, [adapter, viewMonth]);
+  const calendar = core.getCalendarDays(viewMonth, adapter, {
+    weekStartsOn,
+    selected: currentValue,
+    focusedDate,
+    disabled,
+    timezone: displayTimezone
+  });
+  return {
+    value: currentValue,
+    isOpen,
+    open,
+    close,
+    toggle,
+    selectDate,
+    viewMonth,
+    setViewMonth,
+    calendar,
+    focusedDate,
+    setFocusedDate,
+    previousMonth,
+    nextMonth,
+    pickerId,
+    adapter
+  };
+}
+var EMPTY_RANGE2 = { start: null, end: null };
+function useRangePicker(options = {}) {
+  const {
+    value: controlledValue,
+    defaultValue,
+    onChange,
+    disabled = [],
+    weekStartsOn = 0,
+    adapter: adapterProp,
+    displayTimezone
+  } = options;
+  const adapter = resolveAdapter(adapterProp, getDefaultAdapter(), "useRangePicker");
+  const pickerId = react.useId();
+  const isControlled = react.useRef(controlledValue !== void 0).current;
+  const [uncontrolledValue, setUncontrolledValue] = react.useState(
+    defaultValue ?? EMPTY_RANGE2
+  );
+  const currentValue = isControlled ? controlledValue ?? EMPTY_RANGE2 : uncontrolledValue;
+  const [isOpen, setIsOpen] = react.useState(false);
+  const [selectingTarget, setSelectingTarget] = react.useState("start");
+  const [hoverDate, setHoverDate] = react.useState(null);
+  const [viewMonth, setViewMonth] = react.useState(
+    currentValue.start ?? adapter.today(displayTimezone)
+  );
+  const [focusedDate, setFocusedDate] = react.useState(
+    currentValue.start ?? adapter.today(displayTimezone)
+  );
+  const setRange = react.useCallback(
+    (range) => {
+      if (!isControlled) {
+        setUncontrolledValue(range);
+      }
+      onChange?.(range);
+    },
+    [isControlled, onChange]
+  );
+  const selectDate = react.useCallback(
+    (iso) => {
+      const normalized = displayTimezone ? core.civilMidnightFromUtcDay(iso, displayTimezone) : iso;
+      if (selectingTarget === "start") {
+        setRange({ start: normalized, end: null });
+        setSelectingTarget("end");
+        setHoverDate(null);
+      } else {
+        const start = currentValue.start;
+        if (!start) {
+          setRange({ start: normalized, end: null });
+          setSelectingTarget("end");
+          return;
+        }
+        const newRange = adapter.isBefore(normalized, start) ? { start: normalized, end: start } : { start, end: normalized };
+        setRange(newRange);
+        setSelectingTarget("start");
+        setHoverDate(null);
+        setIsOpen(false);
+      }
+    },
+    [selectingTarget, currentValue.start, adapter, setRange, displayTimezone]
+  );
+  const open = react.useCallback(() => {
+    setIsOpen(true);
+    const target = currentValue.start ?? adapter.today(displayTimezone);
+    setViewMonth(target);
+    setFocusedDate(target);
+    if (currentValue.start && currentValue.end) {
+      setSelectingTarget("start");
+    }
+  }, [currentValue, adapter, displayTimezone]);
+  const close = react.useCallback(() => {
+    setIsOpen(false);
+    setHoverDate(null);
+  }, []);
+  const toggle = react.useCallback(() => {
+    if (isOpen) close();
+    else open();
+  }, [isOpen, open, close]);
+  const previousMonth = react.useCallback(() => {
+    const newMonth = adapter.addMonths(viewMonth, -1);
+    setViewMonth(newMonth);
+    setFocusedDate(adapter.startOfMonth(newMonth));
+  }, [adapter, viewMonth]);
+  const nextMonth = react.useCallback(() => {
+    const newMonth = adapter.addMonths(viewMonth, 1);
+    setViewMonth(newMonth);
+    setFocusedDate(adapter.startOfMonth(newMonth));
+  }, [adapter, viewMonth]);
+  const calendar = core.getCalendarDays(viewMonth, adapter, {
+    weekStartsOn,
+    focusedDate,
+    disabled,
+    range: currentValue,
+    rangeHover: hoverDate,
+    timezone: displayTimezone
+  });
+  return {
+    value: currentValue,
+    selectingTarget,
+    selectDate,
+    setRange,
+    isOpen,
+    open,
+    close,
+    toggle,
+    hoverDate,
+    setHoverDate,
+    viewMonth,
+    setViewMonth,
+    calendar,
+    focusedDate,
+    setFocusedDate,
+    previousMonth,
+    nextMonth,
+    pickerId,
+    adapter
+  };
+}
+function useTimePicker(options = {}) {
+  const {
+    value: controlledValue,
+    defaultValue,
+    onChange,
+    format = "24h",
+    step = 1,
+    displayTimezone,
+    adapter: adapterProp
+  } = options;
+  const adapter = resolveAdapter(adapterProp, getDefaultAdapter(), "useTimePicker");
+  const pickerId = react.useId();
+  const isControlled = react.useRef(controlledValue !== void 0).current;
+  const [uncontrolledValue, setUncontrolledValue] = react.useState(
+    defaultValue ?? null
+  );
+  const currentValue = isControlled ? controlledValue ?? null : uncontrolledValue;
+  const baseIso = currentValue ?? adapter.today();
+  const currentTime = react.useMemo(
+    () => displayTimezone ? core.getTimeInTimezone(baseIso, displayTimezone) : core.getTime(baseIso),
+    [baseIso, displayTimezone]
+  );
+  const setTime = react.useCallback(
+    (partial) => {
+      const newIso = displayTimezone ? core.setTimeInTimezone(baseIso, partial, displayTimezone) : core.setTime(baseIso, partial);
+      if (!isControlled) {
+        setUncontrolledValue(newIso);
+      }
+      onChange?.(newIso);
+    },
+    [baseIso, isControlled, onChange, displayTimezone]
+  );
+  const period = format === "12h" ? core.to12Hour(currentTime.hours).period : null;
+  const displayHour = format === "12h" ? core.to12Hour(currentTime.hours).hours12 : currentTime.hours;
+  const setHour = react.useCallback(
+    (hour) => {
+      const hours24 = format === "12h" && period ? core.to24Hour(hour, period) : hour;
+      setTime({ hours: hours24 });
+    },
+    [format, period, setTime]
+  );
+  const setMinute = react.useCallback((minute) => setTime({ minutes: minute }), [setTime]);
+  const setSecond = react.useCallback((second) => setTime({ seconds: second }), [setTime]);
+  const setPeriod = react.useCallback(
+    (newPeriod) => {
+      if (format !== "12h") return;
+      const newHours24 = core.to24Hour(displayHour, newPeriod);
+      setTime({ hours: newHours24 });
+    },
+    [format, displayHour, setTime]
+  );
+  return {
+    value: currentValue,
+    currentTime,
+    setTime,
+    setHour,
+    setMinute,
+    setSecond,
+    setPeriod,
+    availableHours: core.generateHours(format),
+    availableMinutes: core.generateMinutes(step),
+    format,
+    displayHour,
+    period,
+    pickerId
+  };
+}
+
+Object.defineProperty(exports, "DEFAULT_DATEPICKER_LABELS", {
+  enumerable: true,
+  get: function () { return core.DEFAULT_DATEPICKER_LABELS; }
+});
+Object.defineProperty(exports, "DEFAULT_DATETIMEPICKER_LABELS", {
+  enumerable: true,
+  get: function () { return core.DEFAULT_DATETIMEPICKER_LABELS; }
+});
+Object.defineProperty(exports, "DEFAULT_RANGEPICKER_LABELS", {
+  enumerable: true,
+  get: function () { return core.DEFAULT_RANGEPICKER_LABELS; }
+});
+Object.defineProperty(exports, "DEFAULT_TIMEPICKER_LABELS", {
+  enumerable: true,
+  get: function () { return core.DEFAULT_TIMEPICKER_LABELS; }
+});
+exports.DatePicker = DatePicker;
+exports.DateTimePicker = DateTimePicker;
+exports.MonthPicker = MonthPicker;
+exports.RangePicker = RangePicker;
+exports.TimePicker = TimePicker;
+exports.WeekPicker = WeekPicker;
+exports.YearPicker = YearPicker;
+exports.useDatePicker = useDatePicker;
+exports.useRangePicker = useRangePicker;
+exports.useTimePicker = useTimePicker;
+//# sourceMappingURL=headless.cjs.map
+//# sourceMappingURL=headless.cjs.map